def post(self):
"""Creates a new object.
Returns:
A JSON representation of the saved object.
"""
try:
args = parser.parse(self.searchargs, request)
schema = self.resource_object.get_realschema(args)(strict=True)
return parser.parse(schema, request).save()
except GenericYetiError as err:
return err, 400
def get(self, product_id=None):
if not product_id:
args = {
'type': fields.List(fields.Int()),
'product_id': fields.List(fields.Int())
}
try:
args = parser.parse(args, request)
except HTTPException:
return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST
if args.get('product_id', None):
products = []
for p_id in args['product_id']:
element = Product.query.filter_by(id=p_id).first()
if not element:
resp = {"error": "Does not exist."}
status_code = status.HTTP_400_BAD_REQUEST
break
products.append(element)
else:
resp = ProductFromListSchema(many=True).dump(
obj=products).data
status_code = status.HTTP_200_OK
return resp, status_code
try:
products = Product.query.filter(Product.type.in_(
args['type'])).all()
except KeyError:
return {"error": "Missing type id."}, 400
resp = ProductSchema(many=True).dump(obj=products).data
return resp, status.HTTP_200_OK
args = {'download': fields.Boolean()}
try:
args = parser.parse(args, request)
except HTTPException:
return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST
if args.get('download', None):
file_data = Product.query.get(product_id)
response = send_file(BytesIO(file_data.photo),
attachment_filename='image.png',
as_attachment=True)
return response
try:
product = Product.query.get(product_id)
except DataError:
return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST
if product is None:
return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST
product = ProductSchema().dump(obj=product).data
return product, status.HTTP_200_OK
def post(self):
args = parser.parse(self.post_args, request)
username, password = args['username'], args['password']
user = db.session.query(User) \
.filter(User.username == username) \
.filter(User.deleted.isnot(True)) \
.options(joinedload(User.roles)) \
.one_or_none()
if user is None:
raise exc.NotFound('User with this username does not exist')
is_password_valid = User.check_password(user.password_md5, password)
if not is_password_valid:
current_app.logger.warning(f'user_email={args["username"]} '
f'has failed to log in')
raise exc.Forbidden('Invalid password')
current_app.logger.debug(f'user_email={args["username"]} has logged in')
token = generate_refresh_token(user)
refresh_token = RefreshToken(token=token, user_id=user.id)
db.session.add(refresh_token)
db.session.commit()
user_serializer = UserAuthSerializer()
user.refresh_token = token
user_data = user_serializer.dump(user)
return jsonify(user_data.data)
def subject_create():
teachers = Teacher.query.all()
teacher_list = dict()
if teachers:
teacher_list = [{
'id': teacher.id,
'fio': teacher.name
} for teacher in teachers]
if request.method == 'POST':
data = parser.parse(subects_create_post, request)
subject = Subject()
if data:
for item in data.items():
if item[0] == 'name':
subject.name = item[1]
if item[0] == 'desc':
subject.desc = item[1]
if item[0] == 'teacher_id':
teacher = Teacher.query.get(item[1])
if not teacher:
return redirect(url_for('bp_web.subjects'))
subject.teacher = teacher
session.add(subject)
session.commit()
return redirect(url_for('bp_web.subjects'))
return render_template('subjects_edit.html', teacher_list=teacher_list)
def get(self, problem_id: int):
args = parser.parse(get_args, request)
query = self._build_query_by_args(args, problem_id)
query = query.options(
Load(Problem).load_only('id', 'name'),
Load(SimpleUser).load_only('id', 'firstname', 'lastname'))
per_page_count = args.get('count')
page = args.get('page')
result = query.paginate(page=page,
per_page=per_page_count,
error_out=False,
max_per_page=100)
runs = []
for run, user, problem in result.items:
run.user = user
run.problem = problem
runs.append(run)
metadata = {'count': result.total, 'page_count': result.pages}
schema = RunSchema(many=True)
data = schema.dump(runs)
return flask_jsonify({
'result': 'success',
'data': data.data,
'metadata': metadata
})
def login():
"""Allows users to login"""
args = parser.parse(user_args, request)
user = User.query.filter_by(username=args["username"]).first()
if user is None:
user = User(username=str(args["username"]), email=str(args["email"]))
user.set_password(args["password"])
db.session.add(user)
db.session.commit()
login_user(user, remember=True)
return jsonify({
"msg": f"Successfully created user with username {user.username}",
"User": user.asdict(),
})
login_user(user, remember=True)
if not current_user.check_password(args["password"]):
return jsonify("The password you entered was invalid.")
if current_user.is_authenticated:
return redirect("/mood")
def filter(self):
"""Search the database for object with specific fields."""
try:
args = parser.parse(self.searchargs, request)
return self.resource_object.filter(args)
except ValidationError as err:
return err, 400
def get(self, run_id: int):
args = parser.parse(self.get_args, request)
is_admin = args.get('is_admin')
user_id = args.get('user_id')
run_q = db.session.query(Run)
if not is_admin:
run_q = run_q.filter(Run.user_id == user_id)
run = run_q.filter(Run.id == run_id).one_or_none()
if run is None:
raise NotFound(f'Run with id #{run_id} is not found')
language_id = run.ejudge_language_id
source = run.source or b''
for encoding in POSSIBLE_SOURCE_ENCODINGS:
try:
source = source.decode(encoding)
break
except UnicodeDecodeError:
pass
return jsonify({'source': source, 'language_id': language_id})
def inner(self, *args, **kwargs):
_default_size = default_size(self) \
if callable(default_size) else default_size
_max_results = max_results(self) \
if callable(max_results) else max_results
try:
req = parser.parse(
{
'page':
fields.Int(validate=validate.Range(min=1), ),
'from':
fields.Int(
load_from='from',
validate=validate.Range(min=1),
),
'size':
fields.Int(validate=validate.Range(min=1),
missing=_default_size),
},
locations=['querystring'],
validate=_validate_pagination_args,
error_status_code=400,
)
# For validation errors, webargs raises an enhanced BadRequest
except BadRequest as err:
raise SearchPaginationRESTError(
description='Invalid pagination parameters.',
errors=err.data.get('messages'))
# Default if neither page nor from is specified
if not (req.get('page') or req.get('from')):
req['page'] = 1
if req.get('page'):
req.update(
dict(from_idx=(req['page'] - 1) * req['size'],
to_idx=req['page'] * req['size'],
links=dict(
prev={'page': req['page'] - 1},
self={'page': req['page']},
next={'page': req['page'] + 1},
)))
elif req.get('from'):
req.update(
dict(from_idx=req['from'] - 1,
to_idx=req['from'] - 1 + req['size'],
links=dict(
prev={'from': max(1, req['from'] - req['size'])},
self={'from': req['from']},
next={'from': req['from'] + req['size']},
)))
if req['to_idx'] > _max_results:
raise SearchPaginationRESTError(description=(
'Maximum number of {} results have been reached.'.format(
_max_results)))
return f(self, pagination=req, *args, **kwargs)
def post(self):
args = parser.parse(device_args, request)
device = Devices.query.filter_by(device_name=args['device_name']).first()
if device is not None:
return conflict("Device with name {n} already exists".format(n=args['device_name'])), 409
try:
device_id = str(uuid.uuid4())
location = None
temperature_sensor = False
humidity_sensor = False
uptime = 1
if 'location' in args:
location = args['location']
if 'temperature_sensor' in args:
temperature_sensor = True
if 'humidity_sensor' in args:
humidity_sensor = True
if 'uptime' in args:
uptime = long(args['uptime'])
else:
uptime = long(0)
device = Devices(device_id=device_id,
device_name=args['device_name'],
location=location,
temperature_sensor=temperature_sensor,
humidity_sensor=humidity_sensor,
uptime=uptime)
db.session.add(device)
db.session.commit()
return "Location: " + device.url, 200
except Exception as e:
return internal_error("Server Error " + str(e)), 500
def patch(self, game_id):
"""
Obtains a game from the database
"""
json_data = request.get_json(force=True)
args = parser.parse(get_args, request)
session = DbSessionHolder().get_session()
if game_id is None:
return make_response(jsonify({"error": "You need to specify the game ID."}),
status.HTTP_400_BAD_REQUEST)
try:
game_data = add_game_code_id_to_guess(session,
int(game_id),
json_data["game_code_uri"],
args["expand_resources"])
if game_data is None:
return make_response(jsonify({"error": "Game not found."}),
status.HTTP_404_NOT_FOUND)
return make_response(jsonify(game_data),
status.HTTP_200_OK)
except Exception, e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_500_INTERNAL_SERVER_ERROR)
def new_employee():
employee = parser.parse(EmployeeSchema(strict=True))
db.session.add(employee)
db.session.commit()
return (build_result(employee, EmployeeSchema()), 201, {
'Location': url_for('.get_employee', id=employee.id)
})
def post(self):
args = parser.parse(signup_args, request)
if User.objects(username=args['email']):
return api_abort(422, "Eamil已注册")
elif User.objects(username=args['username']):
return api_abort(422, "用户名已存在")
try:
u = User(
email=args["email"].lower(),
username=args["username"],
# TODO: nginx
avatar='http://192.168.1.106:8000/avatar/r{0}.png'.format(
random.randint(1, 10)))
u.set_password(args["password"])
u.save()
if os.getenv('FLASK_ENV') == 'development':
# 发送 email
uid = User.objects(email=args['email']).first().id
send_confirm_email(args['email'], args['username'],
generate_token(uid))
return '', 201
except Exception as e:
current_app.logger.error(e)
return api_abort(500)
def get(self, basket_id=None):
if not basket_id:
args = {
'user_id': fields.Int(required=True),
'state': fields.Boolean()
}
try:
args = parser.parse(args, request)
except HTTPException:
return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST
try:
baskets = Basket.query.filter(
Basket.user_id == args['user_id']).filter(
Basket.state == args['state']).all()
except KeyError:
return {
"error": "user_id and state is required"
}, status.HTTP_400_BAD_REQUEST
resp = BasketSchema(many=True).dump(obj=baskets).data
return resp, status.HTTP_200_OK
try:
basket = Basket.query.get(basket_id)
except DataError:
return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST
if basket is None:
return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST
basket = BasketSchema().dump(obj=basket).data
return basket, status.HTTP_200_OK
def post_lead():
json = parser.parse({
'email': fields.Email(required=True),
'first_name': fields.Str(required=False),
}, request)
lead = Lead.create(**json)
return Response(lead).to_dict()
def login(self):
"""
Authentication
"""
args = parser.parse(self.login_args).get('user')
user = User.authenticate(args['email'], args['password'])
return user_schema.jsonify({'user': user})
def test_get_multiple(self, mock_request):
mock_request.method = 'GET'
mock_request.args = MultiDict({
'f': 'value',
'net': 'CH',
'sta': 'DAVOX,BALST',
'start': '2017-01-01',
'end': '2017-01-07'
})
reference_sncls = [
sncl.StreamEpoch.from_sncl(network='CH',
station='DAVOX',
location='*',
channel='*',
starttime=datetime.datetime(2017, 1, 1),
endtime=datetime.datetime(2017, 1, 7)),
sncl.StreamEpoch.from_sncl(network='CH',
station='BALST',
location='*',
channel='*',
starttime=datetime.datetime(2017, 1, 1),
endtime=datetime.datetime(2017, 1, 7))
]
test_args = parser.parse(self.TestSchema(),
mock_request,
locations=('query', ))
self.assertEqual(dict(test_args), {'f': 'value'})
sncls = fdsnws.fdsnws_parser.parse(
schema.ManyStreamEpochSchema(context={'request': mock_request}),
mock_request,
locations=('query', ))['stream_epochs']
self.assertEqual(sncls, reference_sncls)
def post(self):
arg_fields = {
'email':
String(required=True),
'username':
String(required=True, max=32),
'plaintext_password':
String(required=True),
'local_tz':
String(required=True, validate=validate.OneOf(pytz.all_timezones)),
}
args = parser.parse(arg_fields)
try:
user_info = UserFacade().create_user(args['email'],
args['plaintext_password'],
args['local_tz'],
args['username'])
except Exception as e:
logging.error(
'Random exception encountered registering user {0}'.format(e))
raise EndpointException('Failed to register user.')
logging.info('Successfully created new user at {0}'.format(
args['email']))
return jsonify(UserMarshal().dump(user_info).data)
def patch(self, bucket_id, item_id):
"""Patch a bucket list item."""
args = parser.parse(ItemOperations.update_items_args, request)
done = args.get("done")
# get item
item = self.profile.get_item(item_id=item_id, buc_id=bucket_id)
bucket = self.profile.get_bucket(bucket_id=bucket_id)
if not item or not bucket and item.bucket_id != bucket.id:
return {"message": "Item not found in bucket"}, 404
# editted
edit = self.profile.edit_asset(item=True,
done=done,
asset_id=item_id,
buc_id=bucket_id)
if not edit:
return {"message": "Unable to edit item"}, 422
# get item
return {
"message": "Patched Item succesfully",
"item": item.to_dict()
}, 200
def put(self, id):
data = parser.parse(self.__class__._schema, request)
with db.session.no_autoflush:
record = self.__class__.update_or_create(data, id)
return self.__class__._schema().dump(record)
def create_note():
user = get_user()
note = parser.parse(NoteSchema(), request, locations=['json'])
note.author = user
db.session.add(note)
db.session.commit()
return jsonify(NoteSchema().dump(note).data)
def course_theme_edit(course_theme_id):
course_theme = CourseTheme.query.get(course_theme_id)
if not course_theme:
return redirect(url_for('bp_web.course_themes'))
if request.method == 'POST':
data = parser.parse(course_theme_create_post, request)
if data:
for item in data.items():
if item[0] == 'name':
course_theme.name = item[1]
session.commit()
return redirect(url_for('bp_web.course_themes'))
course_theme_data = {
'id': course_theme.id,
'name': course_theme.name,
'course_numbers_list': dict()
}
if course_theme.course_number:
course_theme_data['course_numbers_list'] = [{
'id':
course_number.id,
'number':
course_number.number
} for course_number in course_theme.course_number]
return render_template('course_themes_edit.html',
course_theme_data=course_theme_data)
def post(self, user_id):
arg_fields = {
'nonce': String(required=False),
'first_name': String(required=False),
'last_name': String(required=False),
}
args = parser.parse(arg_fields)
if args.get('nonce') is not None:
first_name = args.get('first_name')
last_name = args.get('last_name')
self._validate_first_and_last_name(first_name, last_name)
new_sub = self.sub_facade.create_new_subscription_with_customer(
user_id,
args['nonce'],
first_name,
last_name,
)
else:
new_sub = self.sub_facade.create_new_subscription(user_id, )
logging.info('Successfully created subscription for user {0}'.format(
user_id, ))
return jsonify(SubscriptionMarshal().dump(new_sub).data)
def insert_item_from_user():
try:
args = parser.parse(CREATE_INV_ITEM, request)
id_user = decode(request.headers['Authorization'],
SECRET_KEY,
algorithms='HS256')['id_user']
lista_item_ids = [
x.id_item for x in ListItems.get_full_item_list()
]
if args['id_item'] not in lista_item_ids:
return View.error(404, 'Item not found in')
item = InventoryItems.insert_item_from_user(
id_user, args['id_bin'], args['id_item'])
prox_item = ListItems.get_item(args['id_item'])
ListUsers.update_user_points(id_user, prox_item.points)
result = {
'id_user': item.id_user,
'id_bin': item.id_bin,
'id_item': item.id_item
}
except ValidationError as err:
return View.error(400, str(err))
return View.success(result)
def course_group_create(course_theme_id, course_number_id):
course_theme = CourseTheme.query.get(course_theme_id)
if not course_theme:
return redirect(
url_for('bp_web.course_theme_edit',
course_theme_id=course_theme_id))
course_number = course_theme.course_number_lazy.filter_by(
id=course_number_id).first()
if not course_number:
return redirect(
url_for('bp_web.course_theme_edit',
course_theme_id=course_theme_id))
course_group = CourseGroup()
data = parser.parse(course_group_create_post, request)
if data:
for item in data.items():
if item[0] == 'gid':
course_group.gid = int(item[1])
course_group.course_number = course_number
session.add(course_group)
session.commit()
return redirect(
url_for('bp_web.course_number_edit',
course_theme_id=course_theme_id,
course_number_id=course_number_id))
def add_new_meta_result():
args = {
'page_type': Arg(str, required=True),
'url': Arg(str, default=None),
'page_param': Arg(str, default=None),
'h1': Arg(str, default=None),
'meta_title': Arg(str, default=None),
'meta_description': Arg(str, default=None),
'meta_keywords': Arg(str, default=None),
'og_tags': Arg(str, default='{}'),
'twitter_cards': Arg(str, default='{}'),
'gplus_tags': Arg(str, default='{}')
}
data = parser.parse(args, request)
r = requests.post(api_base_url + '/seo/meta_data/add_meta_data', data)
message = "Error while adding meta data for " + data['page_type'] + ". Review the content and other parameters once, contact admin if that doesn't help!"
message_color = "red"
if json.loads(r.text)['result'] and json.loads(r.text)['result'] == 'Success':
message = "Meta data for " + data['page_type'] + " has been added successfully!"
message_color = "green"
return render_template('result.html', message=message, message_color=message_color)
def put(self, bucket_id):
"""Update this bucket list."""
args = parser.parse(BucketListOperations.update_bucket_args, request)
name = args["name"]
if not validat_str(name):
return {
"message":
"bucket name can only contain letters numbers and space"
}, 400
edit = self.profile.edit_asset(item=False,
name=name,
asset_id=bucket_id)
if edit is None:
return {"message": "Bucket not found"}, 404
if not edit:
return {"message": "Bucket not edited"}, 422
else:
data = self.profile.bucket_lists.get(bucket_id).to_dict()
return make_response(
{
"message": "Updated bucket succesfully",
"bucket": data
}, 201)
def post(self):
"""Create a new bucket list."""
args = parser.parse(BucketList.create_bucket_args, request)
# validate name
name = args["name"]
if not validat_str(name):
return {
"message":
"bucket name can only contain letters numbers and space"
}, 400
# query if bucket exists
if self.profile.get_bucket(name):
return {"message": "Bucket: " + name + " exists"}, 400
# create bucket
if not self.profile.add_bucket(name):
return {"message": "Server was unable to process request"}, 500
# get bucket
data = self.profile.get_bucket(name).to_dict()
return make_response(
{
"message": "bucket created succesfully",
"user": self.username,
"bucket": data
}, 201)
def get(self, order_id=None):
if not order_id:
args = {
'user_id': fields.Int()
}
try:
args = parser.parse(args, request)
except HTTPException:
return {"error": "Invalid url"}, status.HTTP_400_BAD_REQUEST
try:
orders = Order.query.filter(Order.user_id == args['user_id']).all()
except KeyError:
return {"error": "user_id is required"}, status.HTTP_400_BAD_REQUEST
for order in orders:
payment = Payment.query.get(order.payment)
order.payment_info = payment
resp = OrderSchema(many=True).dump(obj=orders).data
return resp, status.HTTP_200_OK
try:
order = Order.query.get(order_id)
except DataError:
return {"error": "Invalid url."}, status.HTTP_400_BAD_REQUEST
if order is None:
return {"error": "Does not exist."}, status.HTTP_400_BAD_REQUEST
payment = Payment.query.get(order.payment)
order.payment_info = payment
order = OrderSchema().dump(obj=order).data
return order, status.HTTP_200_OK
def post(self, user_id):
arg_fields = {
'first_name':
String(required=True),
'last_name':
String(required=True),
'street_address':
String(required=True),
'locality':
String(required=True),
'region':
String(required=True),
'postal_code':
String(required=True),
'country_code_alpha2':
String(required=True, validate=validate.Length(2)),
'is_default':
Boolean(required=True, default=False, missing=False),
'extended_address':
String()
}
args = parser.parse(arg_fields)
address = AddressDAO().create_address(user_id, **args)
logging.info(
'Successfully created new address {0} for user {1}.'.format(
address, user_id))
return jsonify(AddressMarshal().dump(address).data)
def post(self, bucket_id):
"""Create a new item in bucket list."""
args = parser.parse(Item.create_items_args, request)
name = args["name"]
description = args.get("description", "Let's Do this")
# validate name
if not validat_str(name):
return {
"message":
"bucket name can only contain letters numbers and space"
}, 400
# get bucket
bucket = self.profile.bucket_lists.get(bucket_id)
if bucket is None:
return {"message": "Bucket not found"}, 404
# get item
item = self.profile.get_item(name=name)
if item:
return {"message": "Item " + name + " exists"}, 400
# create item
if not self.profile.add_item(
name=name, description=description, buc_id=bucket_id):
return {"message": "Server error: Creating item failed"}, 500
# get item
data = self.profile.get_item(name=name).to_dict()
return {
"message": "Item created succesfully",
"bucket_id": bucket_id,
"item": data
}, 201
def rel_me_auth():
if request.method == "GET":
if "payload" not in session:
return render_template("login.html")
me = session["payload"]["me"]
else:
args = parser.parse({"me": fields.URL(required=True)},
request,
location="form")
me = args["me"]
# find supported profiles and use the first one
profiles = find_profiles(me)
if not profiles:
abort(
400,
{
"messages": [
f'Could not find a rel="me" link in {me} pointing to a valid profile ({", ".join(PROVIDERS)})'
]
},
)
profile = list(profiles)[0]
session["tentative_me"] = me
session["profiles"] = profiles
return redirect(url_for(f"{profile}.login"))
def update_employes(id):
employee = Employee.query.get_or_404(id)
args = parser.parse(EmployeeSchema(strict=True, partial=True,
context={'employee_id': employee.id}))
for key, value in args.items():
setattr(employee, key, value)
db.session.commit()
return build_result(employee, EmployeeSchema())
def user_merge():
args = parser.parse({
'user_key': wf.Str(missing=None),
'user_keys': wf.DelimitedList(wf.Str(), delimiter=',', required=True),
})
user_db_keys = [ndb.Key(urlsafe=k) for k in args['user_keys']]
user_dbs = ndb.get_multi(user_db_keys)
if len(user_dbs) < 2:
flask.abort(400)
user_dbs.sort(key=lambda user_db: user_db.created)
merged_user_db = user_dbs[0]
auth_ids = []
permissions = []
is_admin = False
is_active = False
for user_db in user_dbs:
auth_ids.extend(user_db.auth_ids)
permissions.extend(user_db.permissions)
is_admin = is_admin or user_db.admin
is_active = is_active or user_db.active
if user_db.key.urlsafe() == args['user_key']:
merged_user_db = user_db
auth_ids = sorted(list(set(auth_ids)))
permissions = sorted(list(set(permissions)))
merged_user_db.permissions = permissions
merged_user_db.admin = is_admin
merged_user_db.active = is_active
merged_user_db.verified = False
form_obj = copy.deepcopy(merged_user_db)
form_obj.user_key = merged_user_db.key.urlsafe()
form_obj.user_keys = ','.join(args['user_keys'])
form = UserMergeForm(obj=form_obj)
if form.validate_on_submit():
form.populate_obj(merged_user_db)
merged_user_db.auth_ids = auth_ids
merged_user_db.put()
deprecated_keys = [k for k in user_db_keys if k != merged_user_db.key]
merge_user_dbs(merged_user_db, deprecated_keys)
return flask.redirect(
flask.url_for('user_update', user_id=merged_user_db.key.id()),
)
return flask.render_template(
'user/user_merge.html',
title='Merge Users',
html_class='user-merge',
user_dbs=user_dbs,
merged_user_db=merged_user_db,
form=form,
auth_ids=auth_ids,
api_url=flask.url_for('api.admin.user.list'),
)
def get(self, bucket_id, **kwargs):
"""Get list of objects in the bucket.
.. http:get:: /files/(uuid:bucket_id)
Returns a JSON list with all the objects in the bucket.
**Request**:
.. sourcecode:: http
GET /files/0ecc3794-2b57-4834-be61-cb9c3ef60562 HTTP/1.1
Accept: application/json
Content-Type: application/json
Host: localhost:5000
:reqheader Content-Type: application/json
:query boolean versions: 1 (or true) in order to list all the
versions of the files. 0 (or false) for
the most recent versions of each file.
**Response**:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Length: 334
Content-Type: application/json
[
{
"checksum": "xxx",
"size": 110,
"url": "http://localhost:5000/files/c361fd5e.../f.pdf",
"uuid": "c361fd5e-5036-4387-8249-5fcc5a37e128"
},
{
"checksum": "xxx",
"size": 330,
"url": "http://localhost:5000/files/0ff1def.../f2.rst",
"uuid": "0ff1def0-5f09-4ba0-8ee8-ff42f99985ae"
}
]
:resheader Content-Type: application/json
:statuscode 200: no error
:statuscode 403: access denied
:statuscode 404: page not found
"""
args = parser.parse(self.get_args, request)
if bucket_id and Bucket.get(bucket_id):
object_list = []
for obj in Object.get_by_bucket(
bucket_id, versions=args.get('versions', False)
).all():
object_list.append(obj.serialize())
return {'json': object_list}
abort(404, 'The specified bucket does not exist or has been deleted.')
def wrapped(*args, **kwargs):
req_args = webargs_parser.parse({
'submission': webargs_fields.Int(),
'submission_id': webargs_fields.Int()
})
submission_id = req_args.get('submission', req_args.get('submission_id'))
if submission_id is None:
raise ResponseException("submission_id is required", StatusCode.CLIENT_ERROR)
return fn(submission_id, *args, **kwargs)
def validate_employee_data():
try:
e = parser.parse(EmployeeSchema(strict=True))
err = {'error': None}
except UnprocessableEntity as ex:
err = {'error': "Validation Error"}
if hasattr(ex, 'data') and 'messages' in ex.data:
err.update({'messages': ex.data['messages']})
return err, 200
def jsonpify(*args, **kwargs):
params = parser.parse({'callback': wf.Str(missing=None)})
if params['callback']:
content = '%s(%s)' % (
params['callback'], flask.jsonify(*args, **kwargs).data,
)
mimetype = 'application/javascript'
return flask.current_app.response_class(content, mimetype=mimetype)
return flask.jsonify(*args, **kwargs)
def post(self):
try:
args = parser.parse(reading_args)
log_id = post_reading(args, HUMIDITY)
return "Location: " + url_for("HumidityReadingsView:get", log_id=log_id, _external=True), 200
except InvalidRequestException as ire:
return handle_bad_request(ire.message), 422
except NotFoundError as nfe:
return not_found(nfe.message), 404
except Exception as e:
print traceback.format_exc()
return internal_error(), 500
def delete(self):
args = parser.parse(device_name_args, request)
device_name = args['device_name']
if device_name is not None and len(device_name) > 0:
try:
device = Devices.query.filter_by(device_name=device_name).first()
if device is None:
return not_found("Device Not Found " + device_name), 404
db.session.delete(device)
db.session.commit()
return "Device Deleted.", 200
except Exception as e:
return internal_error("Server Error " + str(e)), 500
def get_next_url(next_url=''):
args = parser.parse({
'next': wf.Str(missing=None), 'next_url': wf.Str(missing=None)
})
next_url = next_url or args['next'] or args['next_url']
if next_url:
do_not_redirect_urls = [flask.url_for(u) for u in [
'signin', 'signup', 'user_forgot', 'user_reset',
]]
if any(url in next_url for url in do_not_redirect_urls):
return flask.url_for('welcome')
return is_trusted_url(next_url)
return is_trusted_url(flask.request.referrer)
def param(name, cast=None):
def switch(case):
return {
int: wf.Int(missing=None),
bool: wf.Bool(missing=None),
list: wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
}.get(case)
if cast is None or cast is ndb.Key:
cast_ = wf.Str(missing=None)
else:
cast_ = switch(cast) or cast
args = parser.parse({name: cast_})
return ndb.Key(urlsafe=args[name]) if cast is ndb.Key else args[name]
def get_dbs(cls, query=None, ancestor=None, order=None, limit=None, cursor=None, **kwargs):
args = parser.parse({
'cursor': wf.Str(missing=None),
'limit': wf.Int(missing=None, validate=validate.Range(min=-1)),
'order': wf.Str(missing=None),
})
return util.get_dbs(
query or cls.query(ancestor=ancestor),
limit=limit or args['limit'],
cursor=cursor or args['cursor'],
order=order or args['order'],
**kwargs
)
def add_question():
args = {
'question': Arg(str, required=True),
'option_one': Arg(str, required=True),
'option_two': Arg(str, required=True),
'option_three': Arg(str),
'option_four': Arg(str)
}
data = parser.parse(args, request)
res = interface.insert_question(data['question'],data['option_one'],data['option_two'],data['option_three'],data['option_four'])
if res:
a = {'data':res}
return jsonify(a)
return 'failed'
def index(self):
## retrieve all items from db and dump it them to a list of json strings
print "in get function"
args = parser.parse(index_args, request)
app.logger.debug('GET request for all {}'.format(self.desc))
app.logger.debug('Arguments passed in: {}'.format(args))
objs = self.obj.query.all()
if objs:
obj_dict_list, errors = self.schema(many=True).dump(objs)
if errors:
return jsonify(errors), 500
return jsonify(obj_dict_list)
else:
return jsonify({'message' : 'No {}s found'.format(self.desc)})
def get_next_url(next_url=''):
args = parser.parse({
'next': wf.Str(missing=None), 'next_url': wf.Str(missing=None)
})
next_url = next_url or args['next'] or args['next_url']
do_not_redirect_urls = [flask.url_for(u) for u in [
'signin', 'signup', 'user_forgot', 'user_reset',
]]
if next_url:
if any(url in next_url for url in do_not_redirect_urls):
return flask.url_for('welcome')
return next_url
referrer = flask.request.referrer
if referrer and referrer.startswith(flask.request.host_url):
return referrer
return flask.url_for('welcome')
def order_create():
if request.method == 'GET':
return render_template('order/create.html', model={})
# POST
validator = Order.get_input_validator()
try:
args = parser.parse(validator, request)
except Exception as e:
return render_template('order/create.html', error=str(e.data['exc'].arg_name), model=request.form)
o = Order()
o.author = args['author']
o.name = args['name']
o.year = args['year']
o.user_login = current_user.login
o.save()
return redirect(url_for('orders'))
def keywordtool_api():
apikey = '579a5b85df0459956f0be0875d99083fc0740958'
args = {
'keyword': Arg(str, default=None)
}
result = None
sorted_list = None
data = parser.parse(args, request)
if data['keyword']:
api = 'http://api.keywordtool.io/v1/search/google?apikey=%s&country=in&language=en&metrics=true&keyword=%s' % (apikey, data['keyword'])
r = requests.post(api)
result = json.loads(r.text)['results']
sorted_list = sorted(result)
return render_template('keyword_data.html', data=result, sorted_list=sorted_list)
def get_dbs(
cls, admin=None, active=None, verified=None, permissions=None, **kwargs
):
args = parser.parse({
'admin': wf.Bool(missing=None),
'active': wf.Bool(missing=None),
'verified': wf.Bool(missing=None),
'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
})
return super(User, cls).get_dbs(
admin=admin or args['admin'],
active=active or args['active'],
verified=verified or args['verified'],
permissions=permissions or args['permissions'],
**kwargs
)
def create_question(course, year, period):
args = parser.parse(POST_PARAMS, request)
paper = model.Paper.find(db.session, course, year, period)
question = model.Question(paper, index=args["index"])
if "content" in args:
question.set_content(g.user, args["content"])
db.session.add(question)
db.session.commit()
db.session.refresh(question)
# Load the paper
getattr(question, "paper")
getattr(question, "comment_count")
getattr(question, "similar_count")
return respond({ "question": question })
def get(self, bucket_id, filename, **kwargs):
"""Get object.
.. http:get:: /files/(uuid:bucket_id)/(string:filename)
Sends file to the client.
**Request**:
.. sourcecode:: http
GET /files/4b60f39d-b960-442f-be68-b4b8b04c38a9/f.pdf HTTP/1.1
Accept: application/json
Connection: keep-alive
Content-Type: application/json
Host: localhost:5000
:reqheader Content-Type: application/json
:query uuid version_id: uuid of a specific version of a file.
**Response**:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Type: application/pdf
ETag: "flask-1449350517.0-15192-1285496294"
Downloading to "f.pdf"
:resheader Content-Type: application/json
:statuscode 200: no error
:statuscode 403: access denied
:statuscode 404: page not found
"""
args = parser.parse(self.get_args, request)
obj = Object.get(
bucket_id,
filename,
version_id=args.get('version_id', None))
if obj:
storage = StorageFactory.get(obj.location)
return storage.send_file(obj.filename)
abort(404, 'This object file does not exist or has been deleted.')
def add_new_content_result():
args = {
'url': Arg(str, required=True),
'short_description': Arg(str, default=None),
'content_header': Arg(str, default=None),
'content': Arg(str, required=True)
}
data = parser.parse(args, request)
r = requests.post(api_base_url + '/seo/content/add_content', data)
message = "Error while adding content for " + data['url'] + ". Review the content and other parameters once, contact admin if that doesn't help!"
message_color = "red"
if json.loads(r.text)['result'] and json.loads(r.text)['result'] == 'Success':
message = "Content for " + data['url'] + " has been added successfully!"
message_color = "green"
return render_template('result.html', message=message, message_color=message_color)
def post(self):
args = parser.parse({
'username': wf.Str(missing=None),
'email': wf.Str(missing=None),
'password': wf.Str(missing=None),
})
handler = args['username'] or args['email']
password = args['password']
if not handler or not password:
return flask.abort(400)
user_db = model.User.get_by(
'email' if '@' in handler else 'username', handler.lower()
)
if user_db and user_db.password_hash == util.password_hash(user_db, password):
auth.signin_user_db(user_db)
return helpers.make_response(user_db, model.User.FIELDS)
return flask.abort(401)
def post(self):
args = parser.parse(reading_args)
# if reading_search(args['device_id'], args['timestamp']):
# return conflict("Record already exists for device {d} at time {t}".format(d=args['device_id'],
# t=args['timestamp'])), 409
log_id = uuid.uuid4()
humidity = args['humidity'] if 'humidity' in args else 0.0
reading = Readings(log_id=log_id,
temperature=args['temperature'],
humidity=humidity,
device_id=args['device_id'],
timestamp=args['timestamp']
)
# result_json = reading_schema.dump(reading).data
save_reading(reading)
# collection = create_collection('1.0', request.url, result)
return "Location: " + reading.url, 200
def user_list():
args = parser.parse({
'email': wf.Str(missing=None),
'permissions': wf.DelimitedList(wf.Str(), delimiter=',', missing=[]),
})
user_dbs, cursors = model.User.get_dbs(
email=args['email'], prev_cursor=True,
)
permissions = list(UserUpdateForm._permission_choices)
permissions += args['permissions']
return flask.render_template(
'user/user_list.html',
html_class='user-list',
title='User List',
user_dbs=user_dbs,
next_url=util.generate_next_url(cursors['next']),
prev_url=util.generate_next_url(cursors['prev']),
api_url=flask.url_for('api.admin.user.list'),
permissions=sorted(set(permissions)),
)
def wrapped(*args, **kwargs):
req_args = webargs_parser.parse({
'existing_submission_id': webargs_fields.Int(missing=None),
'cgac_code': webargs_fields.String(missing=None),
'frec_code': webargs_fields.String(missing=None)
})
# Ensure there is either an existing_submission_id, a cgac_code, or a frec_code
if req_args['existing_submission_id'] is None and req_args['cgac_code'] is None and \
req_args['frec_code'] is None:
raise ResponseException('Missing required parameter: cgac_code, frec_code, or existing_submission_id',
StatusCode.CLIENT_ERROR)
# Use codes based on existing Submission if existing_submission_id is provided, otherwise use CGAC or FREC
if req_args['existing_submission_id'] is not None:
check_existing_submission_perms(perm, req_args['existing_submission_id'])
else:
# Check permissions for the agency
if not current_user_can(perm, cgac_code=req_args['cgac_code'], frec_code=req_args['frec_code']):
raise ResponseException("User does not have permissions to write to that agency",
StatusCode.PERMISSION_DENIED)
return fn(*args, **kwargs)
def book_create():
if request.method == "GET":
return render_template("book/create.html")
validator = Book.get_input_validator()
try:
args = parser.parse(validator, request)
except Exception as e:
return render_template("book/create.html", error=str(e.data["exc"].arg_name))
book = Book()
book.author = args["author"]
book.name = args["name"]
book.year = args["year"]
# file
file = request.files["file"]
extension = file.filename.split(".")[-1] or ""
book.file = book.id + "." + extension
file.save(os.path.join(app.config["UPLOAD_FOLDER"], book.file))
#
book.added_by_login = current_user.login
book.save()
return redirect(url_for("main"))
def google_suggest_api():
google_suggest_domain = [
'http://google.com/complete/search',
'http://suggestqueries.google.com/complete/search',
'http://clients1.google.com/complete/search'
]
args = {
'keyword': Arg(str, default=None)
}
result = None
data = parser.parse(args, request)
keyword = data['keyword']
if keyword:
domain_picked = random.choice(google_suggest_domain)
api = '%s?client=firefox&q=%s&hl=en&gl=in' % (domain_picked, keyword)
r = requests.get(api)
result = json.loads(r.text)[1]
return render_template('google_suggest.html', keyword=keyword, data=result)
def edit_comment(entity, comment):
with query(model.Entity):
entity = db.session.query(model.Entity).filter(model.Entity.id == entity).one()
comment = db.session.query(model.Comment).filter(model.Comment.id == comment).one()
# Ensure the user is the author
if not g.user.id == comment.user.id:
raise Unauthorized()
if request.method == "DELETE":
comment.content = ""
comment.deleted = True
elif request.method == "PUT":
args = parser.parse({ "content": fields.Str(required=True) })
comment.content = args["content"]
# Fix up the cache
if entity.type == "question":
db.session.refresh(entity)
question = entity
paper = entity.paper
course = paper.course
invalidate_view("question.do_question", course=course.code, year=paper.year_start, period=paper.period, question=".".join(map(str, question.path)))
# Invalidate the comment cache for specific entity
invalidate_view("comment.get_comments", entity=entity.id)
db.session.add(comment)
db.session.commit()
db.session.refresh(comment)
getattr(comment, "children")
return respond({
"entity": entity,
"comment": comment
})
def multipart_uploadpart(self, multipart, content_md5=None,
content_length=None):
"""Upload a part."""
if content_length != multipart.chunk_size:
raise MultipartInvalidChunkSize()
# Extract part number from request.
data = None
for schema in current_files_rest.uploadparts_schema_factory:
try:
data = parser.parse(schema)
if data:
break
except UnprocessableEntity:
pass
if not data or data.get('part_number') is None:
raise MultipartInvalidPartNumber()
part_number = data['part_number']
# Create part
try:
p = Part.get_or_create(multipart, part_number)
p.set_contents(request.stream)
db.session.commit()
except Exception:
# We remove the Part since incomplete data may have been written to
# disk (e.g. client closed connection etc.)
db.session.rollback()
Part.delete(multipart, part_number)
raise
return self.make_response(
data=p,
context={
'class': Part,
},
etag=p.checksum
)
