Esempio n. 1
0
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)
Esempio n. 2
0
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)
Esempio n. 3
0
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)
Esempio n. 6
0
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?
    })
Esempio n. 7
0
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)
Esempio n. 8
0
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)
Esempio n. 9
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)
Esempio n. 10
0
def logout():
    """
    登出
    参数:
    """
    if session.get("userid") is None:
        return make_response(-1, message="你尚未登录!")
    session.pop("userid")
    return make_response(0)
Esempio n. 11
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)
Esempio n. 12
0
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})
Esempio n. 13
0
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)
Esempio n. 14
0
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)
Esempio n. 15
0
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)
Esempio n. 16
0
def download_file(audio_path):
    path = "/audios/" + audio_path
    data = FS.download(path)
    if not data:
        return make_response(400)
    else:
        return data
Esempio n. 17
0
def ios_version():
    if is_voip():
        ver = face_app_version(True)
    else:
        ver = message_app_version(True)

    return make_response(200, ver)
Esempio n. 18
0
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})
Esempio n. 19
0
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())
Esempio n. 21
0
def android_version():
    if is_voip():
        ver = face_app_version(False)
    else:
        ver = message_app_version(False)

    return make_response(200, ver)
Esempio n. 22
0
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})    
Esempio n. 23
0
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)
Esempio n. 24
0
File: app.py Progetto: ManojLL/test1
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')
Esempio n. 25
0
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)
Esempio n. 26
0
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())
Esempio n. 27
0
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)
Esempio n. 29
0
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)
Esempio n. 30
0
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)
Esempio n. 31
0
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)
Esempio n. 33
0
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'])
Esempio n. 34
0
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
    })
Esempio n. 35
0
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})
Esempio n. 36
0
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)
Esempio n. 37
0
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"
        })
Esempio n. 40
0
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"})
Esempio n. 41
0
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)
Esempio n. 42
0
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)
Esempio n. 43
0
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)
Esempio n. 44
0
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)
Esempio n. 45
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
Esempio n. 46
0
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)
Esempio n. 47
0
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)
Esempio n. 48
0
def INVALID_USERNAME():
    e = {"error":"用户名不存在"}
    logging.warn(e['error'])
    return make_response(400, e)
Esempio n. 49
0
def INVALID_ACCESS_TOKEN():
    e = {"error":"非法的access token"}
    logging.warn("非法的access token")
    return make_response(400, e)
Esempio n. 50
0
def INVALID_CODE():
    e = {"error":"验证码错误"}
    logging.warn("验证码错误")
    return make_response(400, e)
Esempio n. 51
0
def NO_CONTENT():
    e = {"error":"上传内容为空"}
    return make_response(400, e)
Esempio n. 52
0
def INVALID_PASSWORD():
    e = {"error":"密码错误"}
    logging.warn(e['error'])
    return make_response(400, e)
Esempio n. 53
0
def CAN_NOT_GET_TOKEN():
    e = {"error":"获取imsdk token失败"}
    logging.warn("获取imsdk token失败")
    return make_response(400, e)
Esempio n. 54
0
def INVALID_REFRESH_TOKEN():
    e = {"error":"非法的refresh token"}
    logging.warn("非法的refresh token")
    return make_response(400, e)
Esempio n. 55
0
def SMS_FAIL():
    e = {"error":"发送短信失败"}
    logging.warn("发送短信失败")
    return make_response(400, e)
Esempio n. 56
0
    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)
Esempio n. 57
0
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)
Esempio n. 58
0
def EXPIRE_ACCESS_TOKEN():
    e = {"error":"过期的access token"}
    logging.warn("过期的access token")
    return make_response(400, e)
Esempio n. 59
0
def INVALID_PARAM():
    e = {"error":"非法输入"}
    logging.warn("非法输入")
    return make_response(400, e)