def location(latitude, longitude, key):
print('key', key)
print("lat", latitude)
print('long', longitude)
data = query(float(latitude), float(longitude), key)
print(data)
return jsonify(data)
def check_redandunt(info):
if info.has_key('symbol'):
query_sql = "SELECT * FROM `stocks_info` WHERE `symbol` = '{}'".format(info['symbol'])
ret = query(query_sql)
if ret is not None and len(ret) > 0:
return True
else:
return False
def create_graph_handler(college, start, end, threshold):
start = dt_from_timestamp(start)
end = dt_from_timestamp(end)
posts = list(dao.query(college, start, end))
for post in posts:
post['color'] = 'red'
corpus = dao.join_comments(posts)
print len(corpus)
return cosine_graph(corpus, threshold)
def get(self):
args = self.parser.parse_args()
name = args.get('name')
tags = args.get('tag')
session = args.get('session')
musics = query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count():
return {'data': musics.all()}
return {'msg': '没有'}
def get(self):
self.parser.parse_args() # 解析参数，如果参数不满足，则直接返回
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
return marshal(img, self.img_fields)
else:
images = queryAll(Image)
data = {'data': images, "size": len(images)}
session['login_name'] = 'disen'
return marshal(data, self.get_out_fields)
def get(self):
self.parser.parse_args()
users = dao.query(User).all()
respJson = json.dumps(
marshal(data={
"status": "ok",
"data": users
},
fields=self.out_fields))
print(respJson)
resp = make_response(respJson)
resp.set_cookie('token', 'aaadd2212333kkdooo')
return resp
def get(self):
# 通过request 参数解析器，开始解析请求参数
# 如果请求参数不能满足条件，则直接返回参数相关的help的说明
args = self.parser.parse_args()
# 必然会有一个name参数，从args中读取name请求参数的值
name = args.get('name')
tags = args.get('tag')
# 从args中读取session数据
session = args.get('session')
print('session为-》', session)
musics = query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count(): # 如果musics不为0
return {'state': 'ok', 'data': musics.all()}
return {'msg': '你查询的歌曲是{},标签为:{}'.format(name, tags)}
def get(self):
self.parser.parse_args() # 解析参数，如果参数不满足，则直接返回
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
# 将对象转成输出的字段格式（json格式）
return marshal(img, self.img_fields)
else:
# 查询所有Image
images = queryAll(Image)
data = {"data": images, "size": len(images)}
return marshal(data, self.get_out_fields)
def get(self):
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
return marshal(img, self.img_fields)
else:
images = queryAll(Image)
data = {"data": images, "size": len(images)}
# 向session中存放用户名
session['login_name'] = 'disen'
return marshal(data, self.get_out_fields)
def get(self):
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
# 将对象转成输出的字段格式（Json格式）
return marshal(img, self.img_fields)
else:
# 查询所有Image
images = queryAll(Image)
data = {'data': images, 'size': len(images)}
# 向session中存放用户名
session['login_name'] = 'moliy'
return marshal(data, self.get_out_fields)
def total(limit):
data = dao.query("""
SELECT json_build_object(
'ts', htc.bucket,
'total_cnt', htc.cnt,
'total_invalid_cnt', COALESCE(hti.cnt, 0),
'total_valid_cnt', (htc.cnt - COALESCE(hti.cnt, 0))
)::jsonb
FROM history_total_count_in_5mins htc
LEFT JOIN history_total_invalid_count_in_5mins hti
ON hti.bucket = htc.bucket
ORDER BY htc.bucket DESC
LIMIT %s;
""" % limit)
return jsonify(data)
def get(self):
key = request.args.get('key')
if key:
result = {'state': 'fail', 'msg': '无'}
qs = query(User).filter(
or_(User.id == key, User.name == key, User.phone == key))
if qs.count():
result['state'] = 'ok'
result['msg'] = '成功'
result['data'] = qs.first().json
return result
users = queryAll(User)
return {'state': 'ok', 'data': [user.json for user in users]}
def get(self):
# 按name搜索
# 通过request参数解析器，开始解析请求参数
args = self.parser.parse_args()
name = args.get('name')
tags = args.get('tag')
session = args.get('session')
print('session->', session)
musics = query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count():
return {'data': musics.all()}
return {'msg': '搜索{}音乐不存在,标签'.format(name, tags)}
def get(self):
#解析参数，如果参数不满足，则直接返回
# self.parser.parse_args()
id=request.args.get('id')
if id:
img=query(Image).filter(Image.id==id).first()
#将对象转成输出的字段格式（json格式）
return marshal(img,self.img_fields)
else:
#查询所有的Image
images=queryAll(Image)
data={'size':len(images),
'data':images}
#向session中存入用户名
session['login_name']='disen'
return marshal(data,self.get_out_fields)
def get(self):
#读取请求参数中的key
key = request.args.get('key')
if key:
#读取请求参数中的key
result = {'status': 'fail', 'msg': '查询失败'}
#搜索用户信息 key = id/name/phone
qs = query(User).filter(
or_(User.id == key, User.name == key, User.phone == key))
if qs.count():
result['state'] = 'ok'
result['msg'] = '查询成功'
result['data'] = qs.first().json
return result
#从数据库中查询所有的用户
users = queryAll(User)
return {"state": "ok", "data": [user.json for user in users]}
def get(self):
# 按name 搜索
# 通过request参数解析器，开始解析请求参数
# 如果请求参数不能满足条件，则直接返回参数相关的help说明
args=self.parser.parse_args()
# 从 args中读取name请求参数的值
name=args.get('name')
tags=args.get('tag')
# 从args 中读取session(cookies的session)
session=args.get('session')
print('session->',session)
musics=query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count():
return {'data':musics.all()}
return {'msg':'搜索的音乐{}不存在{}'.format(name,tags)}
def top(limit):
data = dao.query("""
SELECT json_build_object(
'id', u.id,
'name', u.name,
'pinyin', u.pinyin,
'department', u.department,
'image', h.image,
'ts', h.ts
)::jsonb
FROM public.user u
INNER JOIN public.history h
ON h.pinyin = u.pinyin
ORDER BY h.ts DESC
LIMIT %s;
""" % limit)
return jsonify(data)
def get(self):
# self.parser.parse_args() # 解析参数，如果我们的参数不满足，直接返回下一步
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
# 将对象转成输出的字段格式（json格式）
return marshal(img, self.img_fields)
else:
# 查询所有Image
images = queryAll(Image)
data = {'data': images,
"size": len(images)}
# 向session中存放用户名
session['login_name'] = 'ming'
return marshal(data, self.get_out_fields)
def get(self):
#按照id/name去查询,按照名字去检索
#通过request参数解析器，开始解析请求参数
#如果请求参数不能满足条件，则直接返回参数相关的help说明
args = self.parser.parse_args()
#从args中读取name请求参数的值
#用dest来指定
name = args.get('name')
tags = args.get('tag')
#从args中读取session的信息(cookie中的session)
session = args.get('session')
print('session->>', session)
musics = query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count():
return {'state': 'ok', 'data': musics.all()}
return {'msg': '搜索{}失败,歌曲不存在，标签：{}！'.format(name, tags)}
def get(self):
# key = request.args.get('key')
# if key:
# music = searchMusic(Music, key).first()
# data = {'data':music}
# return marshal(data,self.get_out_fields)
# musics = queryAll(Music)
# return marshal({'data': musics}, self.get_out_fields)
# 通过request参数解析器，开始解析请求参数
# 如果请求参数不能阀组调教，则直接返回参数相关的help说明
args = self.paser.parse_args()
name = args['name']
tag = args['tag']
session = args.get('session')
print('session---------------------------', session)
musics = query(Music).filter(Music.name.like('%{}%'.format(name)))
if musics.count():
return {'data': musics.all(), 'tag': tag}
return {'msg': '查无此歌{}'.format(name)}
# coding=utf-8
from __future__ import division
from dao import query,execute,q
import pandas as pd
import time
# load 出所有数据
query_sql = "SELECT * FROM `stocks_info`"
all_info = query(query_sql)
stocks_info = pd.DataFrame(all_info)
last_update_time_sql = "SELECT max(last_update_time) as lt FROM `stocks_info`"
last_update_time = query(last_update_time_sql)[0]['lt']
# 转化函数
wan_to_yi = lambda x : x/10000
yi_to_wan = lambda x : x*10000
# print stocks_info.head(5)
print stocks_info.info()
print stocks_info.shape
print "\n"
# # 沪市A股总市值
print"沪市A股总市值: %d万万亿".decode('utf-8')% wan_to_yi(wan_to_yi(stocks_info['mktcap'].sum()))
print "\n"
# 市值最高股票
print "沪市A股市值最高股票(万亿)".decode('utf-8')
stocks_info.mktcap = stocks_info.mktcap.apply(wan_to_yi)
print stocks_info.sort_values(['mktcap'], ascending=False)[['name','mktcap']].head(1)
print "\n"
def get(self):
self.parser.parse_args() #解析参数，如果参数不满足，则直接返回。
id = request.args.get('id')
if id:
img = query(Image).filter(Image.id == id).first()
return marshal()
def query(SQL, data=None):
try:
return dao.query(SQL, data)
except Exception as e:
print "[**debug**] Oops: %s\n" % str(e)
return []
