Python models.User 模块，get() 实例源码

我们从Python开源项目中，提取了以下39个代码示例，用于说明如何使用models.User.get()。

项目：ecommerce_api 作者：nbschool | 项目源码 | 文件源码

def load_user_from_request(request):
    """
    User login validation logic. If the user exists with the given username
    and with the correct password then returns the user, otherwise None.

    Args:
        request (Request): The flask request object used in endpoint handlers

    Returns:
        models.User: The logged user, None if login fails
    """
    if not request.authorization:
        return None
    try:
        user = User.get(User.email == request.authorization['username'])
    except User.DoesNotExist:
        return None

    if user.verify_password(request.authorization['password']):
        return user
    return None

项目：ecommerce_api 作者：nbschool | 项目源码 | 文件源码

def post(self):
        request_data = request.get_json(force=True)

        if 'email' not in request_data or 'password' not in request_data:
            abort(client.BAD_REQUEST)

        email = request_data['email']
        password = request_data['password']

        try:
            user = User.get(User.email == email)
        except User.DoesNotExist:
            abort(client.BAD_REQUEST)

        if not user.verify_password(password):
            abort(client.UNAUTHORIZED)

        login_user(user)
        return generate_response({}, client.OK)

项目：ecommerce_api 作者：nbschool | 项目源码 | 文件源码

def delete(self, order_uuid):
        """ Delete a specific order. """
        try:
            obj = Order.get(uuid=str(order_uuid))
        except Order.DoesNotExist:
            return None, NOT_FOUND

        # get the user from the flask.g global object registered inside the
        # auth.py::verify() function, called by @auth.login_required decorator
        # and match it against the found user.
        # This is to prevent users from deleting other users' account.
        if auth.current_user != obj.user and auth.current_user.admin is False:
            return ({'message': "You can't delete another user's order"},
                    UNAUTHORIZED)

        obj.delete_instance(recursive=True)
        return None, NO_CONTENT

项目：python-webapp-blog 作者：tzshlyt | 项目源码 | 文件源码

def parse_signed_cookie(cookie_str):
    try:
        L = cookie_str.split('-')
        if len(L) != 3:
            return None
        id, expires, md5 = L
        if int(expires) < time.time():
            return None
        user = User.get(id)
        if user is None:
            return None
        if md5 != hashlib.md5('%s-%s-%s-%s' % (id, user.password, expires, _COOKIE_KEY)).hexdigest():
            return None
        return user
    except:
        return None

项目：python-webapp-blog 作者：tzshlyt | 项目源码 | 文件源码

def api_update_blog(blog_id):
    check_admin()
    i = ctx.request.input(name='', summary='', content='')
    name = i.name.strip()
    summary = i.summary.strip()
    content = i.content.strip()
    if not name:
        raise APIValueError('name', 'name cannot be empty.')
    if not summary:
        raise APIValueError('summary', 'summary cannot be empty.')
    if not content:
        raise APIValueError('content', 'content cannot be empty.')
    blog = Blog.get(blog_id)
    if blog is None:
        raise APIResourceNotFoundError('Blog')
    blog.name = name
    blog.summary = summary
    blog.content = content
    blog.update()
    return blog

项目：learn-flask 作者：ProfNandaa | 项目源码 | 文件源码

def login():
    next_ = request.values.get('next')
    if request.method == 'POST':
        form = {
            'username' : request.form['username'],
            'password' : request.form['password']
        }
        user = User.validate(**form)
        if user[0]:
            if request.form['next'] != '':
                session['user'] = {
                    'username': user[1].username,
                    'id': user[1].id
                }
                return redirect(request.form['next'])
            return redirect(url_for('home'))
    return render_template('login.html', next=next_)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def test_move(self):
        # add game and check it
        game = Game.create(white='123', black='456', state='Ke1,ke8')
        self.assertTrue(abs((game.date_created - game.date_state).total_seconds()) < 1)
        self.assertEqual(game.next_color, WHITE)
        self.assertEqual(Game.select().count(), 1)
        self.assertEqual(Move.select().count(), 0)
        self.assertFalse(game.ended)
        # wait a second
        time.sleep(1)
        # add move and check
        game.add_move('K', 'e1-e2', 'Ke2,ke8')
        self.assertEqual(Move.select().count(), 1)
        # reload game
        game = Game.get(pk=game.pk)
        self.assertEqual(game.next_color, BLACK)
        self.assertEqual(game.state, 'Ke2,ke8')
        self.assertTrue((game.date_state - game.date_created).total_seconds() > 1)
        self.assertAlmostEqual(game.moves.get().time_move, 1, places=1)
        self.assertFalse(game.ended)
        # add move with ending game
        game.add_move('k', 'e8-e7', 'Ke2,ke7', True)
        self.assertTrue(game.ended)
        self.assertEqual(game.winner, BLACK)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def test_game_over_1(self):
        # add game and check it
        game = Game.create(white='123', black='456', state='Ke1,ke8')
        self.assertFalse(game.ended)
        self.assertIsNone(game.end_reason)
        self.assertIsNone(game.date_end)
        # game over with saving
        game.game_over(END_CHECKMATE)
        self.assertTrue(game.ended)
        self.assertEqual(game.end_reason, 1)
        self.assertIsNotNone(game.date_end)
        self.assertIsNone(game.winner)
        # reload game
        game = Game.get(pk=game.pk)
        self.assertTrue(game.ended)
        self.assertEqual(game.end_reason, 1)
        self.assertIsNotNone(game.date_end)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def test_game_over_2(self):
        # add game and check it
        game = Game.create(white='123', black='456', state='Ke1,ke8')
        self.assertFalse(game.ended)
        self.assertIsNone(game.end_reason)
        self.assertIsNone(game.date_end)
        # game over without saving
        game.game_over(END_CHECKMATE, datetime(2015, 1, 27, 12, 0, 0), False, WHITE)
        self.assertTrue(game.ended)
        self.assertEqual(game.end_reason, 1)
        self.assertEqual(game.date_end, datetime(2015, 1, 27, 12, 0, 0))
        self.assertEqual(game.winner, WHITE)
        # reload game
        game = Game.get(pk=game.pk)
        self.assertFalse(game.ended)
        self.assertIsNone(game.end_reason)
        self.assertIsNone(game.date_end)
        self.assertIsNone(game.winner)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def accept(game_id):
    try:
        pool = GamePool.get(GamePool.pk == game_id)
    except GamePool.DoesNotExist:
        return send_error('Game not found')
    except Exception as e:
        return send_error('Wrong format')
    if pool.user1 and pool.user1 == request.user:
        return send_error('You cannot start game with yourself')
    with config.DB.atomic():
        pool.player2 = generate_token(True)
        pool.user2 = request.user
        pool.is_started = True
        pool.save()
        game = Game.new_game(
            pool.player1, pool.player2, pool.type_game, pool.time_limit,
            white_user=pool.user1, black_user=pool.user2
        )
        delete_cache('wait_{}'.format(pool.player1))
        result = {'game': pool.player2}
        result.update(game.get_info(consts.BLACK))
    return send_data(result)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def invited(token):
    try:
        enemy_token, game_type, game_limit = get_cache('invite_{}'.format(token))
    except:
        return send_error('game not found')
    enemy_user = None
    user_id = get_cache('user_{}'.format(enemy_token))
    if user_id:
        try:
            enemy_user = User.get(pk=user_id)
        except User.DoesNotExist:
# TODO: if user not found game will be created with None as white player
            pass
    user_token = generate_token(True)
    game = Game.new_game(
        enemy_token, user_token, game_type, game_limit,
        white_user=enemy_user, black_user=request.user
    )
    delete_cache('wait_{}'.format(enemy_token))
    result = {'game': user_token}
    result.update(game.get_info(consts.BLACK))
    return send_data(result)

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def get(self):
        result = []
        count = 0
        for pool in GamePool.select().where(
            GamePool.is_started == False,
            GamePool.is_lost == False,
            GamePool.player1 is not None,
        ).order_by(GamePool.date_created.desc()):
            if pool.user1 and pool.user1 == request.user:
                continue
            result.append({
                'id': pool.pk,
                'date_created': pool.date_created.isoformat(),
                'user': pool.user1.username if pool.user1 else None,
                'type': consts.TYPES[pool.type_game]['name'],
                'limit': pool.time_limit,
            })
            count += 1
            if count > 9:
                break
        return {'games': result}

项目：dark-chess 作者：AHAPX | 项目源码 | 文件源码

def post(self, game_id):
        try:
            pool = GamePool.get(GamePool.pk == game_id)
        except GamePool.DoesNotExist:
            raise errors.APINotFound('game')
        except Exception as e:
            raise errors.APIException('wrong format')
        if pool.user1 and pool.user1 == request.user:
            raise errors.APIException('you cannot start game with yourself')
        pool.player2 = generate_token(True)
        pool.user2 = request.user
        pool.is_started = True
        pool.save()
        game = Game.new_game(
            pool.player1, pool.player2, pool.type_game, pool.time_limit,
            white_user=pool.user1, black_user=pool.user2
        )
        delete_cache('wait_{}'.format(pool.player1))
        result = {'game': pool.player2}
        result.update(game.get_info(consts.BLACK))
        return result