Initial commit

2026-11-05 08:28:15 +00:00
commit 08582a4f70
65 changed files with 1886 additions and 0 deletions
@@ -0,0 +1,118 @@
+from backend.code.enums.errors_enum import ErrorTypeEnum
+from backend.code.modules.database.database_sqlite import DatabaseSqliteModule
+from backend.code.modules.users.repository import UserRepository
+from backend.code.modules.accounts.repository import AccountRepository
+from backend.code.models.responses.user_detail import UserDetailResponse
+
+class UserController():
+    def __init__(self):
+        database = DatabaseSqliteModule()
+        self.repo = UserRepository(database)
+        self.account_repo = AccountRepository(database)
+
+    def ListUsers(self, params: str = None):
+        result = []
+
+        # Process filters
+        if params is not None:
+            params = self._OnProcessParams(params)
+
+        users = self.repo.FilterUsers(params)
+        if len(users) == 0:
+            return result
+
+        for _user in users:
+            user = UserDetailResponse(
+                Id = _user[0],
+                Name = _user[1],
+                Surnames = _user[2],
+                Email = _user[3],
+                Username = _user[4],
+                Locked = _user[5],
+                Active = _user[6]
+            )
+            result.append(user)
+            
+        
+        return result
+        
+    def SelectUser(self, id: int):
+        user = self.repo.SelectUserById(id)
+        if user is None:
+            return
+
+        return UserDetailResponse(
+            Id = user[0],
+            Name = user[1],
+            Surnames = user[2],
+            Email = user[3],
+            Username = user[4],
+            Locked = user[5],
+            Active = user[6]
+        )
+    
+    def RegisterUser(self, name: str, surnames: str, email: str, username: str = None, locked: bool = False, active: bool = True):
+        create_account = (username is not None)
+
+        # Check not exists
+        user_exists = self.repo.FilterUsers({'email': email})
+        if len(user_exists) > 0:
+            return ErrorTypeEnum.USER_EMAIL_EXISTS
+
+        if create_account:
+            account_exists = self.account_repo.SelectByUsername(username)
+            if account_exists is not None:
+                return ErrorTypeEnum.USER_ACCOUNT_EXISTS
+
+        # Register
+        user_id = self.repo.InsertUser(name, surnames, email)
+        if user_id is None:
+            return
+
+        if create_account:
+            account_id = self.account_repo.InsertAccount(user_id, username, locked, active)
+            if account_id is None:
+                return
+        
+        return UserDetailResponse(
+            Id = user_id,
+            Name = name,
+            Surnames = surnames,
+            Email = email,
+            Username = username,
+            Locked = locked,
+            Active = active
+        )
+        
+    def EditUser(self, id: int, name: str, surnames: str, email: str):
+        exists = self.repo.SelectUserById(id)
+        if exists is None:
+            return ErrorTypeEnum.USER_ID_NOT_EXISTS
+
+        edited = self.repo.UpdateUser(id, name, surnames, email)
+        if edited == 0:
+            return
+
+        return True
+
+    def DeleteUser(self, id: int):
+        exists = self.repo.SelectUserById(id)
+        if exists is None:
+            return ErrorTypeEnum.USER_ID_NOT_EXISTS
+
+        deleted = self.repo.DeleteUser(id)
+        if deleted == 0:
+            return
+
+        return True
+
+    #region Utilities
+    def _OnProcessParams(self, params: str):
+        result = {}
+        params = params.strip()
+        params = params.split(',')
+        for param in params:
+            field,value=param.split('=')
+            result[field.lower()]=value
+        return result
+    #endregion
@@ -0,0 +1,76 @@
+from backend.code.modules.database.database import DatabaseModule
+
+class UserRepository():
+    def __init__(self, repo: DatabaseModule):
+        self.conn = repo.conn
+        self.cursor = repo.cursor
+
+    def FilterUsers(self, filters: dict = None):
+        params = list()
+
+        sql = '''
+        SELECT u.*, a.username, a.locked, a.active
+        FROM users u
+        LEFT JOIN user_accounts a ON a.user_id = u.id
+        WHERE 1=1
+        '''
+
+        if filters is not None:
+            if 'name' in filters:
+                sql = sql + " AND u.name LIKE ?"
+                params.append(filters['name'])
+
+            if 'surnames' in filters:
+                sql = sql + " AND u.surnames LIKE ?"
+                params.append(filters['surnames'])
+
+            if 'email' in filters:
+                sql = sql + " AND u.email LIKE ?"
+                params.append(filters['email'])
+
+            if 'username' in filters:
+                sql = sql + " AND a.username LIKE ?"
+                params.append(filters['username'])
+
+        # print(sql)
+
+        self.cursor.execute(sql, params)
+        return self.cursor.fetchall()
+
+    def SelectUserById(self, id: int):
+        sql = '''
+        SELECT u.*, a.username, a.locked, a.active
+        FROM users u
+        LEFT JOIN user_accounts a ON a.user_id = u.id
+        WHERE u.id = ?
+        '''
+        self.cursor.execute(sql, [id])
+        return self.cursor.fetchone()
+    
+    def InsertUser(self, name: str, surnames: str, email: str):
+        sql = '''
+        INSERT INTO users(name, surnames, email)
+        VALUES(?, ?, ?)
+        '''
+        self.cursor.execute(sql, [name, surnames, email])
+        self.conn.commit()
+        return self.cursor.lastrowid
+
+    def UpdateUser(self, id: int, name: str, surnames: str, email: str):
+        sql = '''
+        UPDATE users
+        SET name = ?, surnames = ?, email = ?
+        WHERE id = ?
+        '''
+        self.cursor.execute(sql, [name, surnames, email, id])
+        self.conn.commit()
+        return self.cursor.rowcount
+
+    def DeleteUser(self, id: int):
+        sql = '''
+        DELETE FROM users
+        WHERE id = ?
+        '''
+        self.cursor.execute(sql, [id])
+        self.conn.commit()
+        return self.cursor.rowcount
@@ -0,0 +1,60 @@
+from fastapi import Query, APIRouter, status, Depends, Response, HTTPException
+from backend.code.modules.users.controller import UserController
+
+from backend.code.models.requests.user_register import UserRegisterRequest
+from backend.code.models.requests.user_edit import UserEditRequest
+from backend.code.models.responses.user_detail import UserDetailResponse
+from backend.code.models.responses.user_created import UserCreatedResponse
+
+routes = APIRouter(prefix="/users", tags=["User"])
+controller = UserController()
+
+@routes.get('', status_code = status.HTTP_200_OK, response_model = list[UserDetailResponse])
+def ListUsers(params: str | None = Query(default = None, alias = "query")):
+    users = controller.ListUsers(params)
+    if users is None:
+        raise HTTPException(status_code = status.HTTP_400_BAD_REQUEST)
+
+    if len(users) == 0:
+        return Response(status_code = status.HTTP_204_NO_CONTENT)
+    
+    return users
+
+@routes.get('/{id}', status_code = status.HTTP_200_OK, response_model = UserDetailResponse)
+def GetUser(id: int):
+    user = controller.SelectUser(id)
+    if user is None:
+        raise HTTPException(status_code = status.HTTP_404_NOT_FOUND)
+
+    return user
+
+@routes.post('', status_code = status.HTTP_201_CREATED, response_model = UserCreatedResponse)
+def RegisterUser(data: UserRegisterRequest):
+    created = controller.RegisterUser(data.Name, data.Surnames, data.Email, data.Username, data.Locked, data.Active)
+    if created is None:
+        raise HTTPException(status_code = status.HTTP_400_BAD_REQUEST)
+    
+    if created == -1:
+        raise HTTPException(status_code = status.HTTP_409_CONFLICT, detail = 'Email exists')
+    elif created == -2:
+        raise HTTPException(status_code = status.HTTP_409_CONFLICT, detail = 'Username exists')
+
+    return created
+
+@routes.put('/{id}', status_code = status.HTTP_204_NO_CONTENT)
+def EditUser(id: int, data: UserEditRequest):
+    edited = controller.EditUser(id, data.Name, data.Surnames, data.Email)
+    if edited is None:
+        raise HTTPException(status_code = status.HTTP_400_BAD_REQUEST)
+
+    if deleted == -3:
+        raise HTTPException(status_code = status.HTTP_404_NOT_FOUND)
+
+@routes.delete('/{id}', status_code = status.HTTP_204_NO_CONTENT)
+def DeleteUser(id: int):
+    deleted = controller.DeleteUser(id)
+    if deleted is None:
+        raise HTTPException(status_code = status.HTTP_400_BAD_REQUEST)
+
+    if deleted == -3:
+        raise HTTPException(status_code = status.HTTP_404_NOT_FOUND)