async def game_play():
"""
"""
params = await request.get_json()
logger.debug("Received input /game/play: %s" % (params))
game_id = params.get('game_id')
guess = params.get('guess')
code = await get_game_code(game_id)
logger.debug("Code for %s: %s" % (game_id, code))
if code is None:
return make_json_response(code=1, msg='game_id not valid')
if not validate_guess(code, guess):
return make_json_response(code=1, msg='guess not valid')
try:
result = await play_guess(code, guess)
logger.debug("Game: %s, Guess: %s, Result: %s" %
(game_id, guess, result))
except Exception as e:
logging.error(traceback.format_exc())
return make_json_response(code=1, msg='guess not valid')
await insert_game_guess(game_id, guess, result)
return make_json_response(code=0, body=result)
def trigger_agent_start(camera_id):
camera, error = _get_camera_by_id(camera_id)
if error:
utils.make_json_response(**error)
notifier = CameraNotifier(camera.id, camera.streaming_url)
notifier.notify_agent_start()
return utils.make_json_response(200,
{'status': 'Agent start message sent.'})
def delete_action(action_id):
action, error = _get_action_by_id(action_id)
if error:
return utils.make_json_response(**error)
action_name = action.name
action.delete()
return utils.make_json_response(200, {
"name": action_name,
"status": "deleted"
})
def unregister_device(device_id):
device, error = _get_device_by_id(device_id)
if error:
return utils.make_json_response(**error)
device_name = device.name
device.delete()
return utils.make_json_response(
200,
{"name": device_name, "status": "deleted"}
)
def unregister_camera(camera_id):
camera, error = _get_camera_by_id(camera_id)
if error:
return utils.make_json_response(**error)
camera_name = camera.name
camera.delete()
return utils.make_json_response(200, {
"name": camera_name,
"status": "deleted"
})
def delete_algorithm(algorithm_id):
algorithm, error = _get_algorithm_by_id(algorithm_id)
if error:
return utils.make_json_response(**error)
algorithm_name = algorithm.name
algorithm.delete()
return utils.make_json_response(200, {
"name": algorithm_name,
"status": "deleted"
})
async def game_new():
"""
"""
game_id = get_sha()
code = get_random_code()
logger.debug("New game /game/new: %s || %s" % (game_id, code))
valid_game = await create_game(game_id, code)
if not valid_game:
return make_json_response(code=1, msg='Something went wrong')
else:
return make_json_response(code=0, body={'game_id': game_id})
def run_function():
data = utils.get_request_data()
device = _select_device()
if not device:
return utils.make_json_response(
400,
"Bad Request: No device available."
)
code, status = _send_function_trigger(device.name, data)
if code == 200:
device.last_triggered = datetime.now()
device.save()
return utils.make_json_response(code, status)
def visited_domains():
try:
frm, to = get_visited_domains_params(request.args, ("from", "to"))
except Exception as e:
return make_json_response(error=e, code=HTTPStatus.BAD_REQUEST)
try:
data = redis_connector.get_by_range(frm, to)
except Exception as e:
return make_json_response(status=ERROR_INTERNAL, code=HTTPStatus.INTERNAL_SERVER_ERROR)
links = Links(data)
return make_json_response(key=DOMAINS_KEY, data=links.get_domains())
def create_algorithm():
data = utils.get_request_data()
if not (set(data.keys()) <= set(CREATE_ALGORITHM_FIELDS)):
return utils.make_json_response(
400, "Invalid parameter keys: %s" %
str(set(data.keys()) - set(CREATE_ALGORITHM_FIELDS)))
algorithm = models.Algorithm()
for k, v in data.items():
setattr(algorithm, k, v)
try:
algorithm.save()
except mongoengine.errors.NotUniqueError as e:
return utils.make_json_response(409, e.__str__())
return utils.make_json_response(200, algorithm.to_dict())
def update_action(action_id):
data = utils.get_request_data()
if not (set(data.keys()) <= set(UPDATE_ACTION_FIELDS)):
return utils.make_json_response(
400, "Invalid parameter keys: %s" %
str(set(data.keys()) - set(UPDATE_ACTION_FIELDS)))
action, error = _get_action_by_id(action_id)
if error:
return utils.make_json_response(**error)
for k, v in data.items():
setattr(action, k, v)
action.save()
return utils.make_json_response(200, action.to_dict())
def update_algorithm(algorithm_id):
data = utils.get_request_data()
if not (set(data.keys()) <= set(UPDATE_ALGORITHM_FIELDS)):
return utils.make_json_response(
400, "Invalid parameter keys: %s" %
str(set(data.keys()) - set(UPDATE_ALGORITHM_FIELDS)))
algorithm, error = _get_algorithm_by_id(algorithm_id)
if error:
return utils.make_json_response(**error)
for k, v in data.items():
setattr(algorithm, k, v)
algorithm.save()
return utils.make_json_response(200, algorithm.to_dict())
def task_submit(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
post = request.POST
smile = post.get('smile')
draw_mol_data = post.get('draw_mol_data')
files_id_list = json.loads(post.get('files_id_list', "[]"))
models = json.loads(post.get('models', "[]"))
task_notes = post.get('task_notes')
task_name = post.get('task_name')
local_search_id = int(post.get('local_search_id', 0))
try:
status, info, id = submit_calculate_task(
request.user,
smile=smile,
draw_mol_data=draw_mol_data,
files_id_list=files_id_list,
models=models,
task_notes=task_notes,
task_name=task_name,
local_search_id=local_search_id)
except Exception as err:
status, info, id = False, str(err), None
return make_json_response(dict(status=status, info=info, id=id))
def register_camera():
data = utils.get_request_data()
camera = models.Camera()
camera.name = data['name']
actions, errors = _validate_camera_actions(data['actions'])
if not errors:
camera.action_dict = actions
else:
return utils.make_json_response(400, errors)
camera.streaming_url = RTMP_SERVER + '/' + data['name']
camera.last_updated = datetime.datetime.now()
camera.save()
notifier = CameraNotifier(camera.id, camera.streaming_url)
notifier.notify_agent_start()
return utils.make_json_response(200, camera.to_dict())
def task_submit(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
post = request.POST
smile = post.get('smile')
draw_mol_data = post.get('draw_mol_data')
files_id_list = json.loads(post.get('files_id_list', "[]"))
models = json.loads(post.get('models', "[]"))
task_notes = post.get('task_notes')
task_name = post.get('task_name')
local_search_id = int(post.get('local_search_id', 0))
try:
status, info, id = submit_calculate_task(
request.user,
smile=smile,
draw_mol_data=draw_mol_data,
files_id_list=files_id_list,
models=models,
task_notes=task_notes,
task_name=task_name,
local_search_id=local_search_id)
except Exception as err:
status, info, id = False, str(err), None
return make_json_response(dict(status=status,
info=info,
id=id))
def create_task():
data = utils.get_request_data()
task = models.Task()
task.title = data['title']
task.content = data['content']
task.manager = models.User.objects.get(username=data['manager'])
for assign in data['assignee']:
task.assignee.append(models.User.objects.get(username=assign))
task.status = data['status']
task.tags = data['tags']
task.due_time = datetime.datetime.strptime(data['due_time'],
'%b %d %Y %I:%M%p')
task.pub_time = datetime.datetime.now()
task.update_time = datetime.datetime.now()
if task.pub_time < task.due_time:
task.save()
return utils.make_json_response(200, task.to_dict())
else:
raise exception_handler.BadRequest(
'due time %s is earlier than pub time %s' %
(data['due_time'], datetime.datetime.now()))
def get_user(username):
try:
user = models.User.objects.get(username=username)
except models.User.DoesNotExist:
raise exception_handler.BadRequest("user %s not exist" % username)
return utils.make_json_response(200, user.to_dict())
def visited_links():
try:
json = request.json
except Exception as e:
return make_json_response(error=e, code=HTTPStatus.BAD_REQUEST)
try:
links = Links.from_json(json)
except Exception as e:
return make_json_response(error=e, code=HTTPStatus.BAD_REQUEST)
try:
redis_connector.add(links.links, now_timestamp())
except Exception as e:
return make_json_response(error=ERROR_INTERNAL, code=HTTPStatus.INTERNAL_SERVER_ERROR)
return make_json_response()
def trigger_listener(queue_id):
subprocess.Popen([
'ansible-playbook', 'run.yml', '--extra-vars',
'"queue_id=%s"' % queue_id
],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
return utils.make_json_response(200, "Daemon Started.")
def register_device():
data = utils.get_request_data()
device = models.Device()
try:
device.name = data['name']
except KeyError:
return utils.make_json_response(
400,
"Error registering device: device name not found."
)
device.last_updated = datetime.now()
try:
device.save()
except mongoengine.errors.NotUniqueError as e:
return utils.make_json_response(409, str(e))
return utils.make_json_response(200, device.to_dict())
def create_action():
data = utils.get_request_data()
if not (set(data.keys()) <= set(CREATE_ACTION_FIELDS)):
return utils.make_json_response(
400, "Invalid parameter keys: %s" %
str(set(data.keys()) - set(CREATE_ACTION_FIELDS)))
errors = _validate_action_params(data['params'])
if errors:
return utils.make_json_response(400, errors)
action = models.Action()
for k, v in data.items():
setattr(action, k, v)
try:
action.save()
except mongoengine.errors.NotUniqueError as e:
return utils.make_json_response(409, e.__str__())
return utils.make_json_response(200, action.to_dict())
def cancel_appt_by_time():
data = utils.get_request_data()
try:
date = data['date']
start_time = data['start_time']
except KeyError:
return utils.make_json_response(
400, "Sorry I cannot cancel your appointment "
"without a date and a start time.")
appt_time = datetime.strptime(date + ' ' + start_time, '%b %d %Y %I:%M%p')
appt, error = _get_appt_by_appt_time(appt_time)
if error:
return utils.make_json_response(
404, "I am not able to find your appointment on %s, at %s" %
(date, start_time))
appt.delete()
return utils.make_json_response(
200, "Your appointment has been successfully canceled.")
def logout():
user = models.User.objects.get(username=current_user.username)
logout_user()
for key in ('identity.name', 'identity.auth_type'):
session.pop(key, None)
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
return utils.make_json_response(200, user.to_dict())
async def game_history():
"""
"""
params = await request.get_json()
logger.debug("Received input /game/history: %s" % (params))
game_id = params.get('game_id')
history = await get_game_history(game_id)
return make_json_response(code=0, body=history)
def list_tasks(status):
if status == "all":
tasks = models.Task.objects.order_by('-due_time')
else:
tasks = models.Task.objects.filter(status=status)
tasks_dict = {}
for task in tasks:
tasks_dict.update({task.title: task.to_dict()})
return utils.make_json_response(200, tasks_dict)
def history(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
start = int(request.POST.get('start', 0))
limit = int(request.POST.get('limit', 30))
# Django queryset is lazy, like iterator
results = SuiteTask.objects.filter(user__user=request.user)\
.order_by('-start_time')[start:(start + limit)]
data = dict(suitetask_lists=[r.sid for r in results])
return make_json_response(data)
def trigger_camera_algorithm(camera_id):
camera, error = _get_camera_by_id(camera_id)
if error:
return utils.make_json_response(**error)
algorithm_status = camera.algorithm_status
action_dict = camera.action_dict
if action_dict == {}:
return utils.make_json_response(200,
{'status': 'No algorithm specified.'})
available_action_dict = {
k: v
for k, v in action_dict.items() if algorithm_status[k] == 'idle'
}
algorithm_invoker = AlgorithmInvoker(camera_id)
algorithm_invoker.invoke_current_algorithms(available_action_dict,
camera.streaming_url)
for algorithm_name in available_action_dict.keys():
algorithm_status[algorithm_name] = 'running'
camera.algorithm_status = algorithm_status
camera.save()
return utils.make_json_response(200, {'status': 'triggered'})
def api_login(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
if request.user.username:
info = "login succeed"
status = True
else:
info = "login failed"
status = False
return make_json_response(dict(info=info, status=status))
def api_login(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
if request.user.username:
info = "login succeed"
status = True
else:
info = "login failed"
status = False
return make_json_response(dict(info=info, status=status))
def history(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
start = int(request.POST.get('start', 0))
limit = int(request.POST.get('limit', 30))
# Django queryset is lazy, like iterator
results = SuiteTask.objects.filter(user__user=request.user)\
.order_by('-start_time')[start:(start + limit)]
data = dict(suitetask_lists=[r.sid for r in results])
return make_json_response(data)
def handle_exception(error):
if hasattr(error, 'to_dict'):
response = error.to_dict()
else:
response = {'message': str(error)}
if app.debug and hasattr(error, 'traceback'):
response['traceback'] = error.traceback
status_code = 400
if hasattr(error, 'status_code'):
status_code = error.status_code
return utils.make_json_response(status_code, response)
def get_user_tasks(username, status):
if status == "all":
tasks = models.Task.objects.order_by('-due_time')
else:
tasks = models.Task.objects.filter(status=status).order_by('-due_time')
user_task_dict = {}
for task in tasks:
if username in [user.username for user in task.assignee
] or username == task.manager.username:
user_task_dict.update({task.title: task.to_dict()})
return utils.make_json_response(200, user_task_dict)
def register():
data = utils.get_request_data()
if (models.User.objects.filter(username=data["username"]).count() > 0
or models.User.objects.filter(email=data["email"]).count() > 0):
raise exception_handler.BadRequest("user already exist")
user = models.User()
user.username = data['username']
user.email = data['email']
user.password = data['password']
user.save()
return utils.make_json_response(200, user.to_dict())
def smile_search(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
query = dict(cas=request.POST.get('cas'),
smile=request.POST.get('smile'),
common_name_ch=request.POST.get('common_name_ch'),
common_name_en=request.POST.get('common_name_en'))
# TODO: 开启分页
start = int(request.POST.get('start', 0))
limit = int(request.POST.get('limit', 10))
# TODO: 目前只是使用本地搜索，未来重新开启第三方search API
#results_chemspider = search_cheminfo(query, start, limit)
results = search_cheminfo_local(query, start, limit)
return make_json_response(results)
def singletask(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
id = request.POST.get('id')
details = singletask_details(id).get("singletask")
ret = dict(start_time=str(details.start_time),
end_time=str(details.end_time),
sid=str(details.sid),
temperature=details.temperature,
humidity=details.humidity,
model=str(details.model),
status=str(details.status),
results=details.results,
result_file=details.result_pdf.url if details.result_pdf else None,
src_file=details.file_obj.file_obj.url if details.file_obj else None)
return make_json_response(ret)
def suitetask(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
id = request.POST.get('id')
content = suitetask_details(id)
details = content.get('suitetask')
ret = dict(start_time=str(details.start_time),
end_time=str(details.end_time),
total_tasks=details.total_tasks,
has_finished_tasks=details.has_finished_tasks,
name=details.name,
notes=details.notes,
email=details.email,
status=str(details.status),
models=details.models_str,
models_category=details.models_category_str,
result=details.result_pdf.url if details.result_pdf else None,
singletask_lists=[t.pid for t in content.get('single_lists')])
return make_json_response(ret)
def mol_upload(request):
if not basic_auth_api(request):
return HttpResponseForbidden()
if request.method == "POST" and request.FILES:
try:
f = file_upload_save_process(request)
except Exception as err:
data = dict(status=False,
info=str(err),
uuid=None)
else:
data = dict(status=True,
info="upload file succeed",
uuid=f.fid,
name=f.title)
else:
data = dict(status=False,
uuid=None,
info='post file field is required')
return make_json_response(data)
