feat: add Models+Schema and User Controller

Controllers/User.py

@@ -1,8 +1,11 @@
 from flask import request
 from Models.User import User
+from Models.Role import Role
+from Models.Tenant import Tenant
 from Models.Schema import user_schema, users_schema
 from flask_restful import Resource, abort
 from app import db
+from datetime import datetime
 from werkzeug.security import generate_password_hash
 from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_required, JWTManager, current_user
 
@@ -14,10 +17,22 @@ class UserListResource(Resource):
 
     @jwt_required()
     def post(self):
+        tenants_array= []
+        for tenant_id in request.json['tenants']:
+            tenants_array.append(Tenant.query.filter_by(id=tenant_id).first())
+        roles_array= []
+        for role_id in request.json['roles']:
+            roles_array.append(Role.query.filter_by(id=role_id).first())
         new_user = User(
-            name=request.json['name'],
+            firstname=request.json['firstname'],
+            lastname=request.json['lastname'],
+            username=request.json['username'],
             email=request.json['email'],
-            password=generate_password_hash(request.json['password'])
+            password=generate_password_hash(request.json['password']),
+            tenants=tenants_array,
+            roles=roles_array,
+            creation=datetime.now(),
+            update=datetime.now()
         )
         db.session.add(new_user)
         db.session.commit()
@@ -34,9 +49,22 @@ class UserResource(Resource):
     def put(self, user_id):
         user = User.query.get_or_404(user_id)
 
-        user.name = request.json['name']
+        tenants_array= []
+        for tenant_id in request.json['tenants']:
+            tenants_array.append(Tenant.query.filter_by(id=tenant_id).first())
+        roles_array= []
+        for role_id in request.json['roles']:
+            roles_array.append(Role.query.filter_by(id=role_id).first())
+
+        user.firstname=request.json['firstname']
+        user.lastname=request.json['lastname']
+        user.username=request.json['username']
         user.email=request.json['email']
         user.password=generate_password_hash(request.json['password'])
+        user.tenants=tenants_array
+        user.roles=roles_array
+        user.creation=datetime.now()
+        user.update=datetime.now()
 
         db.session.commit()
         return user_schema.dump(post)
@@ -45,12 +73,28 @@ class UserResource(Resource):
     def patch(self, user_id):
         user = User.query.get_or_404(user_id)
 
-        if 'name' in request.json:
+        if 'firstname' in request.json:
-            user.name = request.json['name']
+            user.firstname=request.json['firstname']
+        if 'lastname' in request.json:
+            user.lastname=request.json['lastname']
+        if 'username' in request.json:
+            user.username=request.json['username']
         if 'email' in request.json:
             user.email=request.json['email']
         if 'password' in request.json:
             user.password=generate_password_hash(request.json['password'])
+        if 'tenants' in request.json:
+            tenants_array= []
+            for tenant_id in request.json['tenants']:
+                tenants_array.append(Tenant.query.filter_by(id=tenant_id).first())
+            user.tenants=tenants_array
+        if 'roles' in request.json:
+            roles_array= []
+            for role_id in request.json['roles']:
+                roles_array.append(Role.query.filter_by(id=role_id).first())
+            user.roles=roles_array
+        
+        user.update=datetime.now()
 
         db.session.commit()
         return user_schema.dump(post)

Models/IoC.py

@@ -0,0 +1,15 @@
+from app import db, ma
+from Models.Tenant import Tenant
+
+class IoC(db.Model):
+    __tablename__ = "iocs"
+    ioc_id = db.Column(db.Integer, primary_key=True)
+    value = db.Column(db.Text)
+    type = db.Column(db.String(50))
+    update = db.Column(db.DateTime)
+    creation = db.Column(db.DateTime)
+    tenant_id = db.Column(db.Integer, db.ForeignKey("tenants.tenant_id"))
+    tenant = db.relationship("Tenant", backref="iocs")
+
+    def __repr__(self):
+        return '<IoC %s>' % self.ioc_id

Models/Permission.py

@@ -0,0 +1,11 @@
+from app import db, ma
+
+
+class Permission(db.Model):
+    __tablename__ = "permissions"
+    permission_id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(50))
+
+
+    def __repr__(self):
+        return '<Permission %s>' % self.permission_id

Models/Post.py

@@ -1,23 +0,0 @@
-from app import db, ma
-from Models.User import User
-from Models.Tag import Tag
-
-tags_posts = db.Table('tags_posts_mapping',
-    db.Column('tag_id', db.Integer, db.ForeignKey('tags.id'), primary_key=True),
-    db.Column('post_id', db.Integer, db.ForeignKey('post.id'), primary_key=True)
-)
-
-
-class Post(db.Model):
-    __tablename__ = "post"
-    id = db.Column(db.Integer, primary_key=True)
-    title = db.Column(db.String(50))
-    content = db.Column(db.String(255))
-    tags = db.relationship('Tag', secondary=tags_posts, lazy='subquery',
-        backref=db.backref('posts', lazy=True))
-    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
-    author = db.relationship("User", backref="posts")
-
-    def __repr__(self):
-        return '<Post %s>' % self.title
-

Models/Role.py

@@ -0,0 +1,19 @@
+from app import db, ma
+from Models.Permission import Permission
+
+roles_permissions = db.Table('roles_permissions_mapping',
+    db.Column('role_id', db.Integer, db.ForeignKey('roles.role_id'), primary_key=True),
+    db.Column('permission_id', db.Integer, db.ForeignKey('permissions.permission_id'), primary_key=True)
+)
+
+class Role(db.Model):
+    __tablename__ = "roles"
+    role_id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(50))
+    tenant_id = db.Column(db.Integer, db.ForeignKey("tenants.tenant_id"))
+    tenant = db.relationship("Tenant", backref="roles")
+    permissions = db.relationship('Permission', secondary=roles_permissions, lazy='subquery',
+        backref=db.backref('roles', lazy=True))
+
+    def __repr__(self):
+        return '<Role %s>' % self.role_id

Models/Schema.py

@@ -1,7 +1,11 @@
 from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
 from Models.User import User
-from Models.Post import Post
+from Models.Ticket import Ticket
-from Models.Tag import Tag
+from Models.Task import Task
+from Models.IoC import IoC
+from Models.Tenant import Tenant
+from Models.Role import Role
+from Models.Permission import Permission
 
 class UserSchema(SQLAlchemyAutoSchema):
     class Meta:
@@ -11,23 +15,59 @@ class UserSchema(SQLAlchemyAutoSchema):
         include_relationships = True
         load_instance = True
 
-class PostSchema(SQLAlchemyAutoSchema):
+class TicketSchema(SQLAlchemyAutoSchema):
     class Meta:
-        model= Post
+        model= Ticket
         include_fk = True
         include_relationships = True
         load_instance = True
 
-class TagSchema(SQLAlchemyAutoSchema):
+class TaskSchema(SQLAlchemyAutoSchema):
     class Meta:
-        model= Tag
+        model= Task
+        include_fk = True
+        include_relationships = True
+        load_instance = True
+
+class IoCSchema(SQLAlchemyAutoSchema):
+    class Meta:
+        model= IoC
+        include_fk = True
+        include_relationships = True
+        load_instance = True
+
+class TenantSchema(SQLAlchemyAutoSchema):
+    class Meta:
+        model= Tenant
+        include_fk = True
+        include_relationships = True
+        load_instance = True
+
+class RoleSchema(SQLAlchemyAutoSchema):
+    class Meta:
+        model= Role
+        include_fk = True
+        include_relationships = True
+        load_instance = True
+
+class PermissionSchema(SQLAlchemyAutoSchema):
+    class Meta:
+        model= Permission
         include_fk = True
         include_relationships = True
         load_instance = True
 
 user_schema = UserSchema()
 users_schema = UserSchema(many=True)
-post_schema = PostSchema()
+ticket_schema = TicketSchema()
-posts_schema = PostSchema(many=True)
+tickets_schema = TicketSchema(many=True)
-tag_schema = TagSchema()
+task_schema = TaskSchema()
-tags_schema = TagSchema(many=True)
+tasks_schema = TaskSchema(many=True)
+ioc_schema = IoCSchema()
+iocs_schema = IoCSchema(many=True)
+tenant_schema = TenantSchema()
+tenants_schema = TenantSchema(many=True)
+role_schema = RoleSchema()
+roles_schema = RoleSchema(many=True)
+permission_schema = PermissionSchema()
+permissions_schema = PermissionSchema(many=True)

Models/Tag.py

@@ -1,12 +0,0 @@
-from app import db, ma
-
-class Tag(db.Model):
-    __tablename__ = "tags"
-    id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(50))
-
-
-    def __repr__(self):
-        return '<Tag %s>' % self.name
-
-

Models/Task.py

@@ -0,0 +1,18 @@
+from app import db, ma
+from Models.Tenant import Tenant
+from Models.Ticket import Ticket
+
+class Task(db.Model):
+    __tablename__ = "tasks"
+    task_id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.Text)
+    priority = db.Column(db.String(50))
+    user_id = db.Column(db.Integer, db.ForeignKey("users.user_id"))
+    user = db.relationship("User", backref="tasks")
+    tenant_id = db.Column(db.Integer, db.ForeignKey("tenants.tenant_id"))
+    tenant = db.relationship("Tenant", backref="tasks")
+    ticket_id = db.Column(db.Integer, db.ForeignKey("tickets.ticket_id"))
+    ticket = db.relationship("Ticket", backref="tasks")
+
+    def __repr__(self):
+        return '<Task %s>' % self.task_id

Models/Tenant.py

@@ -0,0 +1,9 @@
+from app import db, ma
+
+class Tenant(db.Model):
+    __tablename__ = "tenants"
+    tenant_id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(50))
+
+    def __repr__(self):
+        return '<Tenant %s>' % self.name

Models/Ticket.py

@@ -0,0 +1,36 @@
+from app import db, ma
+from Models.User import User
+from Models.IoC import IoC
+from Models.Tenant import Tenant
+
+tickets_iocs = db.Table('tickets_iocs_mapping',
+    db.Column('ticket_id', db.Integer, db.ForeignKey('tickets.ticket_id'), primary_key=True),
+    db.Column('ioc_id', db.Integer, db.ForeignKey('iocs.ioc_id'), primary_key=True)
+)
+
+tickets_users = db.Table('tickets_users_mapping',
+    db.Column('ticket_id', db.Integer, db.ForeignKey('tickets.ticket_id'), primary_key=True),
+    db.Column('user_id', db.Integer, db.ForeignKey('users.user_id'), primary_key=True)
+)
+
+
+class Ticket(db.Model):
+    __tablename__ = "tickets"
+    ticket_id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String(50))
+    priority = db.Column(db.String(50))
+    severity = db.Column(db.String(50))
+    description = db.Column(db.Text)
+    update = db.Column(db.DateTime)
+    creation = db.Column(db.DateTime)
+    status = db.Column(db.String(50))
+    iocs = db.relationship('IoC', secondary=tickets_iocs, lazy='subquery',
+        backref=db.backref('tickets', lazy=True))
+    users = db.relationship('User', secondary=tickets_users, lazy='subquery',
+        backref=db.backref('tickets', lazy=True))
+    tenant_id = db.Column(db.Integer, db.ForeignKey("tenants.tenant_id"))
+    tenant = db.relationship("Tenant", backref="tickets")
+
+    def __repr__(self):
+        return '<Ticket %s>' % self.title
+

Models/User.py

@@ -1,15 +1,35 @@
 from app import db, ma
 from werkzeug.security import check_password_hash
+from Models.Tenant import Tenant
+from Models.Role import Role
+
+tenants_users = db.Table('tenants_users_mapping',
+    db.Column('tenant_id', db.Integer, db.ForeignKey('tenants.tenant_id'), primary_key=True),
+    db.Column('user_id', db.Integer, db.ForeignKey('users.user_id'), primary_key=True)
+)
+
+roles_users = db.Table('roles_users_mapping',
+    db.Column('role_id', db.Integer, db.ForeignKey('roles.role_id'), primary_key=True),
+    db.Column('user_id', db.Integer, db.ForeignKey('users.user_id'), primary_key=True)
+)
 
 class User(db.Model):
-    __tablename__ = "user"
+    __tablename__ = "users"
-    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(50))
+    firstname = db.Column(db.String(50))
-    email = db.Column(db.String(255))
+    lastname = db.Column(db.String(50))
+    update = db.Column(db.DateTime)
+    creation = db.Column(db.DateTime)
+    username = db.Column(db.String(255), unique=True)
+    email = db.Column(db.String(255), unique=True)
     password = db.Column(db.String(255))
+    tenants = db.relationship('Tenant', secondary=tenants_users, lazy='subquery',
+        backref=db.backref('users', lazy=True))
+    roles = db.relationship('Role', secondary=roles_users, lazy='subquery',
+        backref=db.backref('users', lazy=True))
 
     def __repr__(self):
-        return '<User %s>' % self.name
+        return '<User %s>' % self.username
 
     def check_password(self, password):
         return check_password_hash(self.password, password)

app.py

@@ -16,18 +16,13 @@ ma = Marshmallow(app)
 api = Api(app)
 jwt = JWTManager(app)
 
-from Controllers.Post import PostListResource, PostResource
 from Controllers.User import UserListResource, UserResource
-from Controllers.Tag import TagListResource
 from Controllers.Login import Login, Refresh
 
 api.add_resource(UserListResource, '/v1/user')
 api.add_resource(UserResource, '/v1/user/<int:post_id>')
 api.add_resource(Login, '/v1/login')
 api.add_resource(Refresh, '/v1/refresh')
-api.add_resource(PostListResource, '/v1/posts')
-api.add_resource(PostResource, '/v1/posts/<int:post_id>')
-api.add_resource(TagListResource, '/v1/tags')
 db.create_all()