def index(): sender = get_sender() balance = request.json.get('balance') if balance is None: return make_response( { 'error': 'exception.balanceNotFound', 'body': 'balance not found' }, ok=False) operator_gari = refer_gari(OPERATOR_ADDRESS) if operator_gari < DEFAULT_GARI * 10: put_gari(OPERATOR_ADDRESS, DEFAULT_GARI * 10) try: transfer_gari(OPERATOR_ADDRESS, sender, balance) except Exception as e: return make_response({ 'error': 'error.exception', 'body': str(e) }, ok=False) updated_balance = refer_gari(sender) return make_response({'balance': updated_balance}, ok=True)
def generate(): sender = get_sender() try: transfer_gari(sender, OPERATOR_ADDRESS, 100) except Exception as e: return make_response({ 'error': 'error.exception', 'body': str(e) }, ok=False) id = dao.incr_osushi_count() keccak_hash = sha3.keccak_256() keccak_hash.update(str(id).encode('utf-8')) dna = keccak_hash.hexdigest() osushi = dataclasses.asdict(Sushi(id, dna, sender)) dao.set_osushi(id, osushi) linked_list.set_prefix(f'sushi:{sender}') linked_list.push_head(osushi['id']) return make_response({'sushi': osushi}, ok=True)
def packet_process(): """ 处理丢垃圾事件。 { "userid":"用户ID", "type":"垃圾种类", "uuid":"垃圾桶id" } { "code":0, "ok":true/false, "process_id":2333 } """ user = db.session.query(User).filter(User.id == request.form["userid"]) if user.count() == 0: return make_response(-1, message="未知用户ID") if request.form.get("type", "_") not in {"dry", "wet", "recyclable", "harmful"}: return make_response(-1, message="未知垃圾种类") if request.form.get("uuid", "_") not in config.ALLOW_CLIENTS: return make_response(-1, message="未认证客户端") user = user.one() log = RubbishLog() log.rubbish_bin = config.ALLOW_CLIENTS[request.form["uuid"]] log.rubbish_type = request.form["type"] import datetime log.time = datetime.datetime.now() log.user_id = user.id db.session.add(log) db.session.commit() retid = log.id return make_response(0, process_id=retid)
def delete_network() -> Response: """ Delete a network by id """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) network_id = request.form.get("id") network = Network.get_by_id(network_id) if network_id: if session.owner != network.owner: return make_response({ "error": "permission denied" }) network.delete() else: return make_response({ "error": "id missing, or not existing" }) return make_response({ # TODO response needed? Or is missing response allowed? })
def get_network_info() -> Response: """ Returns data about the target network """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) network_id = request.form.get("id") response = dict if network_id: network_list = [Network.get_by_id(network_id)] else: network_list = Network.get_by_owner(session.owner) # TODO check if .all() returns list, else fix to list if not network_list: return make_response({ "error": "no networks found" }) for network in network_list: if session.owner == network.owner: response.update({network.id: network.as_private_simple_dict()}) else: response.update({network.id: network.as_public_simple_dict()}) return make_response(response)
def delete_device() -> Response: """ Delete device by id """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) device_id = request.form.get("id") device = Device.get_by_id(device_id) if device_id: if session.owner != device.owner: return make_response({ "error": "permission denied" }) device.delete() else: return make_response({ "error": "id missing, or not existing" }) return make_response({ # TODO response needed? Or is missing response allowed? })
def sell_cancel(id): sender = get_sender() osushi = dao.get_osushi(id) if not osushi: return make_response( { 'error': 'error.sushiNotFound', 'body': 'sushi not found' }, ok=False) if osushi['price'] is None: return make_response( { 'error': 'error.alreadyBought', 'body': 'already bought' }, ok=False) if osushi['owner'] != sender: return make_response( { 'error': 'error.canNotCancelSellingSushiNotYours', 'body': 'cannot cancel selling sushi is not yours' }, ok=False) osushi['price'] = None dao.set_osushi(id, osushi) linked_list.set_prefix(f'market') linked_list.erase(osushi['id']) return make_response({'sushi': osushi}, ok=True)
def register(): """ 登录 参数:{ "username":"******", "password":"******", "email":"邮箱" } 返回:{ "code":"是否调用成功", "message":"" } """ if session.get("userid") is not None: return make_response(-1, { "message": "用户已登录" }) query = db.session.query(User).filter(or_( User.email == request.form["email"], User.username == request.form["username"])) if query.count(): return make_response(-1, **{ "message": "用户已存在" }) # session["userid"] = query.one().id user = User(username=request.form["username"], email=request.form["email"], password=request.form["password"]) db.session.add(user) db.session.commit() session.permanment = True session["userid"] = user.id return make_response(0)
def get_device_info() -> Response: """ Return data about the target device """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) device_id = request.form.get("id") response = dict if device_id: device_list = [Device.get_by_id(device_id)] else: device_list = Device.get_by_owner(session.owner) # TODO check if .all() returns list, else fix to list if not device_list: return make_response({ "error": "no devices found" }) for device in device_list: if session.owner == device.owner: response.update({device.id: device.as_private_simple_dict()}) else: response.update({device.id: device.as_public_simple_dict()}) return make_response(response)
def logout(): """ 登出 参数: """ if session.get("userid") is None: return make_response(-1, message="你尚未登录!") session.pop("userid") return make_response(0)
def buy(id): sender = get_sender() osushi = dao.get_osushi(id) if not osushi: return make_response( { 'error': 'error.sushiNotFound', 'body': 'sushi not found' }, ok=False) if osushi['price'] is None: return make_response( { 'error': 'error.alreadyBoughtOrCanceled', 'body': 'already bought or canceled' }, ok=False) if osushi['owner'] == sender: return make_response( { 'error': 'error.canNotBuyOwnSushi', 'body': 'cannot buy your own sushi' }, ok=False) try: transfer_gari(sender, osushi['owner'], osushi['price']) except Exception as e: return make_response({ 'error': 'error.exception', 'body': str(e) }, ok=False) old_owner = osushi['owner'] osushi['owner'] = sender osushi['price'] = None dao.set_osushi(id, osushi) linked_list.set_prefix(f'market') linked_list.erase(osushi['id']) linked_list.set_prefix(f'sushi:{old_owner}') linked_list.erase(osushi['id']) linked_list.set_prefix(f'sushi:{sender}') linked_list.push_head(osushi['id']) return make_response({'sushi': osushi}, ok=True)
def post_call(): if not request.data: return INVALID_PARAM() req = json.loads(request.data) channel_id = req.get('channel_id', None) peer_uid = req.get('peer_uid', None) if not channel_id or not peer_uid: return INVALID_PARAM() uid = int(request.uid) now = int(time.time()) c = { "channel_id":channel_id, "caller":uid, "callee":peer_uid, "timestamp":now } p = "你的朋友请求与你通话" obj = { "voip":c, "push":p, "sound":"apns.caf" } content = json.dumps(obj) r = gobelieve.send_system_message(peer_uid, content) logging.debug("send system message:%s", r) return make_response(200, {"success":True})
def get_phone_number_users(rds): if not request.data: return INVALID_PARAM() req = json.loads(request.data) resp = [] contacts = [] for o in req: uid = user.make_uid(o["zone"], o["number"]) u = user.get_user(rds, uid) obj = {} obj["zone"] = o["zone"] obj["number"] = o["number"] if u is None: obj["uid"] = 0 else: contact = user.Contact() contact.name = o["name"] if o.has_key("name") else "" contact.uid = uid contacts.append(contact) obj["uid"] = uid if u.state: obj["state"] = u.state if u.avatar: obj["avatar"] = u.avatar if u.up_timestamp: obj["up_timestamp"] = u.up_timestamp resp.append(obj) user.set_user_contact_list(rds, request.uid, contacts) return make_response(200, resp)
def refresh_token(): rds = g.rds if not request.data: return INVALID_PARAM() obj = json.loads(request.data) refresh_token = obj["refresh_token"] uid = Token.load_refresh_token(rds, refresh_token) if not uid: return INVALID_REFRESH_TOKEN() access_token = gobelieve.login_gobelieve(int(uid), "") if not access_token: return CAN_NOT_GET_TOKEN() tok = { 'expires_in': 3600, 'token_type': 'Bearer', "access_token":access_token, "refresh_token":obj["refresh_token"], 'uid':int(uid) } Token.save_access_token(g.rds, access_token, uid, 3600) return make_response(200, tok)
def upload_file(): if not request.data: return NO_CONTENT() md5_value = md5.new(request.data).hexdigest() path = "/audios/" + md5_value r = FS.upload(path, request.data) if not r: return make_response(400) else: obj = {} url = request.url_root + "audios/" + md5_value src = "/audio/" + md5_value obj["src"] = src obj["src_url"] = url return make_response(200, obj)
def download_file(audio_path): path = "/audios/" + audio_path data = FS.download(path) if not data: return make_response(400) else: return data
def ios_version(): if is_voip(): ver = face_app_version(True) else: ver = message_app_version(True) return make_response(200, ver)
def accept_friend(): if not request.data: return INVALID_PARAM() req = json.loads(request.data) request_id = req.get('request_id') friend_uid = req.get('uid') if not request_id or not friend_uid: return INVALID_PARAM() friend_req = Friend.get_friend_request(g._db, request_id) if not friend_req: return INVALID_PARAM() if friend_req['uid'] != friend_uid or \ friend_req['friend_uid'] != request.uid: return INVALID_PARAM() #添加双向的好友关系 Friend.add_friend_relation(g._db, friend_req['uid'], friend_req['friend_uid']) sys_msg = {"friend":{"type":"accept", "uid":request.uid}} gobelieve.send_system_message(friend_req['uid'], json.dumps(sys_msg)) return make_response(200, {"success":True})
def post_conferences(): if not request.data: return INVALID_PARAM() req = json.loads(request.data) channel_id = req.get('channel_id', None) partipants = req.get('partipants', None) if not channel_id or not partipants: return INVALID_PARAM() uid = int(request.uid) now = int(time.time()) c = { "channel_id":channel_id, "initiator":uid, "partipants":partipants, "timestamp":now } p = "你的朋友邀请你加入群视频通话" obj = { "conference":c, "push":p, "sound":"apns.caf" } content = json.dumps(obj) for pid in partipants: if pid == uid: continue r = gobelieve.send_system_message(pid, content) logging.debug("send system message:%s", r) return make_response(200, {"success":True})
def create_network() -> Response: """ Create a network and returns assigned id """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) user = session.owner created_device = Device.create_device(user) return make_response(created_device.as_private_simple_dict())
def android_version(): if is_voip(): ver = face_app_version(False) else: ver = message_app_version(False) return make_response(200, ver)
def delete_friend(friend_uid): uid = request.uid Friend.delete_friend_relation(g._db, uid, friend_uid) sys_msg = {"friend":{"type":"delete", "uid":uid}} gobelieve.send_system_message(friend_uid, json.dumps(sys_msg)) return make_response(200, {"success":True})
def get_login_state(): """ 查询登录状态 参数: 返回:{ "code":"是否调用成功", "is_login":"******", "user_id":"用户id", "is_admin":"是否为管理员", "username":"******" } """ if not session.get("userid", None): return make_response(0, is_login=False) else: user = User.by_id(session.get("userid")) return make_response(9, is_login=True, user_id=user.id, is_admin=user.is_admin, username=user.username)
def translateLetters(): try: image = request.files["image"] image_name = image.filename image.save(os.path.join(os.getcwd(), image_name)) if filetype.is_image(os.path.join(os.getcwd(), image_name)): result = {'letter': [1,2,3,4,5]} response = make_response(result,True,200) os.remove(os.path.join(os.getcwd(), image_name)) return Response(response=response, status=200, mimetype='application/json') else: response = make_response('The file is NOT an Image', False, 200) return Response(response=response, status=200, mimetype='application/json') except Exception as e: print(e) response = make_response('The file is NOT FOUND', False, 404) return Response(response=response, status=404, mimetype='application/json')
def upload_image(): if not request.data: return make_response(400) content_type = request.headers["Content-Type"] if request.headers.has_key("Content-Type") else "" ext = image_ext(content_type) if not ext: return make_response(400) data = request.data name = md5.new(data).hexdigest() path = "/images/" + name + ext r = FS.upload(path, data) if not r: return make_response(400) url = request.url_root + "images/" + name + ext src = "/images/" + name + ext obj = {"src":src, "src_url":url} return make_response(200, data=obj)
def create_device() -> Response: """ Create a device and returns assigned id """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) address = request.form.get("address") user = session.owner power = request.form.get("power") networks = request.form.get("networks") created_device = Device.create_device(user, address, power, networks) return make_response(created_device.as_private_simple_dict())
def upload_image(): if not request.data: return make_response(400) content_type = request.headers["Content-Type"] if request.headers.has_key("Content-Type") else "" ext = image_ext(content_type) if not ext: return make_response(400) data = request.data name = md5.new(data).hexdigest() path = os.path.join(config.IMAGE_PATH, name + ext) with open(path, "wb") as f: f.write(data) url = request.url_root + "images/" + name + ext src = "/images/" + name + ext obj = {"src":src, "src_url":url} return make_response(200, data=obj)
def post_transmission(event, body, headers): logger.info(func_name()) logger.info(json.dumps(body)) # Will be in body for initial verification using POST tokenInRequest = body.get('verification-token') if tokenInRequest: err = check_token(tokenInRequest) if err: return err return make_response(body.get('challenge'), is_json=False) # Normal request... tokenInRequest = headers.get('verification-token') err = check_token(tokenInRequest) if err: return err return make_response(None, 200)
def get_history(): """ 获取扔垃圾历史 { "userid":"用户ID",//对于非管理员,只能是自己 "page":"页数", } { "code":0, "message":"xxx", "data":[ { "time":"时间", "rubbish_bin":"垃圾桶", "rubbish_id":"id", "rubbish_type":"种类" } ], "total_pages":"总页数" } """ ITEMS_PER_PAGE = 10 if not session.get("userid"): return make_response(-1, message="请先登录") user = User.by_id(session.get("userid")) target = request.form.get("userid", user.id) if str(user.id) != str(target): return make_response(-1, message="你没有权限这样做") result = db.session.query(RubbishLog).filter( RubbishLog.user_id == target).order_by(RubbishLog.id.desc()) import math pages = int(math.ceil(result.count()/ITEMS_PER_PAGE)) page = int(request.form["page"]) result = result.slice( (page-1)*ITEMS_PER_PAGE, (page)*ITEMS_PER_PAGE).all() ret_data = [] for item in result: ret_data.append({ "time": str(item.time), "rubbish_bin": item.rubbish_bin, "rubbish_id": item.id, "rubbish_type": item.rubbish_type }) return make_response(0, data=ret_data, total_pages=pages)
def list(): start_id = int(request.query.get('start_id', dao.get_osushi_count())) limit = int(request.query.get('limit', 10)) sushi_list = dao.get_osushi_list(start_id, limit) start_id = None if len(sushi_list) == 0 else start_id - len(sushi_list) return make_response({ 'sushi_list': sushi_list, 'start_id': start_id }, ok=True)
def information() -> Response: """ Returns the current session informations by the auth-token :return: The current session with informations of owner """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({"error": "token does not exists"}) return make_response({ "session": session.as_simple_dict(), "user": User.get_by_id(session.owner).as_private_simple_dict() })
def handler_destination(event, context): ''' Handler for redox destination GET - verification POST - transmission ''' # logger.info(event) handler = DEST_HANDLER_MAP.get(event.get('httpMethod')) if handler: return run_handler(handler, event) return make_response(None, 401)
def post_sso(event, body, headers): logger.info(func_name()) logger.info(json.dumps(body)) # Authorization: Bearer <token> (headers are lowercase by now) auth = headers.get('authorization') if not auth: return make_response({'error': 'missing auth header'}, 401) auth = auth.split() if len(auth) != 2 or auth[0] != 'Bearer': return make_response({'error': 'failed to parse bearer token'}, 401) payload = validate_jwt(auth[1]) if not payload: return make_response({'error': 'invalid token'}, 401) logger.info(payload) return make_redirect(os.environ['REDIRECT_URL'])
def get_runtime_env(event, body): ''' Handler to dump lambda environment (For debug, etc.) ''' path = os.popen("echo $PATH").read() directories = os.popen("find /opt -type d -maxdepth 4").read().split("\n") return make_response({ 'path': path, 'syspath': sys.path, 'directories': directories, 'event': event })
def logout() -> Response: """ This deletes a session. :return: A response """ token = request.headers.get('Token') if token is None: return make_response({"error": "no token given"}) session = Session.find(token) if session is None: return make_response({"error": "can not log out from nothing"}) # find session and delete it Session.find(token).delete() # send "ok" return make_response({"ok": True})
def _pagination(prefix): linked_list.set_prefix(prefix) start_id = request.query.get('start_id', linked_list.get_head_id()) limit = int(request.query.get('limit', 10)) if start_id is None: # empty return make_response({'sushi_list': [], 'start_id': None}, ok=True) values = linked_list.get_values(start_id, limit) sushi_list = [] for value in values: sushi_list.append(dao.get_osushi(value['id'])) start_id = values[-1]['prev_id'] return make_response({ 'sushi_list': sushi_list, 'start_id': start_id }, ok=True)
def sell(id): sender = get_sender() body = request.environ['wsgi.input'] param = json.loads(body.read().decode('utf8')) price = param.get("price") if price is None: return make_response( { 'error': 'error.priceNotFound', 'body': 'price not found' }, ok=False) osushi = dao.get_osushi(id) if not osushi: return make_response( { 'error': 'error.sushiNotFound', 'body': 'sushi not found' }, ok=False) if osushi['owner'] != sender: return make_response( { 'error': 'error.canNotSellSushiNotYours', 'body': 'cannot sell sushi is not yours' }, ok=False) osushi['price'] = price dao.set_osushi(id, osushi) linked_list.set_prefix(f'market') linked_list.push_head(osushi['id']) return make_response({'sushi': osushi}, ok=True)
def get_verification(event, body, headers): ''' GET /destination Deprecated approach to verification They send challenge and verification token in header and query string params ''' logger.info(func_name()) tokenInRequest = headers.get('verification-token') err = check_token(tokenInRequest) if err: return err query = event.get('queryStringParameters') or {} return make_response(query.get('challenge'), is_json=False)
def add_device_to_network() -> Response: """ Add a device to network """ token = request.headers.get('Token') session = Session.find(token) if session is None: return make_response({ "error": "token does not exists" }) network_id = request.form.get("id") network = Network.get_by_id(network_id) if network_id: if session.owner != network.owner: return make_response({ "error": "permission denied" }) else: return make_response({ "error": "id missing, or not existing" })
def login() -> Response: """ Handles the login which means that this will create a new session if the given credentials are valid. :return: A response """ token = request.headers.get('Token') username = request.form.get("username") password = request.form.get("password") # check if username and password are given if None in (username, password): return make_response({"error": "username or password not given"}) # checks if the token sent by the user does exist and is still valid if token is not None: session = Session.find(token) if session is not None: if session.is_valid(): return make_response({"error": "already signed in"}) user = User.get(username) if not user: return make_response({"error": "incorrect password"}) password_validity = user.validate_password(password) if password_validity: return make_response({ # create session and return its token "token": Session.create(user.id).token }) else: return make_response({"error": "incorrect password"})
def register_user(): if not request.data: return INVALID_PARAM() req = json.loads(request.data) name = req.get('nickname') password = req.get('password') #短信验证码 code = req.get("code") number = req.get("number") country_code = req.get("country_code") if not name or not password or not code \ or not number or not country_code: return INVALID_PARAM() #check sms code if is_test_number(number): pass else: c2, timestamp, _ = code.get_verify_code(g.rds, country_code, number) if c1 != c2: return INVALID_CODE() password = generate_password_hash(password) phone_number = "+%s-%s"%(country_code, number) u = DBUser.get_user(g._db, phone_number) if u: uid = u['id'] DBUser.save_user(g._db, uid, name, password) else: uid = DBUser.add_user(g._db, name, password, phone_number) #登录动作 access_token = gobelieve.login_gobelieve(uid, name) if not access_token: return CAN_NOT_GET_TOKEN() tok = { 'expires_in': 3600, "access_token":access_token, "refresh_token":random_token_generator(), 'uid':uid } Token.save_access_token(g.rds, access_token, uid, 3600) Token.save_refresh_token(g.rds, tok['refresh_token'], uid) return make_response(200, tok)
def verify_code(): zone = request.args.get("zone", "") number = request.args.get("number", "") logging.info("zone:%s number:%s", zone, number) if not is_test_number(number) and not check_verify_rate(g.rds, zone, number): return OVERFLOW() vc = create_verify_code() code.set_verify_code(g.rds, zone, number, vc) data = {} if True:#debug data["code"] = vc data["number"] = number data["zone"] = zone if is_test_number(number): return make_response(200, data = data) if is_super_number(number): return make_response(200, data = data) if not send_sms(number, vc, config.APP_NAME): return SMS_FAIL() return make_response(200, data = data)
def request_friend(): uid = request.uid if not request.data: return INVALID_PARAM() req = json.loads(request.data) friend_uid = req.get('friend_uid') req_id = Friend.add_friend_request(g._db, uid, friend_uid) sys_msg = {"friend":{"request_id":req_id, "uid":uid, "type":"request"}} gobelieve.send_system_message(friend_uid, json.dumps(sys_msg)) resp = {"request_id":req_id} return make_response(200, resp)
def login(): """ 登录 参数:{ "identifier":"用户标识符", "password":"******" } 返回:{ "code":"是否调用成功", "message":"" } """ if session.get("userid") is not None: return make_response(-1, { "message": "用户已登录" }) query = db.session.query(User).filter(or_( User.email == request.form["identifier"], User.username == request.form["identifier"])).filter(User.password == request.form["password"]) if not query.count(): return make_response(-1, **{ "message": "用户名或密码错误" }) session["userid"] = query.one().id return make_response(0)
def download_mp3(audio_path): path = "/audios/" + audio_path + ".mp3" data = FS.download(path) if not data: path = "/audios/" + audio_path amr_data = FS.download(path) if amr_data: data = amr_to_mp3(amr_data) path = "/audios/" + audio_path + ".mp3" FS.upload(path, data) if not data: return make_response(400) else: return data
def access_token(): if not request.data: return INVALID_PARAM() obj = json.loads(request.data) c1 = obj["code"] number = obj["number"] zone = obj["zone"] if is_test_number(number): pass else: c2, timestamp, _ = code.get_verify_code(g.rds, zone, number) if c1 != c2: return INVALID_CODE() uid = user.make_uid(zone, number) access_token = gobelieve.login_gobelieve(uid, "") if not access_token: return CAN_NOT_GET_TOKEN() u0 = user.get_user(g.rds, uid) u = user.User() u.uid = uid if u0 is None: u.state = "Hey!" else: u.state = u0.state user.save_user(g.rds, u) tok = { 'expires_in': 3600, 'token_type': 'Bearer', "access_token":access_token, "refresh_token":random_token_generator(), 'uid':int(uid) } Token.save_access_token(g.rds, access_token, uid, 3600) Token.save_refresh_token(g.rds, tok['refresh_token'], uid) return make_response(200, tok)
def login(): if not request.data: return INVALID_PARAM() req = json.loads(request.data) password = req.get('password') number = req.get("number") country_code = req.get("country_code") phone_number = "+%s-%s"%(country_code, number) u = DBUser.get_user(g._db, phone_number) if not u: return INVALID_USERNAME() if not check_password_hash(u['password'], password): return INVALID_PASSWORD() uid = u['id'] nickname = u.get('nickname') avatar = u.get('avatar') state = u.get('state') nickname = nickname if nickname else "" avatar = avatar if avatar else "" state = state if state else "" access_token = gobelieve.login_gobelieve(uid, nickname) if not access_token: return CAN_NOT_GET_TOKEN() tok = { 'expires_in': 3600, "access_token":access_token, "refresh_token":random_token_generator(), 'uid':u['id'], 'avatar':avatar, 'state':state } Token.save_access_token(g.rds, access_token, u['id'], 3600) Token.save_refresh_token(g.rds, tok['refresh_token'], u['id']) return make_response(200, tok)
def INVALID_USERNAME(): e = {"error":"用户名不存在"} logging.warn(e['error']) return make_response(400, e)
def INVALID_ACCESS_TOKEN(): e = {"error":"非法的access token"} logging.warn("非法的access token") return make_response(400, e)
def INVALID_CODE(): e = {"error":"验证码错误"} logging.warn("验证码错误") return make_response(400, e)
def NO_CONTENT(): e = {"error":"上传内容为空"} return make_response(400, e)
def INVALID_PASSWORD(): e = {"error":"密码错误"} logging.warn(e['error']) return make_response(400, e)
def CAN_NOT_GET_TOKEN(): e = {"error":"获取imsdk token失败"} logging.warn("获取imsdk token失败") return make_response(400, e)
def INVALID_REFRESH_TOKEN(): e = {"error":"非法的refresh token"} logging.warn("非法的refresh token") return make_response(400, e)
def SMS_FAIL(): e = {"error":"发送短信失败"} logging.warn("发送短信失败") return make_response(400, e)
def wrapper(*args, **kwargs): if not util.is_via_chain(): return util.make_response({'error': 'access via chain required.'}, ok=False) return func(*args, **kwargs)
def OVERFLOW(): e = {"error":"get verify code exceed the speed rate"} logging.warn("get verify code exceed the speed rate") return make_response(400, e)
def EXPIRE_ACCESS_TOKEN(): e = {"error":"过期的access token"} logging.warn("过期的access token") return make_response(400, e)
def INVALID_PARAM(): e = {"error":"非法输入"} logging.warn("非法输入") return make_response(400, e)