def delete(self, url):
parser = RequestParser()
parser.add_argument(arg_token)
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = do_delete_image(user, url)
if res == 'success':
return {'status': 'success'}
else:
return error(res), 403
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('blob', type=str, location='json')
data = reqparse.parse_args()
if not data.blob:
return self.argument_required('blob')
# encode content as bytestring
tmp = base64.b64decode(data.blob)
# calculate sha1 digest
digest = hashlib.sha1(tmp).hexdigest()
# write into temp file
f = TemporaryFile()
_ = f.write(tmp)
f.flush()
_ = f.seek(0)
# upload blob
created = self.blob_container.put(f, digest=digest)
# response json and status code
code = created and 201 or 409
response = dict(
digest = digest,
url = '/image/{0}'.format(digest)
)
return response, code
class UserCreate(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument(
'user',
type = username,
required = True,
location = 'json'
)
self.reqparse.add_argument(
'key',
type = pubkey,
required = True,
location = 'json'
)
super(UserCreate, self).__init__()
def post(self):
args = self.reqparse.parse_args()
try:
p.add_user(
username=str(args['user']),
pubkey=args['key'],
hostname='va1.hashbang.sh'
)
except ldap.SERVER_DOWN:
return { 'message': 'Unable to connect to LDAP server'}, 400
except ldap.ALREADY_EXISTS:
return { 'message': 'User already exists'}, 400
except:
sys.stderr.write("Unexpected Error: %s\n" % sys.exc_info()[0])
return { 'message': 'User creation script failed'}, 400
return {'message': 'success'}
def get(self):
params_parser = RequestParser()
params_parser.add_argument(User.Fields.NAME,
type=str,
required=False,
location='args')
params_parser.add_argument(User.Fields.SETTINGS,
type=str,
required=False,
location='args')
fields = params_parser.parse_args()
name = fields.get(User.Fields.NAME, None)
settings = fields.get(User.Fields.SETTINGS, None)
d = dict()
if name is not None:
d[User.Fields.NAME] = name
if settings is not None:
d[User.Fields.SETTINGS] = settings
updated_user = UserOperations.update_user(
request._username, request._passwordhash, d
)
user_dict = User.encode(updated_user)
user_dict = remove_id_from_user_dict(user_dict)
return user_dict, 200
def get(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('with_uploads', type=int, location='args')
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = {
'name': user.name,
'email': user.email,
'profile_image_url': user.profile_image_url,
'uploads_count': user.uploads.count()
}
if args['with_uploads'] == 1:
uploads = []
for upload in user.uploads:
uploads.append({
'type': upload.object.__tablename__,
'url': {
'page': BASE_URL % upload.url,
'direct': upload.direct_url
},
'title': upload.title,
'desc': upload.desc,
'upload_at': upload.time.strftime('%s'),
'view_count': upload.view_count,
'properties': upload.object.prop
})
res['uploads'] = uploads
return success({'user': res})
def wrapper(inst, *args, **kwargs):
header_parser = RequestParser()
header_parser.add_argument(User.Fields.USERNAME,
type=str,
required=True,
location='headers',
help='username needs to be present in header')
header_parser.add_argument(User.Fields.PASSWORDHASH,
type=str,
required=True,
location='headers',
help='password hash needs to be present in header')
headers = header_parser.parse_args()
request._username = headers[User.Fields.USERNAME]
request._passwordhash = headers[User.Fields.PASSWORDHASH]
user = UserOperations.find_user_with_passwordhash(
request._username,
request._passwordhash
)
if not user:
cors_headers = {
'Access-Control-Allow-Origin': '*'
}
return "Cannot authenticte user", 401, cors_headers
# raise UserException("Could not authenticate user")
return func(inst, *args, **kwargs)
def post(self):
parser = RequestParser()
parser.add_argument('X-VERIFY-CREDENTIALS-AUTHORIZATION',
type=str,
location='headers',
dest='authorization')
parser.add_argument('X-AUTH-SERVICE-PROVIDER',
type=str,
location='headers',
dest='authorization_url')
parser.add_argument('media', type=FileStorage, location='files')
parser.add_argument('message', type=unicode, location='form')
parser.add_argument('source', type=unicode, location='form')
args = parser.parse_args()
if args['source'] != 'Tweetbot for iOS':
return error('nottweetbot'), 403
f = args['media']
if not f:
return error('imagenotattached'), 400
headers = {'Authorization': args['authorization']}
r = requests.get(args['authorization_url'], headers=headers)
json = r.json()
user = User.query.filter_by(oauth_uid=json['id']).first()
message = '' if json['protected'] else args.get('message')
desc = "%svia Tweetbot for iOS" % (
('%s\r\n\r\n' % message) if message else '')
upload = do_upload_image(user, f, desc)
if isinstance(upload, str):
return error(upload), 403
else:
return {'url': BASE_URL % upload.url}, 201
def get_one(self, id):
parser = RequestParser()
# Look only in the querystring
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
dao = TimerDAO()
timer = dao.get(id)
as_dict = TimerFormatter().model_to_dict(timer)
resp = jsonify(as_dict)
return resp
def get_one(self, id):
parser = RequestParser()
# Look only in the querystring
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
dao = TimerDAO()
timer = dao.get(id)
as_dict = TimerFormatter().model_to_dict(timer)
resp = jsonify(as_dict)
return resp
def post(self):
parser = RequestParser()
parser.add_argument('image', type=FileStorage, location='files')
parser.add_argument('file', type=FileStorage, location='files')
args = parser.parse_args()
file = args['image'] or args['file']
if not file:
return jsonify({'error': 'not file for upload'})
else:
filename = upload(file)
return jsonify({'href': '%s%s' % (request.url_root, filename)})
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('event',
type=str,
required=True,
help='Event needs to be defined',
location='json')
parser.add_argument('requirements',
type=list,
required=False,
help='Requirements (optional) needs to be defined',
location='json')
return parser
def put(self, id):
reqparse = RequestParser()
reqparse.add_argument('text', type=str, location='json')
data = reqparse.parse_args()
if not data.text:
return self.argument_required('text')
self.cursor.execute("""
UPDATE {}
SET text = ?
WHERE id = ?
""".format(self.__table__), (data.text, id))
self.refresh_table()
return self.get(id)
def put(self, id):
reqparse = RequestParser()
reqparse.add_argument('text', type=str, location='json')
data = reqparse.parse_args()
if not data.text:
return self.argument_required('text')
self.cursor.execute(
"""
UPDATE {}
SET text = ?
WHERE id = ?
""".format(self.__table__), (data.text, id))
self.refresh_table()
return self.get(id)
class Set(Resource):
def __init__(self):
super(Set, self).__init__()
self.__mParser = RequestParser()
self.__mParser.add_argument('bus_id', type=str, required=True)
self.__mParser.add_argument('address', type=str, required=True)
self.__mParser.add_argument('value', type=str, required=True)
self.__mParser.add_argument('cmd', type=str)
def get(self):
lStatus = 'ok'
lArgs = self.__mParser.parse_args()
lBusId = int(lArgs['bus_id'], 0)
lAddress = int(lArgs['address'], 0)
lValue = int(lArgs['value'], 0)
lBus = SMBus(lBusId)
try:
if lArgs['cmd'] is None:
lBus.write_byte(lAddress, lValue)
else:
lCommand = int(lArgs['cmd'], 0)
lBus.write_byte_data(lAddress, lCommand, lValue)
except IOError, pExc:
lStatus = "Error writing data: " + str(pExc)
return {
'bus_id': lBusId,
'address': lAddress,
'cmd': lCommand,
'value': lValue,
'status': lStatus
}
def delete(self, url):
parser = RequestParser()
parser.add_argument(arg_token)
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = do_delete_image(user, url)
if res == 'success':
return {'status': 'success'}
else:
return error(res), 403
def put(self, id):
"""Update tags for a score"""
parser = RequestParser()
parser.add_argument('tags', type=str, required=True)
args = parser.parse_args()
q = db.session.query
score = q(models.Score).get(id)
tag_names = [t.strip() for t in args.tags.split(',')]
score.tags = _process_tags(tag_names, score.user_id)
db.session.commit()
score = q(models.Score).get(id)
result = ScoreSerializer(score).data
return {'result': result}
def get(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('with_uploads', type=int, location='args')
args = parser.parse_args()
if not args['token']:
return error('notoken'), 403
user = User.query.filter_by(token=args['token']).first()
if not user:
return error('wrongtoken'), 403
res = {'name': user.name, 'email': user.email, 'profile_image_url': user.profile_image_url, 'uploads_count': user.uploads.count()}
if args['with_uploads'] == 1:
uploads = []
for upload in user.uploads:
uploads.append({'type': upload.object.__tablename__, 'url': {'page': BASE_URL % upload.url, 'direct': upload.direct_url}, 'title': upload.title, 'desc': upload.desc, 'upload_at': upload.time.strftime('%s'), 'view_count': upload.view_count, 'properties': upload.object.prop})
res['uploads'] = uploads
return success({'user': res})
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('query_string', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.query_string:
return self.argument_required('query_string')
self.cursor.execute("""
SELECT p.*, p._score AS _score,
c.name AS country, c.geometry AS area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND match(text, ?)
ORDER BY _score DESC
""", (data.query_string,))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 200
def post(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('file', type=FileStorage, location='files')
parser.add_argument('desc', type=unicode, location='form')
args = parser.parse_args()
f = args['file']
user = args['token']
if user:
user = User.query.filter_by(token=user).first()
if not user:
return error('wrongtoken'), 403
if not f:
return error('imagenotattached'), 400
upload = do_upload_image(user, f, args['desc'])
if isinstance(upload, str):
return error(upload), 403
else:
return success({
'url': {
'part': upload.url,
'page': BASE_URL % upload.url,
'direct': upload.direct_url
}
}), 201
class Get(Resource):
def __init__(self):
super(Get, self).__init__()
self.__mParser = RequestParser()
self.__mParser.add_argument('bus_id', type=str, required=True)
self.__mParser.add_argument('address', type=str, required=True)
self.__mParser.add_argument('cmd', type=str)
def get(self):
lStatus = "ok"
lCommand = ""
lValue = ""
lArgs = self.__mParser.parse_args()
lBusId = int(lArgs['bus_id'], 0)
lBus = SMBus(lBusId)
lAddress = int(lArgs['address'], 0)
try:
if lArgs['cmd'] is None:
lValue = lBus.read_byte(lAddress)
else:
lCommand = int(lArgs['cmd'], 0)
lValue = lBus.read_byte_data(lAddress, lCommand)
except IOError, pExc:
lStatus = "Error reading from bus: " + str(pExc)
return {
'bus_id': lBusId,
'address': lAddress,
'cmd': lCommand,
'value': lValue,
'status': lStatus
}
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('blob', type=str, location='json')
data = reqparse.parse_args()
if not data.blob:
return self.argument_required('blob')
# encode content as bytestring
tmp = base64.b64decode(data.blob)
# calculate sha1 digest
digest = hashlib.sha1(tmp).hexdigest()
# write into temp file
f = TemporaryFile()
_ = f.write(tmp)
f.flush()
_ = f.seek(0)
# upload blob
created = self.blob_container.put(f, digest=digest)
# response json and status code
code = created and 201 or 409
response = dict(digest=digest, url='/image/{0}'.format(digest))
return response, code
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('query_string', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.query_string:
return self.argument_required('query_string')
self.cursor.execute(
"""
SELECT p.*, p._score AS _score,
c.name AS country, c.geometry AS area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND match(text, ?)
ORDER BY _score DESC
""", (data.query_string, ))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 200
def get(self, soknad_id=None):
if soknad_id:
soknad = self.soknad_resource.get(soknad_id)
ExternalResourceHelper.load_organisation(soknad)
ExternalResourceHelper.load_persons([soknad])
ExternalResourceHelper.load_users([soknad])
return output_pdf(soknad, 200, template=u"pdf/soknad.html")
# return output_csv(soknad, 200, fieldname_mapping=get_fieldname_mapping(), fields_to_ignore=get_fields_to_ignore())
else:
parser = RequestParser()
parser.add_argument("id", type=int, action="append", required=True)
args = parser.parse_args()
soknader = self.soknad_resource.get()
soknader = [s for s in soknader if s["id"] in args["id"]]
ExternalResourceHelper.load_organisations(soknader)
ExternalResourceHelper.load_persons(soknader)
ExternalResourceHelper.load_users(soknader)
return output_csv(
soknader, 200, fieldname_mapping=get_fieldname_mapping(), fields_to_ignore=get_fields_to_ignore()
)
def post(self):
parser = RequestParser()
parser.add_argument('X-VERIFY-CREDENTIALS-AUTHORIZATION', type=str, location='headers', dest='authorization')
parser.add_argument('X-AUTH-SERVICE-PROVIDER', type=str, location='headers', dest='authorization_url')
parser.add_argument('media', type=FileStorage, location='files')
parser.add_argument('message', type=unicode, location='form')
parser.add_argument('source', type=unicode, location='form')
args = parser.parse_args()
if args['source'] != 'Tweetbot for iOS':
return error('nottweetbot'), 403
f = args['media']
if not f:
return error('imagenotattached'), 400
headers = {'Authorization': args['authorization']}
r = requests.get(args['authorization_url'], headers=headers)
json = r.json()
user = User.query.filter_by(oauth_uid=json['id']).first()
message = '' if json['protected'] else args.get('message')
desc = "%svia Tweetbot for iOS" % (('%s\r\n\r\n' % message) if message else '')
upload = do_upload_image(user, f, desc)
if isinstance(upload, str):
return error(upload), 403
else:
return {'url': BASE_URL % upload.url}, 201
class UserCreate(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument(
'user',
type = username,
required = True,
location = 'json'
)
self.reqparse.add_argument(
'key',
type = pubkey,
required = True,
location = 'json'
)
self.reqparse.add_argument(
'host',
type = str,
required = True,
location = 'json'
)
super(UserCreate, self).__init__()
def post(self):
args = self.reqparse.parse_args()
print(args)
try:
p.add_user(
username=str(args['user']),
pubkey=args['key'],
hostname=args['host']
)
except ldap.SERVER_DOWN:
return {'message': 'Unable to connect to LDAP server'}, 400
except ldap.ALREADY_EXISTS:
return {'message': 'User already exists'}, 400
except UNKNOWN_HOST:
return {'message': 'Unknown shell server'}, 400
except:
(typ, value, tb) = sys.exc_info()
sys.stderr.write("Unexpected Error: %s\n" % typ)
sys.stderr.write("\t%s\n" % value)
traceback.print_tb(tb)
return {'message': 'User creation script failed'}, 400
return {'message': 'success'}
class UserCreate(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument(
'user',
type = username,
required = True,
location = 'json'
)
self.reqparse.add_argument(
'key',
type = pubkey,
required = True,
location = 'json'
)
self.reqparse.add_argument(
'host',
type = str,
required = True,
location = 'json'
)
super(UserCreate, self).__init__()
def post(self):
args = self.reqparse.parse_args()
print(args)
try:
p.add_user(
username=str(args['user']),
pubkey=args['key'],
hostname=args['host']
)
except ldap.SERVER_DOWN:
return {'message': 'Unable to connect to LDAP server'}, 400
except ldap.ALREADY_EXISTS:
return {'message': 'User already exists'}, 400
except UNKNOWN_HOST:
return {'message': 'Unknown shell server'}, 400
except:
(typ, value, tb) = sys.exc_info()
sys.stderr.write("Unexpected Error: %s\n" % typ)
sys.stderr.write("\t%s\n" % value)
traceback.print_tb(tb)
return {'message': 'User creation script failed'}, 400
return {'message': 'success'}
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('user', type=dict, location='json')
reqparse.add_argument('text', type=str, location='json')
reqparse.add_argument('image_ref', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.text:
return self.argument_required('text')
if not data.get('user', {}).get('location'):
return self.argument_required('location')
# generate a new time based UUID
post_id = str(uuid.uuid1())
# payload for querying Crate
values = dict(
id = post_id,
created = datetime.now().isoformat(),
user = data.user,
text = data.text,
image_ref = data.image_ref,
like_count = 0,
)
k = list(values.keys())
v = list(values.values())
# compile and execute INSERT statement
self.cursor.execute("""INSERT INTO {} ({}) VALUES ({})""".format(
self.__table__,
', '.join(k),
', '.join('?' * len(v))
), v)
# refresh table to make sure new record is immediately available
self.refresh_table()
# fetch new record
self.cursor.execute("""
SELECT p.*, c.name as country, c.geometry as area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND p.id = ?
""", (post_id,))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 201
def post(self):
# parse incoming POST data
reqparse = RequestParser()
reqparse.add_argument('user', type=dict, location='json')
reqparse.add_argument('text', type=str, location='json')
reqparse.add_argument('image_ref', type=str, location='json')
data = reqparse.parse_args()
# check for required data
if not data.text:
return self.argument_required('text')
if not data.get('user', {}).get('location'):
return self.argument_required('location')
# generate a new time based UUID
post_id = str(uuid.uuid1())
# payload for querying Crate
values = dict(
id=post_id,
created=datetime.now().isoformat(),
user=data.user,
text=data.text,
image_ref=data.image_ref,
like_count=0,
)
k = list(values.keys())
v = list(values.values())
# compile and execute INSERT statement
self.cursor.execute(
"""INSERT INTO {} ({}) VALUES ({})""".format(
self.__table__, ', '.join(k), ', '.join('?' * len(v))), v)
# refresh table to make sure new record is immediately available
self.refresh_table()
# fetch new record
self.cursor.execute(
"""
SELECT p.*, c.name as country, c.geometry as area
FROM guestbook.posts AS p, guestbook.countries AS c
WHERE within(p.user['location'], c.geometry)
AND p.id = ?
""", (post_id, ))
# convert response from Crate into
# json-serializable object array
response = self.convert(self.cursor.description,
self.cursor.fetchall())
return response, 201
def post(self):
parser = RequestParser()
parser.add_argument(arg_token)
parser.add_argument('file', type=FileStorage, location='files')
parser.add_argument('desc', type=unicode, location='form')
args = parser.parse_args()
f = args['file']
user = args['token']
if user:
user = User.query.filter_by(token=user).first()
if not user:
return error('wrongtoken'), 403
if not f:
return error('imagenotattached'), 400
upload = do_upload_image(user, f, args['desc'])
if isinstance(upload, str):
return error(upload), 403
else:
return success({'url': {'part': upload.url, 'page': BASE_URL % upload.url, 'direct': upload.direct_url}}), 201
class Report(Resource):
def __init__(self):
super(Report, self).__init__()
self.__mParser = RequestParser()
self.__mParser.add_argument('success', type=str, required=True)
self.__mParser.add_argument('message', type=str)
self.__mParser.add_argument('rangeId', type=int, required=True)
def get(self):
lArgs = self.__mParser.parse_args()
lSuccess = lArgs['success']
lMessage = lArgs['message']
lRangeId = lArgs['rangeId']
Report.sModel.report(
True if lSuccess == "true" else False,
lRangeId,
lMessage
)
return {}
class UserCreate(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument("user", type=username, required=True, location="json")
self.reqparse.add_argument("key", type=pubkey, required=True, location="json")
self.reqparse.add_argument("host", type=str, required=True, location="json")
super(UserCreate, self).__init__()
def post(self):
args = self.reqparse.parse_args()
print(args)
try:
p.add_user(username=str(args["user"]), pubkey=args["key"], hostname="%s.hashbang.sh" % args["host"])
except ldap.SERVER_DOWN:
return {"message": "Unable to connect to LDAP server"}, 400
except ldap.ALREADY_EXISTS:
return {"message": "User already exists"}, 400
except:
sys.stderr.write("Unexpected Error: %s\n" % sys.exc_info()[0])
return {"message": "User creation script failed"}, 400
return {"message": "success"}
# coding: utf-8
from flask.ext.restful import Resource
from flask.ext.restful.reqparse import RequestParser
from ..app import DbSession
from ..models import User
from ..serializers import UserSerializer
users_parser = RequestParser()
users_parser.add_argument("email", required=True, type=str)
users_parser.add_argument("source", required=True, type=str)
users_parser.add_argument("first_name", required=True, type=str)
users_parser.add_argument("last_name", required=True, type=str)
class UsersList(Resource):
"""
Endpoint ("/users") for showing the list of all users and for adding them.
"""
def get(self):
"""
Return all of the users.
"""
users = DbSession.query(User).all()
return {"users": UserSerializer(users, many=True).data}, 200
def post(self):
"""
continue
if isinstance(attr.value, Model):
# recursive call on related model
ret = get_model_changes(attr.value)
if ret is not None:
changes[attr.key] = ret
else:
history = attr.history
if attr.state.modified and history.has_changes():
changes[attr.key] = {'before': history.deleted[0], 'after': history.added[0]}
return changes
pagination_parser = RequestParser()
pagination_parser.add_argument('page', type=int, required=False, default=1)
pagination_parser.add_argument('perPage', type=int, required=False, default=20)
# the empty list used when return result is empty
empty_list = {"objects": {}, "page": 1, "pages": 0, "total": 0, "per_page": 20}
@contextlib.contextmanager
def profiled():
pr = cProfile.Profile()
pr.enable()
yield
pr.disable()
s = StringIO.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
ps.print_stats()
:license: Apache, see LICENSE for more details.
.. moduleauthor:: Kevin Glisson <*****@*****.**>
"""
import sys
import string
import random
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from flask.ext.restful.reqparse import RequestParser
paginated_parser = RequestParser()
paginated_parser.add_argument('count', type=int, default=10, location='args')
paginated_parser.add_argument('page', type=int, default=1, location='args')
paginated_parser.add_argument('sortDir',
type=str,
dest='sort_dir',
location='args')
paginated_parser.add_argument('sortBy',
type=str,
dest='sort_by',
location='args')
paginated_parser.add_argument('filter', type=str, location='args')
def get_psuedo_random_string():
"""
Create a random and strongish challenge.
from application.models import Collection, Data, Sensor, Unit
from application.service import (
get_shouts,
get_variation,
handle_variation,
retrieve_dbo,
sanitize_name,
the_axis,
the_non_collection,
the_shouts,
the_variation,
)
from application.space import spaceapi
parser = RequestParser()
parser.add_argument("axis", type=int)
parser.add_argument("description", type=str)
parser.add_argument("factor", type=float)
parser.add_argument("name", type=str)
parser.add_argument("sensor", type=str)
parser.add_argument("sensors", type=str, action="append")
parser.add_argument("time", type=str)
parser.add_argument("unit", type=str)
parser.add_argument("value", type=str)
def _get_input(req, opt=None):
args = parser.parse_args()
args.name = sanitize_name(args.name)
args.sensor = sanitize_name(args.sensor)
args.sensors = [sanitize_name(sensor) for sensor in args.sensors] if args.sensors else None
from flask_login import login_required, current_user
from sqlalchemy.orm import load_only
from sqlalchemy import exc, asc, or_
from . import dataformat
from .authorization import is_user_access_restricted, require, allow
from .core import db, event
from .util import new_restful_api, get_model_changes, pagination_parser
from .models import Users, UserTypesForSystem, Courses, UserTypesForCourse, PostsForQuestions, Posts
users_api = Blueprint('users_api', __name__)
user_types_api = Blueprint('user_types_api', __name__)
user_course_types_api = Blueprint('user_course_types_api', __name__)
new_user_parser = RequestParser()
new_user_parser.add_argument('username', type=str, required=True)
new_user_parser.add_argument('student_no', type=str)
new_user_parser.add_argument('usertypesforsystem_id', type=int, required=True)
new_user_parser.add_argument('firstname', type=str, required=True)
new_user_parser.add_argument('lastname', type=str, required=True)
new_user_parser.add_argument('displayname', type=str, required=True)
new_user_parser.add_argument('email', type=str)
new_user_parser.add_argument('password', type=str, required=True)
existing_user_parser = RequestParser()
existing_user_parser.add_argument('id', type=int, required=True)
existing_user_parser.add_argument('username', type=str, required=True)
existing_user_parser.add_argument('student_no', type=str)
existing_user_parser.add_argument('usertypesforsystem_id',
type=int,
required=True)
from flask.ext.restful import abort, representations, types
from flask.ext.restful.representations.json import output_json
from flask.ext.restful.reqparse import RequestParser
from flask.ext.restful.utils import unpack
from functools import wraps
from werkzeug.http import parse_options_header
# Monkey-patch flask.ext.restful.representations.json.settings to always
# return indented and sorted JSONs.
representations.json.settings = {
'indent': 4,
'sort_keys': True,
}
request_options = RequestParser()
request_options.add_argument('Content-Type', type=str, location='headers')
request_options.add_argument('fields', type=str, location='args')
request_options.add_argument('page', type=int, location='args')
request_options.add_argument('per_page', type=int, location='args')
response_options = RequestParser()
response_options.add_argument('envelope', type=types.boolean, location='args')
response_options.add_argument('callback', type=str, location='args')
response_options.add_argument('X-Conditional',
type=types.boolean,
location='headers')
_log = logging.getLogger(__name__)
__all__ = ('ClassyAPI', 'BaseAPI', 'BaseResource', 'secure_endpoint')
from .core import db, event
from .models import Groups, GroupsAndUsers, CoursesAndUsers, Users, Courses, UserTypesForCourse
from .util import new_restful_api
from .attachment import allowed_file
groups_api = Blueprint('groups_api', __name__)
api = new_restful_api(groups_api)
groups_users_api = Blueprint('groups_users_api', __name__)
apiU = new_restful_api(groups_users_api)
USER_IDENTIFIER = 0
GROUP_NAME = 1
import_parser = RequestParser()
import_parser.add_argument('userIdentifier', type=str, required=True)
# events
on_group_create = event.signal('GROUP_POST')
on_group_delete = event.signal('GROUP_DELETE')
on_group_course_get = event.signal('GROUP_COURSE_GET')
on_group_import = event.signal('GROUP_IMPORT')
on_group_get = event.signal('GROUP_GET')
on_group_user_create = event.signal('GROUP_USER_CREATE')
on_group_user_delete = event.signal('GROUP_USER_DELETE')
def import_members(course_id, identifier, members):
# initialize list of users and their statuses
invalids = [] #invalid entry - eg. no group name
from flask.ext.admin.actions import action
from flask.ext.restful.reqparse import RequestParser
from wtforms.ext.i18n.form import Form
from sqlalchemy import or_
from sqlalchemy.orm import joinedload
from leopard.comps.excel import export_xls
from leopard.core.config import get_config
from leopard.helpers import get_current_user, get_columns_by_model
from . import filters
from . import typefmt
translations_cache = {}
page_size_parser = RequestParser()
page_size_parser.add_argument('page_size', type=int, default=20)
def dict_merge(a, b):
if not isinstance(b, dict):
return b
result = deepcopy(a)
for k, v in b.items():
if k in result and isinstance(result[k], dict):
result[k] = dict_merge(result[k], v)
else:
result[k] = deepcopy(v)
return result
class BaseForm(OriginBaseform, Form):
def _create_classes(self, model, resource_metadata):
resource_name = resource_metadata.name
classname = to_camelcase(resource_name)
# Create Resource List class
list_parser = RequestParser()
fields = {
'_uid': restful_fields.Integer # Internal id
}
for field in resource_metadata.schema.get('fields', []):
# JSON properties names are camelCase
property_name = to_camelcase(field.get('name'), False)
# but SQLAlchemy columns are snake_case
column_name = to_underscore(field.get('name'))
# Add a filter argument for each column
list_parser.add_argument(property_name, action='append')
# Map JSON properties to SQLAlchemy columns
args = []
kwargs = {'attribute': column_name}
fields[property_name] = get_field_type(TYPES, field)(*args,
**kwargs)
# Expect pagination arguments
list_parser.add_argument('page', type=int, default=0)
list_parser.add_argument('per_page', type=int, default=100)
list_parser.add_argument('select',
type=str,
default=','.join(fields.keys()))
def get_list(self):
args = list_parser.parse_args()
query = self.__model__.queryset
# Filters
for field in resource_metadata.schema.get('fields', []):
# JSON properties names are camelCase
property_name = to_camelcase(field.get('name'), False)
# but SQLAlchemy columns are snake_case
column_name = to_underscore(field.get('name'))
# Get the argument value from URL query, if any
values = args[property_name]
if values is not None:
query = query.in_(**{column_name: values})
# Pagination
query = query.offset(args['page'] * args['per_page'])
query = query.limit(args['per_page'])
result = query.all()
# Display only the selected fields
selected_fields = filter_dict(fields, args['select'].split(','))
return restful.marshal(result, selected_fields)
list_ = type(
'{}List'.format(classname), (restful.Resource, ), {
'get': get_list,
'__resource_name__': resource_name,
'__model__': model
})
# Create Resource Single class
single_parser = RequestParser()
single_parser.add_argument('select',
type=str,
default=','.join(fields.keys()))
def get_single(self, pk):
args = single_parser.parse_args()
query = self.__model__.queryset
result = query.get(pk)
# Display only the selected fields
selected_fields = filter_dict(fields, args['select'].split(','))
return restful.marshal(result, selected_fields)
single = type(
classname, (restful.Resource, ), {
'get': get_single,
'__resource_name__': resource_name,
'__model__': model
})
return list_, single
from flask.ext.restful.reqparse import RequestParser
from . import api
from .errors import BadRequest
from .helpers import Resource
from .index import index_links
from .jwt import generate_token, is_verified
parser = RequestParser(bundle_errors=True)
parser.add_argument("username", required=True)
parser.add_argument("password", required=True)
@api.route("/api/login")
@index_links.add("login", method="POST", condition=lambda x: not is_verified())
class Login(Resource):
method_decorators = []
def post(self):
args = parser.parse_args()
if args["username"] == "ssh" and args["password"] == "homework":
return {"token": generate_token(args["username"])}
raise BadRequest("Login failed")
if isinstance(resp, tuple):
return resp[0], resp[1]
if isinstance(resp, Pagination):
return {'items': _filter_items(resp.items), 'total': resp.total}
if isinstance(resp, list):
return {'items': _filter_items(resp), 'total': len(resp)}
return marshal(resp, self.fields)
except Exception as e:
current_app.logger.exception(e)
# this is a little weird hack to respect flask restful parsing errors on marshaled functions
if hasattr(e, 'code'):
if hasattr(e, 'data'):
return {'message': e.data['message']}, 400
else:
return {'message': {'exception': 'unknown'}}, 400
else:
return {'message': {'exception': str(e)}}, 400
return wrapper
paginated_parser = RequestParser()
paginated_parser.add_argument('count', type=int, default=10, location='args')
paginated_parser.add_argument('page', type=int, default=1, location='args')
paginated_parser.add_argument('sortDir', type=str, dest='sort_dir', location='args')
paginated_parser.add_argument('sortBy', type=str, dest='sort_by', location='args')
paginated_parser.add_argument('filter', type=str, location='args')
url_for
)
from flask.ext.restful.reqparse import RequestParser
from vpnchooser.syncer import sync
from vpnchooser.helpers import (
require_login,
id_from_url
)
from vpnchooser.helpers.fields import AbsoluteUrl, NullableAbsoluteUrl
from vpnchooser.db import session, Device, Vpn
parser = RequestParser()
parser.add_argument(
'ip', type=str,
required=True,
)
parser.add_argument(
'name', type=str,
required=True,
)
parser.add_argument(
'type', type=str,
required=False,
)
parser.add_argument(
'vpn', type=str,
required=False
)
resource_fields = {
abort,
url_for
)
from flask.ext.restful.reqparse import RequestParser
from vpnchooser.helpers import (
require_admin, require_login
)
from vpnchooser.helpers.fields import AbsoluteUrl
from vpnchooser.db import session, Vpn
parser = RequestParser()
parser.add_argument(
'name', type=str,
required=True,
help='The name of the vpn.'
)
parser.add_argument(
'description', type=str,
required=True,
)
parser.add_argument(
'table', type=str,
required=True,
)
resource_fields = {
'id': fields.Integer,
'name': fields.String,
'description': fields.String,
ret = get_model_changes(attr.value)
if ret is not None:
changes[attr.key] = ret
else:
history = attr.history
if attr.state.modified and history.has_changes():
changes[attr.key] = {
'before': history.deleted[0],
'after': history.added[0]
}
return changes
pagination_parser = RequestParser()
pagination_parser.add_argument('page', type=int, required=False, default=1)
pagination_parser.add_argument('perPage', type=int, required=False, default=20)
# the empty list used when return result is empty
empty_list = {"objects": {}, "page": 1, "pages": 0, "total": 0, "per_page": 20}
@contextlib.contextmanager
def profiled():
pr = cProfile.Profile()
pr.enable()
yield
pr.disable()
s = StringIO.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
ps.print_stats()
# First declare a Flask Blueprint for this module
judgements_api = Blueprint('judgements_api', __name__)
# Then pack the blueprint into a Flask-Restful API
api = new_restful_api(judgements_api)
all_judgements_api = Blueprint('all_judgements_api', __name__)
apiAll = new_restful_api(all_judgements_api)
def judgement_type(value):
return dict(value)
new_judgement_parser = RequestParser()
new_judgement_parser.add_argument('answerpair_id',
type=int,
required=True,
help="Missing answer pair id.")
new_judgement_parser.add_argument('judgements',
type=judgement_type,
required=True,
action="append",
help="Missing judgements.")
# events
on_answer_pair_get = event.signal('ANSWER_PAIR_GET')
on_judgement_create = event.signal('JUDGEMENT_CREATE')
on_judgement_question_count = event.signal('JUDGEMENT_QUESTION_COUNT')
on_judgement_course_count = event.signal('JUDGEMENT_COURSE_COUNT')
# First declare a Flask Blueprint for this module
judgements_api = Blueprint('judgements_api', __name__)
# Then pack the blueprint into a Flask-Restful API
api = new_restful_api(judgements_api)
all_judgements_api = Blueprint('all_judgements_api', __name__)
apiAll = new_restful_api(all_judgements_api)
def judgement_type(value):
return dict(value)
new_judgement_parser = RequestParser()
new_judgement_parser.add_argument(
'answerpair_id', type=int, required=True,
help="Missing answer pair id.")
new_judgement_parser.add_argument(
'judgements', type=judgement_type, required=True, action="append", help="Missing judgements.")
# events
on_answer_pair_get = event.signal('ANSWER_PAIR_GET')
on_judgement_create = event.signal('JUDGEMENT_CREATE')
on_judgement_question_count = event.signal('JUDGEMENT_QUESTION_COUNT')
on_judgement_course_count = event.signal('JUDGEMENT_COURSE_COUNT')
# /
class JudgementRootAPI(Resource):
template_folder='templates',
static_folder='static',
static_url_path='/receita/static')
# Create the restful API
receita_api = restful.Api(receita, prefix="/api/v1")
# receita_api.decorators = [cors.crossdomain(origin='*')]
# class Date(fields.Raw):
# def format(self, value):
# return str(value)
# Parser for RevenueAPI arguments
revenue_list_parser = RequestParser()
revenue_list_parser.add_argument('page', type=int, default=0)
revenue_list_parser.add_argument('per_page_num', type=int, default=100)
revenue_list_parser.add_argument('years', type=int, action='append')
revenue_list_parser.add_argument('code')
# Fields for RevenueAPI data marshal
revenue_fields = { 'id': fields.Integer()
, 'date': fields.DateTime(dt_format='iso8601')
, 'description': fields.String()
, 'code': fields.String(attribute='original_code')
, 'monthly_predicted': fields.Float()
, 'monthly_outcome': fields.Float() }
class RevenueApi(restful.Resource):
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('tag',
type=str,
required=True,
help='Tag of event',
location='json')
parser.add_argument('name',
type=str,
required=True,
help='Name needs to be defined',
location='json')
parser.add_argument(
'date',
type=str,
required=True,
help='Date needs to be defined',
location='json') # Cambiar el type por lo que corresponde.
parser.add_argument(
'time',
type=str,
required=False,
help='Time of event',
location='json') # Cambiar el type por lo que corresponde.
parser.add_argument('venue',
type=dict,
required=True,
help='Venue needs to be defined',
location='json')
parser.add_argument('requirement',
type=list,
required=False,
location='json')
parser.add_argument('image',
type=str,
required=True,
help='Image needs to be defined',
location='json')
parser.add_argument('description',
type=str,
required=False,
help='Description of event',
location='json')
parser.add_argument('visibility',
type=str,
required=True,
help='Visibility of event',
location='json')
parser.add_argument('gests',
type=list,
required=False,
help='Gests of event',
location='json'),
parser.add_argument('capacity',
type=int,
required=True,
help='Capacity of event',
location='json')
return parser
template_folder='templates',
static_folder='static',
static_url_path='/receita/static')
# Create the restful API
receita_api = restful.Api(receita, prefix="/api/v1")
class Date(fields.Raw):
def format(self, value):
return str(value)
# Parser for RevenueAPI arguments
revenue_list_parser = RequestParser()
revenue_list_parser.add_argument('page', type=int, default=0)
revenue_list_parser.add_argument('per_page_num', type=int, default=100)
revenue_list_parser.add_argument('years', type=int, action='append')
# Fields for RevenueAPI data marshal
revenue_fields = {
'id': fields.Integer(),
'date': Date,
'description': fields.String(),
'code': fields.String(),
'monthly_predicted': fields.Float(),
'monthly_outcome': fields.Float()
}
class RevenueApi(restful.Resource):
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/contrato/static')
# Create the restful API
contratos_api = restful.Api(contratos, prefix="/api/v1")
# receita_api.decorators = [cors.crossdomain(origin='*')]
# class Date(fields.Raw):
# def format(self, value):
# return str(value)
# Parser for RevenueAPI arguments
contratos_list_parser = RequestParser()
contratos_list_parser.add_argument('cnpj')
contratos_list_parser.add_argument('orgao')
contratos_list_parser.add_argument('modalidade')
contratos_list_parser.add_argument('evento')
contratos_list_parser.add_argument('objeto')
contratos_list_parser.add_argument('processo_administrativo')
contratos_list_parser.add_argument('nome_fornecedor')
contratos_list_parser.add_argument('licitacao')
contratos_list_parser.add_argument('group_by', default='')
contratos_list_parser.add_argument('order_by', 'id')
contratos_list_parser.add_argument('page', type=int, default=0)
contratos_list_parser.add_argument('per_page_num', type=int, default=100)
# Fields for ContratoAPI data marshal
contratos_fields = {
'id': fields.Integer(),
# -*- encoding: utf-8 -*-
from flask.ext.restful import (Resource, fields, marshal_with, abort, url_for)
from flask.ext.restful.reqparse import RequestParser
from vpnchooser.syncer import sync
from vpnchooser.helpers import (require_login, id_from_url)
from vpnchooser.helpers.fields import AbsoluteUrl, NullableAbsoluteUrl
from vpnchooser.db import session, Device, Vpn
parser = RequestParser()
parser.add_argument(
'ip',
type=str,
required=True,
)
parser.add_argument(
'name',
type=str,
required=True,
)
parser.add_argument(
'type',
type=str,
required=False,
)
parser.add_argument('vpn', type=str, required=False)
resource_fields = {
'id': fields.Integer,
'ip': fields.String,
def _get_args(self, request):
parser = RequestParser()
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
return args
from .core import db
from .authorization import require, allow, is_user_access_restricted
from .models import Posts, PostsForAnswers, PostsForQuestions, Courses, Users, \
Judgements, AnswerPairings, Scores, GroupsAndUsers, CoursesAndUsers, UserTypesForCourse
from .util import new_restful_api, get_model_changes, pagination_parser
from .attachment import add_new_file, delete_file
from .core import event
answers_api = Blueprint('answers_api', __name__)
api = new_restful_api(answers_api)
all_answers_api = Blueprint('all_answers_api', __name__)
apiAll = new_restful_api(all_answers_api)
new_answer_parser = RequestParser()
new_answer_parser.add_argument('user', type=int, default=None)
new_answer_parser.add_argument('content', type=str, default=None)
new_answer_parser.add_argument('name', type=str, default=None)
new_answer_parser.add_argument('alias', type=str, default=None)
existing_answer_parser = RequestParser()
existing_answer_parser.add_argument('id', type=int, required=True, help="Answer id is required.")
existing_answer_parser.add_argument('content', type=str, default=None)
existing_answer_parser.add_argument('name', type=str, default=None)
existing_answer_parser.add_argument('alias', type=str, default=None)
existing_answer_parser.add_argument('uploadedFile', type=bool, default=False)
answer_list_parser = pagination_parser.copy()
answer_list_parser.add_argument('group', type=int, required=False, default=None)
answer_list_parser.add_argument('author', type=int, required=False, default=None)
answer_list_parser.add_argument('orderBy', type=str, required=False, default=None)
from flask.ext.restful import Resource, marshal_with
from flask.ext.restful.reqparse import RequestParser
import logic
from utils import quote_marshaller
parser = RequestParser()
parser.add_argument('text', type=str, required=True)
# noinspection PyMethodMayBeStatic
class QuotesList(Resource):
@marshal_with(quote_marshaller)
def get(self):
return logic.get_active()
def post(self):
text = parser.parse_args().get('text', None)
return logic.create(text)
# noinspection PyMethodMayBeStatic
class Quote(Resource):
@marshal_with(quote_marshaller)
def get(self, quote_id):
return logic.read(quote_id)
@marshal_with(quote_marshaller)
def post(self, quote_id):
{{ "~" * (cookiecutter.app_name ~ ".frontend.security")|count }}
:author: {{ cookiecutter.author }}
:copyright: © {{ cookiecutter.copyright }}
:license: {{ cookiecutter.license }}, see LICENSE for more details.
templated from https://github.com/ryanolson/cookiecutter-webapp
"""
from flask import current_app, jsonify, request
from flask.ext.classy import FlaskView, route
from flask.ext.jwt import generate_token
from flask.ext.restful.reqparse import RequestParser
from flask.ext.security import current_user
request_options = RequestParser()
request_options.add_argument('Content-Type', type=str, location='headers')
class AuthView(FlaskView):
@route('/jwt/token', methods=['POST'])
def jwt_token(self):
"""
Returns a JWT token if the user is logged in and the post has
content type application/json. All errors are returned as json.
"""
if not current_user.is_authenticated():
return jsonify({
"status": 401,
"message": "No user authenticated",
}), 401, {
"WWW-Authenticate": "None"
def _create_classes(self, model, resource_metadata):
resource_name = resource_metadata.name
classname = to_camelcase(resource_name)
# Create Resource List class
list_parser = RequestParser()
fields = {
'_uid': restful_fields.Integer # Internal id
}
for field in resource_metadata.schema.get('fields', []):
# JSON properties names are camelCase
property_name = to_camelcase(field.get('name'), False)
# but SQLAlchemy columns are snake_case
column_name = to_underscore(field.get('name'))
# Add a filter argument for each column
list_parser.add_argument(property_name, action='append')
# Map JSON properties to SQLAlchemy columns
args = []
kwargs = {'attribute': column_name}
fields[property_name] = get_field_type(TYPES, field)(*args,
**kwargs)
# Expect pagination arguments
list_parser.add_argument('page', type=int, default=0)
list_parser.add_argument('per_page', type=int, default=100)
list_parser.add_argument('select', type=str,
default=','.join(fields.keys()))
def get_list(self):
args = list_parser.parse_args()
query = self.__model__.queryset
# Filters
for field in resource_metadata.schema.get('fields', []):
# JSON properties names are camelCase
property_name = to_camelcase(field.get('name'), False)
# but SQLAlchemy columns are snake_case
column_name = to_underscore(field.get('name'))
# Get the argument value from URL query, if any
values = args[property_name]
if values is not None:
query = query.in_(**{column_name: values})
# Pagination
query = query.offset(args['page'] * args['per_page'])
query = query.limit(args['per_page'])
result = query.all()
# Display only the selected fields
selected_fields = filter_dict(fields, args['select'].split(','))
return restful.marshal(result, selected_fields)
list_ = type('{}List'.format(classname), (restful.Resource, ), {
'get': get_list,
'__resource_name__': resource_name,
'__model__': model
})
# Create Resource Single class
single_parser = RequestParser()
single_parser.add_argument('select', type=str,
default=','.join(fields.keys()))
def get_single(self, pk):
args = single_parser.parse_args()
query = self.__model__.queryset
result = query.get(pk)
# Display only the selected fields
selected_fields = filter_dict(fields, args['select'].split(','))
return restful.marshal(result, selected_fields)
single = type(classname, (restful.Resource, ), {
'get': get_single,
'__resource_name__': resource_name,
'__model__': model
})
return list_, single
def create_parser(self):
parser = RequestParser(bundle_errors=True)
parser.add_argument('username',
type=str,
required=True,
help='Name needs to be defined',
location='json')
parser.add_argument('password',
type=str,
required=False,
help='Password needs to be defined',
location='json')
parser.add_argument('email',
type=str,
required=True,
help='Email needs to be defined',
location='json')
parser.add_argument('firstName',
type=str,
required=False,
location='json')
parser.add_argument('lastName',
type=str,
required=False,
location='json')
parser.add_argument('phone', type=str, required=False, location='json')
return parser
