change something

Author: zhangjie

api/app.py

@@ -18,6 +18,9 @@ def create_app():
     db.init_app(app)
 
     from .auth import api_auth as auth_blueprint
-    app.register_blueprint(auth_blueprint, url_prefix='/auth')
+    app.register_blueprint(auth_blueprint, url_prefix='/api')
+
+    from .users import api_user as user_blueprint
+    app.register_blueprint(user_blueprint, url_prefix='/api')
 
     return app

api/auth/__init__.py

@@ -1,11 +1,13 @@
 from flask import Blueprint
 from ..app import api
-
-from .resources.foo import Foo
+from .resources.login import LoginApi
+from .resources.logout import LogOutApi
 
 api_auth = Blueprint('auth', __name__)
 
-api.add_resource(Foo, '/todos/<int:id>')
+api.add_resource(LoginApi, '/login')
+api.add_resource(LogOutApi, '/logout')
+
 api.init_app(api_auth)
 
 """Initialize this class with the given :class:`flask.Flask`

api/auth/resources/foo.py

@@ -0,0 +1,29 @@
+from flask_restful import Resource, reqparse
+from flask import jsonify
+
+from api.models.user import User
+
+
+class LoginApi(Resource):
+    def __init__(self):
+        self.reqparse = reqparse.RequestParser()
+        self.reqparse.add_argument('username', type=str, required=True, help='用户名不能为空', location='json')
+        self.reqparse.add_argument('password', type=str, required=True, help='密码不能为空', location='json')
+        super(LoginApi, self).__init__()
+
+    def get(self):
+        return {'task': 'Say "Hello, World!"'}
+
+    def post(self):
+        args = self.reqparse.parse_args()
+        username = args.get('username')
+        password = args.get('password')
+
+        user = User.query.filter_by(username=username).first()
+        if user and user.verify_password(password):
+            token = user.generate_auth_token().decode('ascii')
+            user.token = token
+
+            return jsonify({'data': user.to_dict()})
+
+        return {'errcode': 422, 'errmsg': '用户名或者密码不对'}, 422

api/auth/resources/login.py

@@ -0,0 +1,25 @@
+from flask_restful import Resource, reqparse
+from flask import jsonify
+
+from api.models.user import User
+from api.auth_token import token_auth
+
+
+class LogOutApi(Resource):
+    decorators = [token_auth.login_required]
+
+    def __init__(self):
+        self.reqparse = reqparse.RequestParser()
+        self.reqparse.add_argument('token', type=str, required=True, help='token不能为空', location='json')
+        super(LogOutApi, self).__init__()
+
+    def post(self):
+        args = self.reqparse.parse_args()
+        token = args.get('token')
+
+        user = User.query.filter_by(token=token).first()
+        if not user:
+            return {'errcode': 422, 'errmsg': 'Token失效或者不对'}, 422
+
+        user.token = None
+        return jsonify({})

api/auth/resources/logout.py

@@ -0,0 +1,21 @@
+from flask_httpauth import HTTPBasicAuth, HTTPTokenAuth, MultiAuth
+
+from . import app
+from .models.user import User
+from .errors import unauthorized, forbidden
+
+token_auth = HTTPTokenAuth(scheme='Bearer')
+
+
+@token_auth.verify_token
+def verify_token(token):
+    print(token)
+    if token:
+        user = User.verify_auth_token(token)
+        return user is not None
+    return False
+
+
+@token_auth.error_handler
+def auth_error():
+    return unauthorized('token过期或者不存在')

api/auth_token.py

@@ -13,41 +13,21 @@ def enum_to_value(data):
             new_data = data
         return new_data
 
-    @staticmethod
-    def enum_to_name(data):
-        if not data:
-            return None
-        try:
-            new_data = data.name
-        except Exception:
-            new_data = data
-        return new_data
-
-    '''
+    """
     :param
       enum_type: show enum name or value
       extra_kw : extra property value
-      extra_dict: extra dict 
+      extra_dict: extra dict
       remove_key: del dict key
-    @:return 
+    @:return
       return new dict
-    '''
+    """
 
-    def to_dict(self, enum_type='name', extra_kw=None, extra_dict=None, remove_key=list()):
-        model_field = [v for v in self.__dict__.keys() if not v.startswith('_') and v not in remove_key]
+    def to_dict(self, extra_dict=None, remove_key=None):
+        model_field = [v for v in self.__dict__.keys() if not v.startswith('_') and v not in (remove_key or [])]
         result = dict()
         for info in model_field:
-            if enum_type == 'name':
-                result[info] = self.enum_to_name(getattr(self, info))
-            else:
-                result[info] = self.enum_to_value(getattr(self, info))
-
-        if extra_kw and isinstance(extra_kw, list):
-            for info in extra_kw:
-                if enum_type == 'name':
-                    result[info] = self.enum_to_name(getattr(self, info))
-                else:
-                    result[info] = self.enum_to_value(getattr(self, info))
+            result[info] = self.enum_to_value(getattr(self, info))
 
         if extra_dict and isinstance(extra_dict, dict):
             for k, v in extra_dict.items():

api/base_model.py

@@ -0,0 +1,23 @@
+from flask import jsonify
+
+
+class ValidationError(ValueError):
+    pass
+
+
+def bad_request(message):
+    response = jsonify({'error': 'bad request', 'message': message})
+    response.status_code = 400
+    return response
+
+
+def unauthorized(message):
+    response = jsonify({'error': 'unauthorized', 'message': message})
+    response.status_code = 401
+    return response
+
+
+def forbidden(message):
+    response = jsonify({'error': 'forbidden', 'message': message})
+    response.status_code = 403
+    return response

api/errors.py

@@ -1,6 +1,43 @@
+from werkzeug.security import generate_password_hash, check_password_hash
+from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
+from flask import current_app
+
 from .. import db
 
 
 class User(db.Model):
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(32))
+    username = db.Column(db.String(32))
+    _password = db.Column(db.String(128))
+
+    token = db.Column(db.String(128))
+
+    @property
+    def test(self):
+        return 'id:{}'.format(self.id)
+
+    @property
+    def password(self):
+        raise AttributeError('password not readable')
+
+    @password.setter
+    def password(self, password):
+        self._password = generate_password_hash(password)
+
+    def verify_password(self, password):
+        return check_password_hash(self._password, password)
+
+    def generate_auth_token(self, expiration=3600 * 8):
+        s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration)
+
+        return s.dumps({'id': self.id})
+
+    @staticmethod
+    def verify_auth_token(token):
+        s = Serializer(current_app.config['SECRET_KEY'])
+
+        try:
+            data = s.loads(token)
+        except:
+            return None
+        return User.query.get(data['id'])

api/models/user.py

@@ -0,0 +1,23 @@
+from flask import Blueprint
+from api.app import api
+from api.auth_token import token_auth
+from api.errors import *
+
+from .resources.users import User
+
+api_user = Blueprint('users', __name__)
+
+api.add_resource(User, '/user')
+
+api.init_app(api_user)
+
+
+@api_user.before_request
+@token_auth.login_required
+def before_request():
+    pass
+
+
+@api_user.errorhandler(ValidationError)
+def validation_error(e):
+    return bad_request(e.args[0])