Esempio n. 1
0
def fulltime_request(user, address=None):
    auth = yield get_db_object_by_attr(Auth, user_id=user.id, ignore=True)
    if auth and auth.identifier:
        raise gen.Return(already_exist_error('user %s is already a xiaodier' % user.nickname))

    request_record = RequestRecord(user_id=user.id, detail=address)

    yield execute(('add', request_record))
    yield execute(('commit', None))

    raise gen.Return(None)
Esempio n. 2
0
def first_award(user, key):
    type_, type_doc, point = key
    award = yield get_db_object_by_attr(Award,
                                        user_id=user.id,
                                        type=type_,
                                        ignore=True)
    if award is None:
        user.original_point += point
        point_record = PointRecord(user_id=user.id,
                                   type=type_doc,
                                   balance=user.bright_point +
                                   user.original_point,
                                   number='+' + str(point))
        award = Award(user_id=user.id, type=type_)
        yield execute(('add_all', [user, award, point_record]))
        yield execute(('commit', None))
Esempio n. 3
0
 def wrapper(self, *args, **kwargs):
     username = self.get_argument("username", None)
     token = self.get_argument("token", None)
     if permission == Permission.COMMON:
         self._G.user = yield authorizer.authenticate_common(
             username=username, token=token)
     elif permission == Permission.MANAGER:
         self._G.user = yield authorizer.authenticate_manager(
             username=username, token=token)
     elif permission == Permission.ADMIN:
         self._G.user = authorizer.authenticate_admin(username=username,
                                                      token=token)
     if identified and not self._G.user.identified:
         not_authorized_error('user %s is not identified' %
                              self._G.user.nickname)
     if innocence:
         black_list = yield execute([('query', BlackList),
                                     ('filter', None), ('first', None)])
         if self._G.user.id in json.loads(black_list.list):
             not_authorized_error('user %s is not innocence' %
                                  self._G.user.nickname)
     if xiaodier and self._G.user.role not in XIAODIER:
         not_authorized_error('user %s is not xiaodier' %
                              self._G.user.nickname)
     # run generator until finish
     f = func(self, *args, **kwargs)
     while True:
         try:
             f.send((yield next(f, None)))
         except StopIteration:
             break
     raise gen.Return(None)
Esempio n. 4
0
    def _authenticate(self, object_=User, username=None, token=None):
        user = yield execute([('query', object_),
                              ('filter', object_.username == username),
                              ('first', None)])
        if user is None:
            raise gen.Return(not_authorized_error('wrong username'))
        if not AuthorizerHelper.verify_token(user, token):
            raise gen.Return(not_authorized_error('wrong token'))

        raise gen.Return(user)
Esempio n. 5
0
def get_delivery(school=None,
                 sort=None,
                 ascend=None,
                 keyword=None,
                 page_num=None):
    from sqlalchemy import and_, or_

    order_way = getattr(Task, ORDER_FIELDS[sort])
    if not ascend:
        order_way = order_way.desc()

    if keyword:
        keyword = ['%{}%'.format(k) for k in keyword.encode('utf-8').split()]
        task_fields = ['source', 'type', 'destination']
        task_list = [
            and_(getattr(Task, attr).like(k) for k in keyword)
            for attr in task_fields
        ]
        user_fields = ['nickname', 'campus', 'hostel']
        user_list = [
            and_(getattr(User, attr).like(k) for k in keyword)
            for attr in user_fields
        ]
        deliveries = yield execute(
            sqls=[('query', Task), ('join', (
                User,
                Task.puser_id == User.id)), ('filter', Task.school == school),
                  ('filter',
                   or_(*(task_list + user_list))), ('order_by', order_way),
                  ('offset', (page_num - 1) *
                   MAX_DELIVERY_PER_PAGE), (
                       'limit', MAX_DELIVERY_PER_PAGE), ('all', None)])
    else:
        deliveries = yield execute(
            sqls=[('query',
                   Task), ('filter',
                           Task.school == school), ('order_by', order_way),
                  ('offset', (page_num - 1) *
                   MAX_DELIVERY_PER_PAGE), (
                       'limit', MAX_DELIVERY_PER_PAGE), ('all', None)])

    raise gen.Return([delivery.to_json() for delivery in deliveries])
Esempio n. 6
0
def identify_user(user, role=None, school='cqu', sid=None,
                  password=None, truename=None):
    if user.identified:
        raise gen.Return(already_exist_error('user %s is already identified' % user.nickname))

    if (yield get_db_object_by_attr(Auth, school_id=sid, ignore=True)) is not None:
        raise gen.Return(already_exist_error('school_id %s is already identified' % sid))

    result = yield CommonTaskFactory.get_task(TaskNames.IDENTIFY_USER.value).run(
        school=school, sid=sid, password=password, truename=truename
    )
    if result is None:
        raise gen.Return(invalid_argument_error('certification is failed, please check the params'))

    auth = Auth(
        user_id=user.id,
        truename=truename,
        school_id=sid,
        school_role=role,
        identifier=""
    )
    engagement = Engagement(
        user_id=user.id,
        engagement=json.dumps([0])
    )
    sign = Sign(
        user_id=user.id,
        day=-1,
        record=json.dumps([])
    )
    user.identified = True
    user.school = school

    yield execute(('add_all', [auth, engagement, sign, user]))
    yield execute(('commit', None))

    raise gen.Return(None)
Esempio n. 7
0
def register_user(password=None, nickname=None, code=None,
                  headimg=None, sex=None, phone=None, unique_id=None):
    if (yield get_db_object_by_attr(User, phone=phone, ignore=True)) is not None:
        raise gen.Return(already_exist_error('phone %s alreay exist' % phone))
    if (yield get_db_object_by_attr(User, nickname=nickname, ignore=True)) is not None:
        raise gen.Return(already_exist_error('nickname %s alreay exist' % nickname))
    if headimg:
        headimg_path = yield save_image_to_oss(headimg, OSS_HEADIMG_PATH,
                                         str(datetime.now()), when_fail=DEFAULT_HEADIMG)
    else:
        headimg_path = DEFAULT_HEADIMG

    bright_point = 0
    if code:
        user = yield get_db_object_by_attr(User, code=code)
        if user:
            user.bright_point += INVITE_AWARD_POINT
            user.code = None
            execute(('add', user))

            point_record = PointRecord(
                username=user.username,
                type='邀好友注册',
                balance=user.bright_point + user.original_point,
                number='+%d' % INVITE_AWARD_POINT,
                time=datetime.now().__format__("%Y-%m-%d")
            )
            yield execute(('add', point_record))
            yield execute(('commit', None))
            bright_point = INVITE_AWARD_POINT

    user = User(
        username=generate_unique_username(),
        password=password_manager.encrypt(password),
        nickname=nickname,
        phone=phone,
        role=Permission.COMMON,
        unique_id=unique_id,
        code=(yield generate_invitingcode()),
        headimg=headimg_path,
        sex=sex,
        identified=False,
        school="",
        campus="",
        hostel="",
        introduction="",
        original_point=DEFAULT_POINT,
        bright_point=bright_point,
        credibility=DEFAULT_CREDIBILITY
    )
    yield execute(('add', user))
    yield execute(('commit', None))

    raise gen.Return(user)
Esempio n. 8
0
def get_db_object_by_attr(object_, **kwargs):
    assert len(kwargs) >= 1, 'function get_db_object_by_attr need argument'

    if 'ignore' in kwargs:
        ignore = kwargs.pop('ignore')
    else:
        ignore = False
    if len(kwargs) > 1:
        filter_ = and_(*[
            getattr(object_, key) == value
            for key, value in kwargs.iteritems()
        ])
    else:
        key, value = kwargs.popitem()
        filter_ = getattr(object_, key) == value
    user = yield execute(sqls=[('query', object_), ('filter',
                                                    filter_), ('first', None)])
    if not user and not ignore:
        raise gen.Return(invalid_argument_error('wrong %s' % key))

    raise gen.Return(user)
Esempio n. 9
0
 def _asave(self, delivery):
     yield execute(('add', delivery))
     yield execute(('commit', None))
Esempio n. 10
0
def do_forget_password(phone=None, password=None):
    user = yield get_db_object_by_attr(User, phone=phone)
    user = password_manager.forget_password(user, password)

    yield execute(('add', user))
    yield execute(('commit', None))