del fastapi-users

server/main-server/src/database/db.py

@@ -1,40 +1,78 @@
-from collections.abc import AsyncGenerator
-from fastapi import Depends
-from fastapi_users.db import SQLAlchemyUserDatabase
-from fastapi_users.jwt import SecretType
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+import asyncpg
+from email_validator import EmailNotValidError, validate_email
+from pydantic import EmailStr
 
-from src.auth.user_manager import UserManager
-from src.database.user import User, Base
+from src.database.user import UserLogin, User
 
 
 class Database:
     def __init__(
             self,
+            admin_name: str,
+            admin_password: str,
             db_user: str,
             db_pass: str,
             db_host: str,
-            db_port: int,
-            db_name: str,
-            secret: SecretType
+            db_name: str
     ):
-        self.DATABASE_URL = f'postgresql+asyncpg://{db_user}:{db_pass}@{db_host}:{db_port}/{db_name}'
-        self.engine = create_async_engine(self.DATABASE_URL)
-        self.async_session_maker = async_sessionmaker(self.engine, expire_on_commit=False)
-        self.secret = secret
+        self.admin_name = admin_name
+        self.admin_password = admin_password
+        self.db_user = db_user
+        self.db_pass = db_pass
+        self.db_host = db_host
+        self.db_name = db_name
 
-    async def create_db_and_tables(self):
-        async with self.engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
+    async def connect(self):
+        try:
+            self.conn =await asyncpg.create_pool(
+                user=self.db_user,
+                password=self.db_pass,
+                database=self.db_name,
+                host=self.db_host
+            )
+        except Exception as e:
+            return e
+
+    async def disconnect(self):
+        await self.conn.close()
+
+    async def init(self):
+        try:
+            await self.conn.execute(
+                '''
+                CREATE TABLE IF NOT EXISTS users (
+                    username TEXT NOT NULL PRIMARY KEY UNIQUE, 
+                    password TEXT NOT NULL, 
+                    email TEXT NOT NULL, 
+                    role TEXT NOT NULL,
+                    out_vpn_access BOOL NOT NULL
+                )
+                '''
+            )
+            await self.conn.fetch(
+                '''
+                INSERT INTO users (username, password, email, role, out_vpn_access)
+                SELECT $1, $2, 'admin@admin.admin', 'Admin', true
+                WHERE NOT EXISTS (SELECT 1 FROM users WHERE username = $1)
+                ''',
+                self.admin_name,
+                self.admin_password
+            )
+        except Exception as e:
+            return e
 
 
-    async def get_async_session(self) -> AsyncGenerator[AsyncSession, None]:
-        async with self.async_session_maker() as session:
-            yield session
+    async def get_user(self, username: str):
+        fetch = await self.conn.fetchrow('SELECT * FROM users WHERE username = $1', username)
+
+        if fetch is None:
+            return None
+
+        n = list()
+
+        for i in fetch.values():
+            n.append(i)
+
+        return n
 
 
-    async def get_user_db(self, session: AsyncSession = Depends(get_async_session)):
-        yield SQLAlchemyUserDatabase(session, User)
-
-    async def get_user_manager(self, user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
-        yield UserManager(self.secret, user_db)