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 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 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)