separated api

Author: msnodeve

app/__init__.py

@@ -8,7 +8,7 @@
 from sqlalchemy.sql import text
 from flask_marshmallow import Marshmallow
 from app.api.database import DB
-from app.users.views import API
+from app.api import  REST_API
 
 SQLALCHEMY_DATABASE_URI = \
     ("mysql+pymysql://{USER}:{PASSWORD}@{ADDR}:{PORT}/{NAME}?charset=utf8")
@@ -17,8 +17,6 @@
 def create_app() -> (Flask):
     """ create_app() 함수를 호출해 앱을 초기화 """
 
-
-
     """ app config part """
     # 나중에 config는 다 빼야 할 것 같다.
     app = Flask(__name__)
@@ -33,7 +31,7 @@ def create_app() -> (Flask):
     app.config['SQLALCHEMY_ECHO'] = True
     app.config['DEBUG'] = True
     DB.init_app(app)
-    API.init_app(app)
+    REST_API.init_app(app)
     MA.init_app(app)
 
     """ return part """

app/api/__init__.py

@@ -1,7 +1,8 @@
 from flask_restplus import Api
+from app.users.views import API as users_api
+from app.posts.views import API as posts_api
 
-API = Api(title='Board API',
-        version='1.0',
-        description="Board REST API"
-        # All API metadatas
-    )
+REST_API = Api()
+
+REST_API.add_namespace(users_api, '/users')
+REST_API.add_namespace(posts_api, '/posts')

app/posts/__init__.py

@@ -0,0 +1,24 @@
+from app.api.database import DB, CRUD
+from marshmallow import Schema, fields
+from flask_sqlalchemy import SQLAlchemy
+from marshmallow import validate
+from sqlalchemy.sql import text
+from app.users.models import Users, UsersSchema
+
+class Post(DB.Model):
+    __tablename__ = 'posts'
+    __table_args__ = {'mysql_collate': 'utf8_general_ci'}
+
+    id = DB.Column(DB.Integer, primary_key=True)
+    name = DB.Column(DB.String(255), nullable=False)
+    author_id = DB.Column(DB.Integer, DB.ForeignKey(Users.id))
+    author = DB.relationship("Users", uselist=False)
+
+    def __init__(self, name: str, author_id: int):
+        self.name = name
+        self.author_id = author_id
+
+class PostSchema(Schema):
+    id = fields.Integer()
+    name = fields.Str()
+    author = fields.Nested(UsersSchema)

app/posts/models.py

@@ -0,0 +1,57 @@
+from http import HTTPStatus
+from flask import jsonify
+from flask import make_response
+from app.users.models import Users, UsersSchema
+from sqlalchemy.exc import SQLAlchemyError
+from flask_restplus import Api, Namespace, fields, reqparse, Resource
+from app.constants import STATUS_CODE
+from app.constants import GET, POST, PATCH, DELETE
+from app.posts.models import Post, PostSchema
+from app.api.database import DB
+
+API = Namespace('Posts',description="Post's REST API")
+
+POSTS_SCHEMA = PostSchema()
+
+POST_FIELDS = API.model('Post', {
+    'name': fields.String,
+    'author_id': fields.Integer,
+})
+
+@API.route('/posts')
+class Posts(Resource):
+    parser = reqparse.RequestParser()
+    parser.add_argument('name', required=True, type=str, help="post's name", location='json')
+    parser.add_argument('author_id', required=True, type=int, help="post's author", location='json')
+
+    @API.expect(POST_FIELDS)
+    def post(self):
+        args_ = self.parser.parse_args()
+        post = Post(name=args_['name'], author_id=args_['author_id'])
+        try:
+            DB.session.add(post)
+            DB.session.commit()
+            body = jsonify({"posts": POSTS_SCHEMA.dump(post).data})
+            code = HTTPStatus.OK
+        except SQLAlchemyError as err:
+            DB.session.rollback()
+            message = str(err)
+            body = jsonify({"message": message})
+            code = HTTPStatus.INTERNAL_SERVER_ERROR
+        return make_response(body, code.value)
+
+@API.route('/post/<int:seqno>')
+class PostItem(Resource):
+    def get(self, seqno):
+        try:
+            post_item = DB.session.query(Post).outerjoin(Users, Users.id==Post.author_id).filter(Post.id==seqno).first()
+            body = jsonify({"post":POSTS_SCHEMA.dump(post_item).data})
+            if post_item:
+                code = HTTPStatus.OK
+            else:
+                code = HTTPStatus.NOT_FOUND
+        except SQLAlchemyError as err:
+            message = str(err)
+            body = jsonify({"message": message})
+            code = HTTPStatus.INTERNAL_SERVER_ERROR
+        return make_response(body, code.value)

app/posts/views.py

@@ -1,4 +1,4 @@
-from app.api.database import DB, CRUD
+from app.api.database import DB
 from marshmallow import Schema, fields
 from flask_sqlalchemy import SQLAlchemy
 from marshmallow import validate
@@ -40,23 +40,3 @@ def get_top_level_links(self, data, many):
     class Meta:
         type_ = 'users'
         strict = True
-
-
-
-class Post(DB.Model):
-    __tablename__ = 'posts'
-    __table_args__ = {'mysql_collate': 'utf8_general_ci'}
-
-    id = DB.Column(DB.Integer, primary_key=True)
-    name = DB.Column(DB.String(255), nullable=False)
-    author_id = DB.Column(DB.Integer, DB.ForeignKey(Users.id))
-    author = DB.relationship("Users", uselist=False)
-
-    def __init__(self, name: str, author_id: int):
-        self.name = name
-        self.author_id = author_id
-
-class PostSchema(Schema):
-    id = fields.Integer()
-    name = fields.Str()
-    author = fields.Nested(UsersSchema)

app/users/models.py

@@ -6,28 +6,11 @@
 from flask_restplus import Api, Namespace, fields, reqparse, Resource
 from app.constants import STATUS_CODE
 from app.constants import GET, POST, PATCH, DELETE
-from app.users.models import Post, PostSchema
 from app.api.database import DB
 
-API = Api(title='Board API',
-        version='1.0',
-        description="Board REST API"
-        # All API metadatas
-    )
-
-SCHEMA = UsersSchema()
-post_schema = PostSchema()
-
-USER_FIELDS = API.model('Users', {
-    'name': fields.String,
-    'email': fields.String,
-    'password': fields.String
-})
-POST_FIELDS = API.model('Post', {
-    'name': fields.String,
-    'author_id': fields.Integer,
-})
+API = Namespace('Users',description="User's REST API")
 
+USERS_SCHEMA = UsersSchema()
 
 @API.route('/users/<int:user_id>')
 @API.param('user_id', 'The user identifier')
@@ -37,25 +20,31 @@ class UserItem(Resource):
     parser.add_argument('email', required=True, type=str, help="user's email", location='json')
     parser.add_argument('password', required=True, type=str, help="password", location='json')
 
+    user_field = API.model('Users', {
+        'name': fields.String,
+        'email': fields.String,
+        'password': fields.String
+    })
+
     @API.doc(responses=GET)
     def get(self, user_id):
         user = Users.query.get_or_404(user_id)
-        user = SCHEMA.dump(user).data
+        user = USERS_SCHEMA.dump(user).data
         return user
 
-    @API.expect(USER_FIELDS)
+    @API.expect(user_field)
     @API.doc(responses=PATCH)
     def patch(self, user_id):
         args = self.parser.parse_args()
         user = Users.query.get_or_404(user_id)
-        response = user.update(args, SCHEMA)
+        response = user.update(args, USERS_SCHEMA)
         return response
 
     @API.doc(responses=DELETE)
     def delete(self, user_id):
         #import pdb; pdb.set_trace()
         user = Users.query.get_or_404(user_id)
-        response = user.delete(user, SCHEMA)
+        response = user.delete(user, USERS_SCHEMA)
         return response
 
 
@@ -66,19 +55,25 @@ class UsersList(Resource):
     parser.add_argument('email', required=True, type=str, help="user's email", location='json')
     parser.add_argument('password', required=True, type=str, help="password", location='json')
 
+    user_field = API.model('Users', {
+        'name': fields.String,
+        'email': fields.String,
+        'password': fields.String
+    })
+
     def get(self):
         users_query = Users.query.all()
-        results = SCHEMA.dump(users_query, many=True).data
+        results = USERS_SCHEMA.dump(users_query, many=True).data
         return results
 
-    @API.expect(USER_FIELDS)
+    @API.expect(user_field)
     def post(self):
         args = self.parser.parse_args()
         user = Users(args['name'], args['email'], args['password'])
         try:
             DB.session.add(user)
             DB.session.commit()
-            body = jsonify({"users": SCHEMA.dump(user).data})
+            body = jsonify({"users": USERS_SCHEMA.dump(user).data})
             code = HTTPStatus.OK
         except SQLAlchemyError as err:
             DB.session.rollback()
@@ -87,52 +82,30 @@ def post(self):
             code = HTTPStatus.INTERNAL_SERVER_ERROR
         return make_response(body, code.value)
 
-@API.route('/posts')
-class Posts(Resource):
+@API.route('/users/auth')
+class GetUser(Resource):
     parser = reqparse.RequestParser()
-    parser.add_argument('name', required=True, type=str, help="post's name", location='json')
-    parser.add_argument('author_id', required=True, type=int, help="post's author", location='json')
+    parser.add_argument('name', required=True, type=str, help="user's name", location='json')
+    parser.add_argument('password', required=True, type=str, help="user's password", location='json')
 
-    @API.expect(POST_FIELDS)
-    def post(self):
-        args_ = self.parser.parse_args()
-        post = Post(name=args_['name'], author_id=args_['author_id'])
-        try:
-            DB.session.add(post)
-            DB.session.commit()
-            body = jsonify({"posts": post_schema.dump(post).data})
-            code = HTTPStatus.OK
-        except SQLAlchemyError as err:
-            DB.session.rollback()
-            message = str(err)
-            body = jsonify({"message": message})
-            code = HTTPStatus.INTERNAL_SERVER_ERROR
-        return make_response(body, code.value)
+    user_field = API.model('Auth', {
+        'name': fields.String,
+        'password': fields.String
+    })
 
-@API.route('/post/<int:seqno>')
-class PostItem(Resource):
-    def get(self, seqno):
+    @API.expect(user_field)
+    def post(self):
+        args = self.parser.parse_args()
         try:
-            post_item = DB.session.query(Post).outerjoin(Users, Users.id==Post.author_id).filter(Post.id==seqno).first()
-            body = jsonify({"post":post_schema.dump(post_item).data})
-            if post_item:
+            user = Users.query.filter(Users.name == args['name'] and Users.password == args['password']).first()
+            body = jsonify({"user" : USERS_SCHEMA.dump(user).data})
+            if user:
                 code = HTTPStatus.OK
             else:
                 code = HTTPStatus.NOT_FOUND
         except SQLAlchemyError as err:
             message = str(err)
-            body = jsonify({"message": message})
+            body = jsonify({"message" : message})
             code = HTTPStatus.INTERNAL_SERVER_ERROR
         return make_response(body, code.value)
 
-@API.route('/userLogin')
-class GetUser(Resource):
-    parser = reqparse.RequestParser()
-    parser.add_argument('name', required=True, type=str, help="user's name", location='json')
-    parser.add_argument('password', required=True, type=str, help="user's password", location='json')
-
-    @API.expect(USER_FIELDS)
-    def post(self):
-        args = self.parser.parse_args()
-        user = Users.query.filter(Users.name == args['name']).first()
-        import pdb; pdb.set_trace()