async def get(self, request: Request): bots = await dbManger.execute(RobotModel.select()) bots = [bot.to_dict() for bot in bots] return Response(data=bots, status=200, message="ok")
def info_save(): args = request.json return Response.success(DailyInfoService.save(args))
def error_handler(exception: Exception): if exception: log.error(traceback.format_exc()) return Response.failed(msg=f'{exception}')
def get_log_content(): log_path = request.args.get('log_path') assert id is not None return Response.success(data=BuildService.get_log_content(log_path))
def get(self, request, *args, **kwargs): response = self.list(request, *args, **kwargs) return Response(data=response.data, status=200)
def change_password(): """Change the current password --- put: tags: - auth requestBody: content: application/json: schema: type: object properties: user_id: type: integer required: true current_password: type: string required: true new_password: type: string required: true confirm_password: type: string required: true responses: 200: content: application/json: schema: type: object properties: status: type: int example: 200 success: type: dict example: {message: password changes successfully} error: type: dict example: {message: error occurred} 400: description: bad request """ app.logger.info("change password") if not request.is_json: response_body = {"message": "Missing JSON in request"} return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST _mandatory_fields = [ "user_id", "current_password", "new_password", "confirm_password", ] req_data = request.json try: validation_data_check(_mandatory_fields, req_data) user_id, current_password, new_password, confirm_password = fetch_change_pass_req_body( req_data=request.json) user = User.query.filter_by(id=user_id).first() app.logger.info( f"password mismatch {pwd_context.verify(current_password, user.password)}" ) if user is None or not pwd_context.verify(current_password, user.password): response_body = {"message": "unauthorized"} return Response(401).wrap(response_body), HTTPStatus.UNAUTHORIZED check_new_password_confirm_password(new_password, confirm_password) app.logger.info(get_jwt_identity()) update_data = { "password": pwd_context.hash(new_password) # "updated_by": get_jwt_identity().get("username"), # "updated_on": datetime.datetime.now().isoformat(), } obj = UserSchema().load(update_data, instance=user, partial=True) db.session.add(obj) db.session.commit() response_body = {"message": "password changed successfully"} return Response(200).wrap(response_body), HTTPStatus.OK except ValueError as e: response_body = {"message": e.args[0]} return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST except SQLAlchemyError as e: app.logger.error(f"error occured while returned {str(e)}") response_body = {"message": f"{str(e)}"} return ( Response(500).wrap(response_body), HTTPStatus.INTERNAL_SERVER_ERROR, )
def say(client, message, clients, header): user = UsersTool.current_user(client) user['message'] = message Response(header=header, data=user).response(clients=clients)
def china_detail(): date = request.args.get('date') return Response.success(SummaryService.china_detail(date))
def overseas(): date = request.args.get('date') return Response.success(SummaryService.overseas(date))
def like_article(): args = request.json article_id = args.get('article_id') user_name = g.user.name assert article_id is not None return Response.success(ArticleService.like_article(article_id, user_name))
def summary_china(): date = request.args.get('date') return Response.success(SummaryService.china_summary(date))
def article_detail(): id = request.args.get('id') assert id is not None return Response.success(ArticleService.article_detail(id, g.user.name))
def article_list(): is_published = request.args.get('is_published') == 'true' return Response.success( ArticleService.article_list(g.user.name, is_published))
async def post(self, request: Request): form_data = request.form return Response(data=None, status=200, message="ok")
def delete(): id = request.args.get('id') return Response.success(AlbumService.delete_album(id))
def history(): return Response.success(SummaryService.history())
def login(): """Authenticate user and return tokens --- post: tags: - auth requestBody: content: application/json: schema: type: object properties: username: type: string example: admin required: true password: type: string example: admin required: true responses: 200: content: application/json: schema: type: object properties: access_token: type: string example: myaccesstoken refresh_token: type: string example: myrefreshtoken 400: description: bad request security: [] """ if not request.is_json: response_body = {"message": "Missing JSON in request"} return ( Response(400).wrap(response_body=response_body), HTTPStatus.BAD_REQUEST, ) username = request.json.get("username", None) password = request.json.get("password", None) if not username or not password: response_body = {"message": "Missing username or password"} return ( Response(400).wrap(response_body=response_body), HTTPStatus.BAD_REQUEST, ) try: user = User.query.filter_by(username=username).first() if user is None: response_body = {"message": "User not found"} return ( Response(401).wrap(response_body=response_body), HTTPStatus.UNAUTHORIZED, ) except Exception as e: app.logger.error(str(e)) db.session.rollback() response_body = {"message": f"error occurred{str(e)}"} return ( Response(500).wrap(response_body=response_body), HTTPStatus.INTERNAL_SERVER_ERROR, ) if user is None or not pwd_context.verify(password, user.password): response_body = {"message": "Unauthorized"} return ( Response(401).wrap(response_body=response_body), HTTPStatus.UNAUTHORIZED, ) ret = create_response_body(user) response_body = {"data": ret} return Response(200).wrap(response_body=response_body), HTTPStatus.OK
def leave(self, data): room_id, p_id = data.get('room_id', None), data.get('p_id', None) room = RoomTool.leave_room(self.client, room_id, p_id) Response('room.leave', data={}).response(self.client) Response('room.info', data=room).response(clients=self.clients)
def reset_password(): """Change the current password --- put: tags: - auth requestBody: content: application/json: schema: type: object properties: username: type: string required: true password: type: string required: true responses: 200: content: application/json: schema: type: object properties: status: type: int example: 200 success: type: dict example: {message: password changes successfully} error: type: dict example: {message: error occurred} 400: description: bad request """ if not request.is_json: response_body = {"message": "Missing JSON in request"} return ( Response(400).wrap(response_body=response_body), HTTPStatus.BAD_REQUEST, ) # return jsonify({"msg": "Missing JSON in request"}), HTTPStatus.BAD_REQUEST _mandatory_fields = ["username", "password"] req_data = request.json try: validation_data_check(_mandatory_fields, req_data) authorized_user = validation_authority( get_jwt_identity().get("username")) if authorized_user == "authorized": username = req_data["username"] password = req_data["password"] current_time = datetime.datetime.now().isoformat() current_user = get_jwt_identity().get("username") user = User.query.filter_by(username=username).first() if user is None: response_body = {"message": "user is not present"} return ( Response(401).wrap(response_body), HTTPStatus.UNAUTHORIZED, ) update_data = { "password": pwd_context.hash(password), # "updated_by": current_user, # "updated_on": current_time, } obj = UserSchema().load(update_data, instance=user, partial=True) db.session.add(obj) db.session.commit() response_body = {"message": "password reset successfully"} return Response(200).wrap(response_body), HTTPStatus.OK elif authorized_user == "unauthorized": response_body = {"message": "unauthorized"} return ( Response(401).wrap(response_body=response_body), HTTPStatus.UNAUTHORIZED, ) else: response_body = {"message": authorized_user} return ( Response(500).wrap(response_body=response_body), HTTPStatus.INTERNAL_SERVER_ERROR, ) except ValueError as e: response_body = {"message": e.args[0]} return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST except SQLAlchemyError as e: app.logger.error(f"error occured while returned {str(e)}") response_body = {"message": f"{str(e)}"} return ( Response(500).wrap(response_body), HTTPStatus.INTERNAL_SERVER_ERROR, )
def login(self, data): data = UsersTool.login(client=self.client, data=data) Response('user.login', data=data).response(self.client)
def get_logs(): return Response.success(data=BuildService.get_logs(g.user.name))
def create_room(self, data=None): user_id = redis_obj.db.get(get_w_key(self.client)) room = RoomTool.init_room(user_id, self.client, BattleType.freestyle, GameType.offline) Response("room.create", room).response(self.client)
def recent_build(): return Response.success(data=BuildService.recent_build(g.user.name))
def get_album_list(): user_name = g.user.name is_public = request.args.get('is_public') == 'true' return Response.success(AlbumService.album_list(user_name, is_public))
def has_done(): return Response.success(DailyInfoService.has_done(g.user.name))
def get_img_list(): album_id = request.args.get('album_id') user_name = g.user.name return Response.success(AlbumService.img_list(user_name, album_id))
def daily_info_statistic(): start = request.args.get('start') end = request.args.get('end') return Response.success(DailyInfoService.query(start, end))
def public_album(): id = request.json.get('id') assert id is not None return Response.success(AlbumService.public_album(id))
def save(): id = request.json.get('id') name = request.json.get('name') user_name = g.user.name return Response.success(WorkspaceService.save(user_name, id, name))
def delete_tag(): id = request.args.get('id') assert id is not None return Response.success(TagService.delete(id))