def photos_verify(request):
""" Just verify if picture is valid """
if request.method == 'GET':
return json_response({'status': 'FAIL'}, 403)
elif request.method == 'POST':
photo = SinglePhotoForm(request.POST, request.FILES)
if photo.is_valid():
return json_response({'status': 'OK'})
else:
return json_response({'status': 'FAIL'}, 403)
def me(request):
session = yield from get_session(request)
try:
user_id = session['user_id']
except KeyError:
return json_response({})
else:
with(yield from request.app['db']) as conn:
query = sa.select([models.users]).where(models.users.c.id == user_id)
u = yield from conn.execute(query)
user = yield from u.fetchone()
schema = schemas.UserSchema()
result = schema.dump(user)
return json_response(result.data)
def pugs_json(request):
from pugs import pugs
data = []
for i,pug in enumerate(pugs):
data.append({'id': i, 'url': pug['url'] , 'url_small': pug['url'], 'type': pug['ratio'] })
return json_response( data )
def photos_upload(request):
""" Upload photos """
if request.method == 'POST':
photo = SinglePhotoForm(request.POST, request.FILES)
if photo.is_valid():
genitalia = Genitalia(name='',image=request.FILES['photo'])
already_uploaded = Genitalia.objects.filter(hash=genitalia.get_hash())
if not already_uploaded:
genitalia.save()
return json_response({'status': 'OK'})
else:
return json_response({'status': 'FAIL','error': 'Picture already uploaded'}, 403)
else:
return json_response({'status': 'FAIL','error': 'Not a valid picture'}, 403)
return json_response({'status': 'FAIL'}, 403)
def users(request, **kwargs):
with(yield from request.app['db']) as conn:
query = sa.select([models.users])
ret = yield from conn.execute(query)
schema = schemas.UserSchema(many=True)
result = schema.dump(list(ret))
return json_response(result.data)
def predict():
values = zip(df['Date'], df['Vam co dong'])
aut = zip(labels, df['Vam co dong'][-3:])
value = []
input_variables = data
# print(input_variables)
flow = [flask.request.form['flow']]
input_variables.append(flow)
input_variables = fit_data(input_variables)
# print("a",input_variables)
predictions = json_response(input_variables, endpoint, lookback)
# print(json_response)
prediction = round(
predict_transf(predictions['predictions']).flatten().tolist()[0], 2)
# print("predict", prediction)
value.append((prediction))
input_variables = input_variables.tolist()
# print(type(input_variables))
pre = predictions['predictions'][0]
# print(type(pre), pre)
input_variables.append(pre)
predictions_2 = json_response(input_variables, endpoint, lookback)
prediction_2 = round(
predict_transf(predictions_2['predictions']).flatten().tolist()[0], 2)
value.append(prediction_2)
input_variables.append(predictions_2['predictions'][0])
# print('after+1', input_variables)
# input_variables = fit_data(input_variables)
# print(inputs(input_variables, lookback))
prediction_3 = json_response(input_variables, endpoint, lookback)
# print('json2', json_response.text)
prediction_3 = round(
predict_transf(prediction_3['predictions']).flatten().tolist()[0], 2)
value.append(prediction_3)
chart = zip(labels, df['Vam co dong'][-3:], value)
# prediction = model.predict(input_variables)[0]
return flask.render_template('index.html',
predict_1=prediction,
predict_2=prediction_2,
predict_3=prediction_3,
values=values,
aut=aut,
chart=chart,
charts=zip(labels, value),
predict=zip(date, predict_data),
dubao=zip(df["Date"][-3:], value))
def uploaddata():
auth = request.authorization
if auth.username != 'admin' or auth.password != 'thesecret':
abort(401)
directory = request.args.get('dir')
load_data(directory)
#fluxo de callback pendente.
return json_response({'directory': directory, 'status': 'OK'})
def home():
auth = request.authorization
if auth.username != 'admin' or auth.password != 'thesecret':
abort(401)
return json_response({
'username': auth.username,
'password': auth.password,
'status': 'OK'
})
async def wrapped(request, **kwargs):
limit = int(request.GET.get('limit', 20))
offset = int(request.GET.get('offset', 0))
n_list = await handler(request, limit=limit, offset=offset)
items = [dict(row) for row in n_list] if is_iterable(n_list) else []
result = {
'meta': {
'offset': offset,
'limit': limit
},
'items': items
}
return json_response(result, **kwargs)
def notifications(request, team=None, limit=20, offset=0):
limit = int(request.GET.get('limit', 20))
offset = int(request.GET.get('offset', 0))
with(yield from request.app['db']) as conn:
nf = models.notifications.alias()
us = models.users.alias()
items = []
nf_count = 0
trans = yield from conn.begin()
session = yield from get_session(request)
user_id = session['user_id'] if 'user_id' in session else None
try:
nf_count = yield from conn.scalar(sa.select([sa.func.count(nf.c.id)])
.where(nf.c.team == team['id']))
nf_query = sa.select([nf])\
.where(nf.c.team == team["id"])\
.order_by(sa.desc(nf.c.creation_date))\
.limit(limit)\
.offset(offset)
nfs = yield from conn.execute(nf_query)
for n in nfs:
item = dict(n)
author_query = sa.select([us]).where(us.c.id == item["author"])
author = yield from conn.execute(author_query)
item["author"] = yield from author.fetchone()
items.append(item)
except Exception:
yield from trans.rollback()
else:
yield from trans.commit()
schema = schemas.NotificationSchema(many=True)
result = {
'meta': {
'offset': offset,
'limit': limit,
'total': nf_count,
'user_id': user_id
},
'items': schema.dump(items).data
}
return json_response(result)
def photos_json(request):
""" Server the photos as a JSON """
data = cache.get( 'photos_json' ) or []
# If no data
if not data:
for photo in Genitalia.objects.filter(approved=True).reverse():
#for photo in Genitalia.objects.filter(approved=True):
small = small_photo(photo)
big = big_photo(photo)
data.append({
'id': photo.id,
'url': big['url'],
'url_small': small['url'],
'type': 'size-%dx%d' % small['size']
})
cache.set('photos_json', data, 1200*10 )
return json_response( data )
def teams(request):
with(yield from request.app['db']) as conn:
trans = yield from conn.begin()
result = []
try:
query = sa.select([models.teams])
teams = yield from conn.execute(query)
for row in teams:
item = dict(row)
owner = yield from conn.execute(sa.select([models.users])\
.where(models.users.c.id == item['owner']))
item['owner'] = yield from owner.fetchone()
result.append(item)
except Exception:
yield from trans.rollback()
else:
yield from trans.commit()
schema = schemas.TeamSchema(many=True)
return json_response(schema.dump(result).data)
def remove_notification(request):
id = request.path.split('/')[-1]
result = {'error': ''}
if id:
session = yield from get_session(request)
user_id = session['user_id'] if 'user_id' in session else None
if not user_id:
result = {'error': 'You must be loged in to remove item'}
else:
with(yield from request.app['db']) as conn:
trans = yield from conn.begin()
try:
query = sa.select([models.notifications])\
.where(models.notifications.c.id == id)
res = yield from conn.execute(query)
nf = yield from res.fetchone()
if not nf:
result = {'error': 'No such item'}
elif nf['author'] != user_id:
result = {'error': 'You can not remove this item. Its not yours, you silly dog!'}
else:
if (yield from conn.execute(models.notifications.delete()\
.where(models.notifications.c.id == id))):
result = {"id": id}
else:
result = {'erorr': 'Error on save'}
except Exception as e:
print(str(e))
yield from trans.rollback()
else:
yield from trans.commit()
else:
print('Can not delete noitfication: no id')
result = {'error': 'Can not delete noitfication: no id'}
print(json.dumps(result))
return json_response(json.dumps(result))
def not_found(e):
return json_response(status=404)
