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 concrete_backend():
parser = RequestParser()
for argument in arguments:
parser.args.append(argument)
user, created = func(parser.parse_args())
current_app.db.session.commit()
login_user(user)
return user, created
def concrete_backend():
parser = RequestParser()
for argument in arguments:
parser.args.append(argument)
user, created = func(parser.parse_args())
current_app.db.session.commit()
login_user(user)
return user, created
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(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 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 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)
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 __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 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}
class SystemOptionsAPIView(APIView):
def get(self):
options = dict((o.name, o.value) for o in SystemOption.query.all())
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
for option in OPTION_DEFAULTS.keys():
post_parser.add_argument(option)
@requires_admin
def post(self):
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(SystemOption,
where={
'name': name,
},
values={
'value': value,
})
return '', 200
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):
parser = RequestParser()
parser.add_argument('token', type=str)
args = parser.parse_args()
if UserService.check_token(args['token']):
return {'message': 'success'}
return {'message': 'error'}
class UserOptionsAPIView(APIView):
# get is not implemented...add functionality to initial_index instead if
# needed
post_parser = RequestParser()
post_parser.add_argument('user.colorblind')
def post(self):
user = get_current_user()
if user is None:
return error("User not found", http_code=404)
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': user.id,
'name': name,
},
values={
'value': value,
})
return self.respond({})
def post(self):
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('password', type=str)
parser.add_argument('re_password', type=str)
parser.add_argument('phone', type=str)
parser.add_argument('address', type=str)
parser.add_argument('description', type=str)
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})
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('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 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 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, 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('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 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('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):
# 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 __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):
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('password', type=str)
args = parser.parse_args()
salted_string = (args['password'] + SALT)
hashed_pwd = hash_sha(salted_string)
if user_service.check_login(args['email'], hashed_pwd):
return {
'message': 'ok',
'token': user_service.get_token(args['email'], hashed_pwd)
}
else:
return {'message': 'error'}
def post(self):
try:
parser = RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('token', type=str)
args = parser.parse_args()
pwd = ''.join(choice(ascii_uppercase) for i in range(8))
salted_string = (pwd + SALT)
hashed_pwd = hash_sha(salted_string)
UserService.create_user(args['email'], hashed_pwd, args['token'])
send_mail(
args['email'], "Account information",
"Hi, This is your temporary password for your account: " + pwd)
return {'message': 'ok'}
except:
return {'message': 'error'}
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 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 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
class PlanOptionsAPIView(APIView):
def get(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return error("Plan not found", http_code=404)
options = dict(
(o.name, o.value)
for o in ItemOption.query.filter(ItemOption.item_id == plan.id, ))
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
post_parser.add_argument('bazel.autogenerate')
post_parser.add_argument('build.expect-tests')
post_parser.add_argument('build.timeout')
post_parser.add_argument('snapshot.allow')
post_parser.add_argument('snapshot.require')
@requires_project_admin(get_project_slug_from_plan_id)
def post(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return error("Plan not found", http_code=404)
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': plan.id,
'name': name,
},
values={
'value': value,
})
return self.respond({})
def post(self):
parser = RequestParser()
parser.add_argument('file', type=werkzeug.datastructures.FileStorage)
parser.add_argument('name', type=str)
parser.add_argument('price', type=str)
parser.add_argument('description', type=str)
parser.add_argument('type', type=int)
parser.add_argument('token', type=str)
args = parser.parse_args()
if UserService.check_token(args['token']):
if args['type'] == 0:
return {'message': 'success'}
ImageService.save_2d_image(args)
else:
ImageService.save_3d_image(args)
return {'message': 'success'}
return {'message': 'error'}, 403
class PlanOptionsAPIView(APIView):
def get(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return '', 404
options = dict(
(o.name, o.value)
for o in ItemOption.query.filter(ItemOption.item_id == plan.id, ))
for key, value in OPTION_DEFAULTS.iteritems():
options.setdefault(key, value)
return self.respond(options)
post_parser = RequestParser()
post_parser.add_argument('build.expect-tests')
post_parser.add_argument('build.timeout')
post_parser.add_argument('snapshot.allow')
@requires_admin
def post(self, plan_id):
plan = Plan.query.get(plan_id)
if plan is None:
return '', 404
args = self.post_parser.parse_args()
for name, value in args.iteritems():
if value is None:
continue
create_or_update(ItemOption,
where={
'item_id': plan.id,
'name': name,
},
values={
'value': value,
})
return '', 200
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 {}
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 parse_with(*arguments, **kwargs):
"""This decorator allows you to easily augment any method (typically a
view method) to access reqparse based arguments, i.e.:
class Users(Resource):
@parse_with(Argument('profession'))
def post(self, params, username):
create_new_user(username, params.profession)
return 'CREATED', 201
api.add_resource(Users, '/<username>', endpoint='users')
"""
parser = kwargs.pop('parser', RequestParser())
if kwargs: # mimic py3k style named-arguments after *args, i.e., def f(a, *b, c=1)
raise TypeError("unexpected keyword argument '%s'" % (kwargs.popitem()[0],))
for argument in arguments:
parser.args.append(argument)
def decor(func):
@wraps(func)
def inner(self, *args, **kwargs):
return func(self, parser.parse_args(), *args, **kwargs)
return inner
return decor
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"}
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):
__name__,
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()
}
def _get_args(self, request):
parser = RequestParser()
parser.add_argument('user', location='args', default=None)
args = parser.parse_args(request)
return args
contratos = Blueprint('contratos',
__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 = {
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")
from flask.ext.restful.reqparse import RequestParser
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,
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)
receita = Blueprint('receita', __name__,
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):
from application.conc import jump_to_conclusions
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)
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
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')
# 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):
"""
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
if attr.key in synonyms:
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')
