Python g.current_user方法代碼示例

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def has_item_write_permission(self, user_id, item):
        """Check if the user is allowed to modify the item.

        Implement this function for your resource.
        Default behaviour: No user has write permission.

        Args:
            user (str): The id of the user that wants to access the item
            item (dict): The item the user wants to change or delete.
                Attention! If they are any ObjectIds in here, Eve will not have
                converted them yet, so be sure to cast them to str if you want
                to compare them to e.g. g.current_user

        Returns:
            bool: True if user has permission to change the item, False if not.
        """
        return False 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def test_authentication_defaults(self):
        """Make sure authenticate sets defaults for all auth values."""
        expect_none = 'current_token', 'current_user', 'current_session'
        expect_false = 'resource_admin', 'resource_admin_readonly'

        with self.app.test_request_context():
            # Nothing there before
            for item in expect_none + expect_false:
                with self.assertRaises(AttributeError):
                    getattr(g, item)

            authenticate()
            for item in expect_none:
                self.assertIsNone(getattr(g, item))

            check_if_admin('someresource')
            for item in expect_false:
                self.assertFalse(getattr(g, item)) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def _validate_only_self_enrollment_for_event(self, enabled, field, value):
        """Validate if the user can be used to enroll for an event.

        1.  Anyone can signup with no user id
        2.  other id: Registered users can only enter their own id
        3.  Exception are resource admins: they can sign up others as well

        Args:
            enabled (bool): validates nothing if set to false
            field (string): field name
            value: field value

        The rule's arguments are validated against this schema:
        {'type': 'boolean'}
        """
        if enabled:
            if g.resource_admin or value is None:
                return
            if g.get('current_user') != str(value):
                self._error(field, "You can only enroll yourself. (%s: "
                                   "%s is yours)." % (field, g.current_user)) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def new_post_comment(id):
    post = Post.query.get_or_404(id)
    comment = Comment.from_json(request.json)
    comment.author = g.current_user
    comment.post = post
    db.session.add(comment)
    db.session.commit()
    return jsonify(comment.to_json()), 201, \
        {'Location': url_for('api.get_comment', id=comment.id,
                             _external=True)} 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def new_post():
    post = Post.from_json(request.json)
    post.author = g.current_user
    db.session.add(post)
    db.session.commit()
    return jsonify(post.to_json()), 201, \
        {'Location': url_for('api.get_post', id=post.id, _external=True)} 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def edit_post(id):
    post = Post.query.get_or_404(id)
    if g.current_user != post.author and \
            not g.current_user.can(Permission.ADMINISTER):
        return forbidden('Insufficient permissions')
    post.body = request.json.get('body', post.body)
    db.session.add(post)
    return jsonify(post.to_json()) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def verify_password(email_or_token, password):
    if email_or_token == '':
        g.current_user = AnonymousUser()
        return True
    if password == '':
        g.current_user = User.verify_auth_token(email_or_token)
        g.token_used = True
        return g.current_user is not None
    user = User.query.filter_by(email=email_or_token).first()
    if not user:
        return False
    g.current_user = user
    g.token_used = False
    return user.verify_password(password) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def before_request():
    if not g.current_user.is_anonymous and \
            not g.current_user.confirmed:
        return forbidden('Unconfirmed account') 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def new_post_comment(id):
    post = Post.query.get_or_404(id)
    comment = Comment.from_json(request.json)
    comment.author = g.current_user
    comment.post = post
    db.session.add(comment)
    db.session.commit()
    return jsonify(comment.to_json()), 201, \
        {'Location': url_for('api.get_comment', id=comment.id,_external=True)} 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def new_post():
    post = Post.from_json(request.json)
    post.author = g.current_user
    db.session.add(post)
    db.session.commit()
    return jsonify(post.to_json()), 201, {'Location': url_for('api.get_post',id=post.id, _external=True)}

# put請求 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def edit_post(id):
    post = Post.query.get_or_404(id)
    if g.current_user != post.author and \
            not g.current_user.operation(Permission.ADMINISTER):
        return forbidden('Insufficient permissions')
    post.title = request.json.get('title', post.title)
    post.body = request.json.get('body', post.body)
    db.session.add(post)
    return jsonify(post.to_json()) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def before_request():
    if not g.current_user.is_authenticated:
        return forbidden('Unconfirmed account') 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def verify_password(username, password):
    """Check username and password with stored password hash from database."""
    user = User.query.filter_by(username=username).first()
    if user is None:
        return False
    g.current_user = user
    return user.check_password(password) 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def verify_token(token):
    """API verify auth user token."""
    g.current_user = User.check_token(token) if token else None
    return g.current_user is not None 

# 需要導入模塊: from flask import g [as 別名]
# 或者: from flask.g import current_user [as 別名]
def auth_required(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        token = request.headers.get('Authorization', '')
        if token:
            user = verify_token(token)
            if user:
                g.current_user = user
                return func(*args, **kwargs)
        return UNAUTHORIZED
    return wrapper