def put(self):
# 获取者的
self.parser.add_argument('given', required=True)
# 分享者的
self.parser.add_argument('give', required=True)
self.parser.add_argument('count', required=True)
self.parser.add_argument('left_flow', required=True) # 更新分享者所剩下的流量
args = self.parser.parse_args()
if add_shared(args['give'], args['given'], args['count']):
return output_json({}, 201)
else:
return output_json({"ERROR": "FALIED TO ADD"}, 401)
def put(self):
# 获取者的
self.parser.add_argument('given', required=True)
# 分享者的
self.parser.add_argument('give', required=True)
self.parser.add_argument('count', required=True)
self.parser.add_argument('left_flow', required=True) # 更新分享者所剩下的流量
args = self.parser.parse_args()
if add_shared(args['give'], args['given'], args['count']):
return output_json({}, 201)
else:
return output_json({"ERROR": "FALIED TO ADD"}, 401)
def delete(self, job_id):
if self.redis.exists(job_id):
self.redis.delete(job_id)
return output_json(
{
'status': 'ok',
'description': 'Job is deleted.'
}, 200)
else:
return output_json(
{
'status': 'error',
'description': 'The job is not in the queue.'
}, 400)
def get(self, username=""):
if username == "":
users = get_all_users()
if len(users) == 0:
return output_json({"ERROR": "No user"}, 200)
usernames = list(map(lambda x: x.username, users))
return output_json({"users": usernames}, 200)
user = get_user_by_name(username)
if user:
password = user.password
if 'password' not in request.args or request.args['password'] != password:
return output_json({"ERROR": "forbidden"}, 401)
else:
return output_json(user.to_simple_dict(), 200)
else:
abort(404, ERROR='no such user ' + username)
def get_all_shopping_list():
"""
Restful endpoint to get all shopping lists with items
:return: data
"""
data = shopping_service.get_all_shopping_list()
return output_json(data, 200)
def post(self):
json_data = request.get_json(force=True)
data = utils.val_request(model=Components, json_data=json_data,
att={'component_id': json_data['component_id']})
if data[1] == 200:
utils.write_to_db(Components, json_data)
return output_json(data[0], data[1], d_type_header)
def get_shopping_list_by_item_id(item_id):
"""
Restful endpoint to get all shopping lists containing given item
:param item_id:
:return: data
"""
data = shopping_service.get_shopping_list_by_item_id(item_id)
return output_json(data, 200)
def post(self):
json_data = request.get_json(force=True)
data = utils.val_request(model=Categories, json_data=json_data,
att={'data_category_id': json_data['data_category_id']})
if data[1] == 200:
utils.write_to_db(Categories, json_data)
return output_json(data[0], data[1], d_type_header)
def get(self, city):
r = requests.get(
"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={appid}"
.format(city=city, appid=self.api_key))
if r.status_code == 200:
return output_json(r.json(), r.status_code)
else:
return {}, r.status_code
def post(self):
json_data = request.get_json(force=True)
data = utils.val_request(model=PartNumbers, json_data=json_data,
att={'part_number_id': json_data['part_number_id']})
if data[1] == 200:
utils.write_to_db(PartNumbers, json_data)
return output_json(data[0], data[1], d_type_header)
def search_shopping_list_by_item_name_keyword(title):
"""
Restful endpoint to get all shopping lists having item which contains given keyword in tile
:param title:
:return: data
"""
data = shopping_service.search_shopping_list_by_item_name_keyword(title)
return output_json(data, 200)
def get_shopping_list_by_title(title):
"""
Restful endpoint to get all shopping lists based on title
:param title:
:return: data
"""
data = shopping_service.get_shopping_list_by_title(title)
return output_json(data, 200)
def get(self, username=""):
if username == "":
users = get_all_users()
if len(users) == 0:
return output_json({"ERROR": "No user"}, 200)
usernames = list(map(lambda x: x.username, users))
return output_json({"users": usernames}, 200)
user = get_user_by_name(username)
if user:
password = user.password
if 'password' not in request.args or request.args[
'password'] != password:
return output_json({"ERROR": "forbidden"}, 401)
else:
return output_json(user.to_simple_dict(), 200)
else:
abort(404, ERROR='no such user ' + username)
def put(self):
self.parser.add_argument("user", required=True)
self.parser.add_argument("password", required=True)
self.parser.add_argument("max_share", required=True)
self.parser.add_argument("max_left", required=True)
self.parser.add_argument("start", required=True)
self.parser.add_argument("end", required=True)
self.parser.add_argument("mac", required=True)
args = self.parser.parse_args()
user = User(args['user'], args['password'], args['start'], args['end'],
args['max_share'], args['max_left'], args['mac'])
ret_vals = add_user(user)
if ret_vals[0]:
print_all_users(get_all_users())
return output_json({"message": "okay"}, 201)
else:
print(ret_vals[1])
return output_json({"ERROR": "failed"}, 409)
def json(data, code, headers):
"""
Flask will output an error message in json format by default.
To prevent that we leak important information remove all messages from non 200 responses
"""
if code == 200:
return output_json(data, code, headers)
else:
return make_response('', code, headers)
def put(self):
self.parser.add_argument("user", required=True)
self.parser.add_argument("password", required=True)
self.parser.add_argument("max_share", required=True)
self.parser.add_argument("max_left", required=True)
self.parser.add_argument("start", required=True)
self.parser.add_argument("end", required=True)
self.parser.add_argument("mac", required=True)
args = self.parser.parse_args()
user = User(args['user'], args['password'], args['start'], args['end'], args['max_share'],
args['max_left'], args['mac'])
ret_vals = add_user(user)
if ret_vals[0]:
print_all_users(get_all_users())
return output_json({"message": "okay"}, 201)
else:
print(ret_vals[1])
return output_json({"ERROR": "failed"}, 409)
def get(self):
qry = Categories.query.all()
data = CATEGORIES_SCHEMA.dump(qry)
status = utils.check_status(data)
return output_json(data, status, d_type_header)
def get(self):
qry = PartNumbers.query.all()
data = PARTNUMBERS_SCHEMA.dump(qry)
status = utils.check_status(data)
return output_json(data, status, d_type_header)
def handle_http_exception(error):
error.data['status'] = 400
return output_json(error.data, 400)
def get(self):
return output_json({'msg': 'Hello World!'},200, d_type_header)
def post(self, args):
extra_data = {k: v for k, v in request.json.items() if k not in args}
enrollment = enroll(**args, sender=current_user, extra_data=extra_data)
return output_json(flask_restful.marshal(enrollment, self.enrollment_fields), 201)
def get(self):
qry = Locations.query.all()
data = LOCATIONS_SCHEMA.dump(qry)
status = utils.check_status(data)
return output_json(data, status, d_type_header)
def get(self, **kwargs):
if kwargs.get('job_id'):
job_id = kwargs.get('job_id')
if self.redis.exists(job_id):
parser = reqparse.RequestParser()
if request.url_rule.rule == '/jobs/<string:job_id>/next':
parser.add_argument('expired_duration',
type=int,
default=300)
args = parser.parse_args(strict=True)
if self.redis.jsonget(job_id, Path('.items')):
ttl = args.get('expired_duration')
items = self.redis.jsonget(job_id, Path('.items'))
for item in items:
if not self.redis.exists(f'hold_{item}'):
self.redis.execute_command(
'SET', f'hold_{item}', job_id)
self.redis.execute_command(
'EXPIRE', f'hold_{item}', ttl)
return output_json(
{
'status': 'ok',
'job_id': job_id,
'ttl': ttl,
'index': items.index(item),
'item': item
}, 200)
return output_json(
{
'status': 'error',
'job_id': job_id,
'description': 'Items list is empty.'
}, 400)
if request.url_rule.rule == '/jobs/<string:job_id>/items':
parser.add_argument('active',
default='true',
choices=('true', 'false'))
args = parser.parse_args(strict=True)
items = self.redis.jsonget(job_id, Path('.items'))
done_items = self.redis.jsonget(job_id, Path('.done'))
if args.get('active') == 'true':
active_items = []
for item in items:
if not self.redis.exists(f'hold_{item}') and \
items.index(item) not in done_items:
active_items.append(item)
return output_json(
{
'status': 'ok',
'job_id': job_id,
'items': active_items
}, 200)
return output_json(
{
'status': 'ok',
'job_id': job_id,
'items': items + done_items
}, 200)
else:
return output_json(
{
'status': 'error',
'job_id': job_id,
'description': 'The job is not in the queue.'
}, 400)
return output_json(
{
'status': 'ok',
'jobs': [i for i in self.redis.keys() if i[:5] != 'hold_']
}, 200)
def get(self):
qry = RuleMeta.query.all()
data = RULESMETA_SCHEMA.dump(qry)
status = utils.check_status(data)
return output_json(data, status, d_type_header)
def get(self):
return output_json({"ping": "pong"}, 200)
def get(self):
response = {
'data':
'this is a sample response from the "/api" endpoint in flask Container'
}
return output_json(response, 200, headers)
def get(self):
qry = Components.query.find(par)
data = COMPONENTS_SCHEMA.dump(qry)
status = utils.check_status(data)
return output_json(data, status, d_type_header)
def post(self, **kwargs):
if request.url_rule.rule == '/jobs/<string:job_id>/items/<int:item_index>/done':
job_id = kwargs.get('job_id')
item_index = kwargs.get('item_index')
done_item = self.redis.jsonget(job_id, Path('.items'))[item_index]
if item_index in self.redis.jsonget(job_id, Path('.done')):
return output_json(
{
'status': 'error',
'description': 'The item already was marked as done.',
'job_id': job_id,
'index': item_index,
'item': done_item
}, 400)
self.redis.delete(f'hold_{done_item}')
self.redis.jsonarrappend(job_id, Path('.done'), item_index)
return output_json(
{
'status': 'ok',
'description': 'The item is marked as done.',
'job_id': job_id,
'index': item_index,
'item': done_item
}, 200)
if request.url_rule.rule == '/jobs/<string:job_id>/items/<int:item_index>/error':
job_id = kwargs.get('job_id')
item_index = kwargs.get('item_index')
error_item = self.redis.jsonget(job_id, Path('.items'))[item_index]
if item_index in self.redis.jsonget(job_id, Path('.error')):
return output_json(
{
'status': 'error',
'description': 'The item already was marked as error.',
'job_id': job_id,
'index': item_index,
'item': error_item
}, 400)
self.redis.delete(f'hold_{error_item}')
self.redis.jsonarrappend(job_id, Path('.error'), item_index)
return output_json(
{
'status': 'ok',
'description': 'The item is marked as error.',
'job_id': job_id,
'index': item_index,
'item': error_item
}, 200)
if isinstance(request.json, list) and request.json:
job_id = str(uuid.uuid4())
data = {'items': request.json, 'done': [], 'error': []}
if self.redis.jsonset(job_id, Path.rootPath(), data):
return output_json(
{
'status': 'ok',
'description': 'Job is added to queue.',
'job_id': job_id
}, 201)
else:
return output_json(
{
'status': 'error',
'description': 'Wrong request!'
}, 400)
def json_response(payload, code):
headers = {'Content-type': 'application/json'}
return output_json(payload, code, headers)
def _pydantic_safe_output_json(data: Union[BaseModel, dict, list], code, headers=None):
if isinstance(data, BaseModel):
data = data.dict()
return output_json(data, code, headers)
