def getUser(account_id):
try:
user = User.query.filter_by(account_id=account_id).first()
response = respond({'user': user.columns_to_dict()}, 200)
except:
response = respond({'error': "user not found"}, 404)
return response
def browse(rq, app, model):
query = rq.pwf.model.objects
# TODO: Filters
if rq.pwf.filters:
try: conds = parse_filters(rq.pwf.model, rq.pwf.filters)
except PerfectDataError as e:
return respond(rq, {'message':'failed-to-parse-filters', 'messages':e.messages}, 400)
if conds:
query = query.filter(conds)
result = {
"per_page":rq.pwf.per_page,
"page":rq.pwf.page,
"total":query.count(),
"data":[],
}
# Apply sort to query
try: query = parse_sort(rq, query)
except PerfectDataError as e:
return respond(rq, {'message':'failed-to-parse-filters', 'messages':e.messages}, 400)
page_real = rq.pwf.page * rq.pwf.per_page
per_page_real = page_real + rq.pwf.per_page
data_list = query.all()[page_real:per_page_real]
for obj in data_list:
result['data'].append(obj.to_object())
return respond(rq, result)
def createUser():
req = request.get_json()
try:
newuser = User(username=req['username'], email=req['email'])
db.session.add(newuser)
db.session.commit()
return respond({'user': newuser.columns_to_dict()}, 201)
except AlreadyExists as e:
return respond({'error': e.message}, 400)
def updateUser(account_id):
req = request.get_json()
try:
user = User.query.filter_by(account_id=account_id).first()
user.update(req)
db.session.commit()
return respond({'user': user.columns_to_dict()}, 201)
except AlreadyExists as e:
return respond({"error": e.message}, 400)
def getUserStastistics(account_id):
try:
user = User.query.filter_by(account_id=account_id).options(
db.load_only("id")).first()
statistics = Statistics.query.filter_by(user_id=user.id).order_by(
Statistics.created_at.desc()).first()
res = {"statistics": statistics.columns_to_dict()}
return respond(res, 200)
except:
return respond({"error": "user not found"}, 404)
def updateUserAchievements(account_id):
try:
req = request.get_json()
user = User.query.filter_by(account_id=account_id).options(
db.load_only("id")).first()
achiev = Achievements(user_id=user.id, achievement=req['achievement'])
db.session.add(achiev)
db.session.commit()
resp = {"success": "achievement has been added successfully"}
return respond(resp, 201)
except:
return respond({"error": "user not found"}, 404)
def getUserAchievements(account_id):
try:
user = User.query.filter_by(account_id=account_id).options(
db.load_only("id")).first()
achievements = Achievements.query.filter_by(user_id=user.id).all()
result = {}
for index in range(len(achievements)):
result[index] = achievements[index].columns_to_dict()
return respond({'achievements': result}, 200)
except:
return respond({'error': "user not found"}, 404)
def proxy_head(rq, app):
data = validate_request(rq, [
{'name':'url', 'type':'url', 'required':True}
])
url = urlparse.urlparse(data['values']['url'])
query = ''
if url.query:
query = '?%s' % url.query
path = '%s%s' % (url.path, query)
conn = httplib.HTTPConnection(url.netloc)
conn.request('HEAD', path)
res = conn.getresponse()
mime = res.getheader('content-type')
size = res.getheader('content-length')
info = {
'host':url.netloc,
'path':path,
}
if mime:
info['type'] = mime
if size:
info['size'] = int(size)
return respond(rq, info, res.status)
def updateUserStatistics(account_id):
try:
req = request.get_json()
user = User.query.filter_by(account_id=account_id).options(
db.load_only("id")).first()
stats = Statistics(user_id=user.id,
wins=req['wins'],
losses=req['losses'],
score=req['score'],
level=req['level'])
db.session.add(stats)
db.session.commit()
resp = {"success": "statistics has been added successfully"}
return respond(resp, 201)
except:
return respond({"error": "user not found"}, 404)
def getUserInfo(account_id, info):
if info not in ['statistics', 'achievements']:
return respond({"error": "invalid url"}, 404)
else:
if info == 'achievements':
return getUserAchievements(account_id=account_id)
elif info == 'statistics':
return getUserStastistics(account_id=account_id)
def authenticate():
"""Sends a 401 response that enables basic auth"""
data = {
"error":
'Could not verify your access level for that URL. You have to login with proper credentials'
}
status_code = 401
headers = {'WWW-Authenticate': 'Basic realm="Login Required"'}
return respond(data=data, status_code=status_code, headers=headers)
def decorator(rq, *args, **kwargs):
if not hasattr(rq, 'pwf'):
try: rq.pwf = pwf().parse_rq_base(rq)
except PerfectDataError as e:
return respond(rq, {
'message':'failed-to-parse-base',
'errors':e.messages
}, 400)
return fn(rq, *args, **kwargs)
def update_document(document_id):
body = request.get_json()
updated_document_count = Document.objects.update_one(
id=document_id,
**{
k: v
for k, v in body.items()
if k in ["title", "parent", "children", "content"]
})
return respond(updated_document_count=updated_document_count)
def decorator(rq, app, model, id=None, *args, **kwargs):
try: id = int(id)
except: id = None
if id:
try: rq.pwf.obj = rq.pwf.model.objects.filter(id=id).get()
except ObjectDoesNotExist:
raise Http404
return fn(rq, app, model, id, *args, **kwargs)
else:
return respond(rq, {'message':'invalid-id'}, 400)
def create(rq, app, model, id=None):
# ID attribute will be added into request payload schema, so it must be
# removed to prevent rewrites
if 'id' in rq.pwf.obj_data['values']:
rq.pwf.obj_data['values'].pop('id', None)
item = update_object(rq.pwf.model, rq.pwf.model(), rq.pwf.obj_data['values'])
item.save()
if rq.pwf.obj_data['update_m2m']:
item = rq.pwf.model.objects.filter(id = item.id).get()
item = update_object(rq.pwf.model, item, rq.pwf.obj_data['values'])
item.save()
return respond(rq, {'data':item.to_object()})
def create_document():
body = request.get_json()
try:
title = body["title"]
content = body["content"]
parent = body.get("parent")
children = body.get("children")
except KeyError:
return "Data missing from request"
document = Document(**{
"title": title,
"content": content,
"parent": parent,
"children": children
})
document.save()
return respond(document=document.to_mongo())
def on_validation_error(e):
return respond({'error': e.message}, 400)
def get_document(document_id):
res = db.documents.find_one({"_id": ObjectId(document_id)})
return respond(document=res)
def get_documents():
res = list(db.documents.find())
return respond(documents=res)
def edit(rq, app, model, id):
item = update_object(rq.pwf.model, rq.pwf.obj, rq.pwf.obj_data['values'])
item.save()
return respond(rq, {'data':item.to_object()})
def drop(rq, app, model, id):
rq.pwf.obj.delete()
return respond(rq, {'data':{'id':id}})
def deny(rq):
return respond(rq, {'errors':[{'message':'permission-denied'}]}, 403)
def decorator(rq, app, model, id=None, *args, **kwargs):
rq.pwf.parse_object_data(False)
if rq.pwf.obj_data['errors']:
return respond(rq, {'errors':rq.pwf.obj_data['errors']}, 400)
return fn(rq, app, model, id, *args, **kwargs)
