shaapi 0.1.0__py3-none-any.whl

shaapi/template/backend/crud/crud_user.py

@@ -0,0 +1,267 @@
+from fast_captcha import text_captcha
+from sqlalchemy import and_, desc, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql import Select
+
+from backend.models import User
+from backend.crud.crud_role import role_dao
+from backend.app.admin.schema.user import (
+    UserRegister,
+    UserUpdate
+)
+from backend.common.security.jwt import get_hash_password
+from backend.common.enums import Role as Role_enum
+from backend.utils.timezone import timezone
+from backend.crud.crud_base import CRUDBase
+
+
+class CRUDUser(CRUDBase[User]):
+    async def get(self, db: AsyncSession, admin_id: int) -> User | None:
+        """
+        Getting admin
+
+        :param db:
+        :param admin_id:
+        :return:
+        """
+        return await self.select_model(db, admin_id)
+    
+    async def get_by_x_id(self, db: AsyncSession, x_id: str, populates: list = []) -> User | None:
+        """
+        Get admin by email
+
+        :param db:
+        :param email:
+        :return:
+        """
+        return await self.select_model_by_column(db, x_id=x_id, populates=populates)
+
+    async def get_by_email(self, db: AsyncSession, email: str, populates: list = []) -> User | None:
+        """
+        Get admin by email
+
+        :param db:
+        :param email:
+        :return:
+        """
+        return await self.select_model_by_column(db, email=email, populates=populates)
+
+    async def get_by_phone(self, db: AsyncSession, phone: str) -> User | None:
+        """
+        Get admin by phone
+
+        :param db:
+        :param phone:
+        :return:
+        """
+        return await self.select_model_by_column(db, phone=phone, populates=['roles'])
+
+    async def get_by_pseudo(self, db: AsyncSession, pseudo: str) -> User | None:
+        """
+        Get admin by pseudo
+
+        :param db:
+        :param pseudo:
+        :return:
+        """
+        return await self.select_model_by_column(db, pseudo=pseudo, populates=['roles'])
+
+    async def update_login_time(self, db: AsyncSession, email: str) -> int:
+        """
+        Update login time
+
+        :param db:
+        :param email:
+        :return:
+        """
+        return await self.update_model_by_column(db, {'last_login_time': timezone.now()}, email=email)
+
+    async def create(self, db: AsyncSession, obj: UserRegister, *, social: bool = False) -> None:
+        """
+        Create User
+
+        :param db:
+        :param obj:
+        :param social: Social admins, adapted to oauth 2.0
+        :return:
+        """
+        if not social:
+            salt = text_captcha(5)
+            obj.password = get_hash_password(f'{obj.password}{salt}')
+            dict_obj = obj.model_dump()
+            dict_obj.update({'salt': salt})
+        else:
+            dict_obj = obj.model_dump()
+            dict_obj.update({'salt': None})
+    
+        new_admin = self.model(**dict_obj)
+        await db.add(db, new_admin)
+
+    async def add(self, db: AsyncSession, obj: UserRegister) -> User:
+        """
+        Add admin
+
+        :param db:
+        :param obj:
+        :return:
+        """
+        salt = text_captcha(5)
+        obj.password = get_hash_password(f'{obj.password}{salt}')
+        dict_obj = obj.model_dump(exclude={'roles'})
+        
+        dict_obj.update({'salt': salt})
+
+        
+        new_admin = self.model(**dict_obj)
+
+        
+        role = await role_dao.get_by_name(db, Role_enum.ADMIN.value)
+        
+        role_list = []
+        if role is not None:
+            role_list.append(role)
+        new_admin.roles.extend(role_list)
+        db.add(new_admin)
+        await db.flush()
+        await db.refresh(new_admin)
+        return new_admin
+
+    async def update_admin_info(self, db: AsyncSession, input_admin: int, obj: UserUpdate) -> int:
+        """
+        Updating admin information
+
+        :param db:
+        :param input_admin:
+        :param obj:
+        :return:
+        """
+        return await self.update_model(db, input_admin, obj)
+
+    async def update_profile_image(self, db: AsyncSession, input_admin: int, profile_image: dict) -> int:
+        """
+        Update admin profile image
+
+        :param db:
+        :param input_admin:
+        :param avatar:
+        :return:
+        """
+        return await self.update_model(db, input_admin, {'profile_image': dict})
+
+    async def check_email(self, db: AsyncSession, email: str) -> User | None:
+        """
+        Check admin email
+
+        :param db:
+        :param email:
+        :return:
+        """
+        return await self.select_model_by_column(db, email=email)
+
+    async def reset_password(self, db: AsyncSession, pk: int, new_pwd: str) -> int:
+        """
+        Reset admin password
+
+        :param db:
+        :param pk:
+        :param new_pwd:
+        :return:
+        """
+        return await self.update_model(db, pk, {'password': new_pwd})
+
+    async def get_list(self, email: str = None, phone: str = None, status: bool = None, role: str | None = None) -> Select:
+        """
+        Get admin list
+
+        :param dept:
+        :param adminname:
+        :param phone:
+        :param status:
+        :return:
+        """
+        stmt = (
+            select(self.model)
+            .order_by(desc(self.model.join_time))
+        )
+        where_list = []
+        if email:
+            where_list.append(self.model.email.like(f'%{email}%'))
+        if phone:
+            where_list.append(self.model.phone.like(f'%{phone}%'))
+        if status is not None:
+            where_list.append(self.model.status == status)
+        if where_list:
+            stmt = stmt.where(and_(*where_list))
+        return stmt
+
+    async def get_status(self, db: AsyncSession, admin_id: int) -> int:
+        """
+        Get admin status 
+
+        :param db:
+        :param admin_id:
+        :return:
+        """
+        admin = await self.get(db, admin_id)
+        return admin.status
+
+    async def get_multi_login(self, db: AsyncSession, admin_id: int) -> bool:
+        """
+        Get admin multipoint login status
+
+        :param db:
+        :param admin_id:
+        :return:
+        """
+        admin = await self.get(db, admin_id)
+        return admin.is_multi_login
+
+    async def set_status(self, db: AsyncSession, admin_id: int, status: bool) -> int:
+        """
+        Set admin account status
+
+        :param db:
+        :param admin_id:
+        :param status:
+        :return:
+        """
+        return await self.update_model(db, admin_id, {'status': status})
+
+    async def set_multi_login(self, db: AsyncSession, admin_id: int, multi_login: bool) -> int:
+        """
+        Set multi login
+
+        :param db:
+        :param admin_id:
+        :param multi_login:
+        :return:
+        """
+        return await self.update_model(db, admin_id, {'is_multi_login': multi_login})
+
+    async def get_with_relation(self, db: AsyncSession, *, id: int = None, x_id: str = None, email: str = None, populates: list = []) -> User | None:
+        """
+        Get admin and (roles)
+
+        :param db:
+        :param admin_id:
+        :param email:
+        :return:
+        """
+        stmt = (
+            select(self.model)
+        )
+            
+        filters = []
+        if id:
+            filters.append(self.model.id == id)
+        if email:
+            filters.append(self.model.email == email)
+        if x_id:
+            filters.append(self.model.x_id == x_id)
+            
+        stmt = self.get_with_relationship(stmt, populates=populates)
+        admin = await db.execute(stmt.where(*filters))
+        return admin.scalars().first()
+
+
+user_dao: CRUDUser = CRUDUser(User)

shaapi/template/backend/database/db_postgres.py

@@ -0,0 +1,125 @@
+import sys
+
+from typing import Annotated, Generator
+from uuid import uuid4
+from sqlalchemy import MetaData, create_engine
+
+from fastapi import Depends
+from sqlalchemy import URL
+from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from collections.abc import AsyncGenerator
+from sqlalchemy import event
+
+
+from backend.common.log import log
+from backend.common.model import MappedBase
+from backend.core.conf import settings
+from sqlalchemy.orm import sessionmaker
+
+    
+SQLALCHEMY_DATABASE_URL = (
+    f"postgresql+asyncpg://{settings.POSTGRES_USER}:{settings.POSTGRES_PASSWORD}@{settings.POSTGRES_HOST}:"
+    f"{settings.POSTGRES_PORT}/{settings.POSTGRES_DATABASE}"
+)
+
+try:
+    engine = create_engine(
+        SQLALCHEMY_DATABASE_URL,
+        pool_pre_ping=True,
+        echo=False,
+        future=True,
+    )
+    session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+except Exception as e:
+    print(f"DB connection error. detail={e}")
+
+
+def create_engine_and_session(url: str | URL):
+    try:
+        # database engine
+        engine = create_async_engine(
+            url, echo=settings.POSTGRES_ECHO, future=True, pool_pre_ping=True
+        )
+        # log.success('Database Connection Successful')
+    except Exception as e:
+        log.error("❌ Database link failure {}", e)
+        sys.exit()
+    else:
+        db_session = async_sessionmaker(
+            bind=engine, autoflush=False, expire_on_commit=False
+        )
+        return engine, db_session
+
+
+async_engine, async_db_session = create_engine_and_session(SQLALCHEMY_DATABASE_URL)
+
+
+async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
+    """session generator"""
+    session = async_db_session()
+    try:
+        yield session
+    except Exception as se:
+        await session.rollback()
+        raise se
+    finally:
+        await session.close()
+
+
+# Session Annotated
+CurrentSession = Annotated[AsyncSession, Depends(get_async_db)]
+
+
+def get_db() -> Generator[Session, None, None]:
+    """
+    Create a database session when accessing from an endpoint, using Depend
+    If there are no errors, validate.
+    If there is an error, go back and close in all cases.
+    """
+
+    db = None
+    try:
+        db = session_factory()
+        yield db
+        db.commit()
+    except Exception:
+        if db:
+            db.rollback()
+    finally:
+        if db:
+            db.close()
+
+
+async def create_table():
+    """Creating Database Tables"""
+    async with async_engine.begin() as coon:
+        await coon.run_sync(MappedBase.metadata.create_all)
+
+
+def uuid4_str() -> str:
+    """Database Engine UUID Type Compatibility Solution"""
+    return str(uuid4())
+
+
+def drop_all_tables() -> None:
+    print("start: drop_all_tables")
+    """
+    Delete all tables, types, Roles, etc.
+    and return to initial state (development environment only)
+    """
+    if settings.ENVIRONMENT != "dev":
+        # Run only in local environnement
+        print("drop_all_table() should be run only in dev env.")
+        return
+
+    metadata = MetaData()
+    metadata.reflect(bind=engine)
+
+    for table_key in metadata.tables:
+        table = metadata.tables.get(table_key)
+        if table is not None:
+            print(f"Deleting {table_key} table")
+            metadata.drop_all(engine, [table], checkfirst=True)
+
+    print("end: drop_all_tables")

shaapi/template/backend/database/db_redis.py

@@ -0,0 +1,62 @@
+import sys
+
+from redis.asyncio import Redis
+from redis.exceptions import AuthenticationError, TimeoutError
+
+from backend.common.log import log
+from backend.core.conf import settings
+
+
+class RedisCli(Redis):
+    def __init__(self):
+        super(RedisCli, self).__init__(
+            host=settings.REDIS_HOST,
+            port=settings.REDIS_PORT,
+            # password=settings.REDIS_PASSWORD,
+            db=settings.REDIS_DATABASE,
+            socket_timeout=settings.REDIS_TIMEOUT,
+            decode_responses=True,   # Transcoding utf-8
+        )
+
+    async def open(self):
+        """
+        Trigger Initialization Connection
+
+        :return:
+        """
+        try:
+            await self.ping()
+        except TimeoutError:
+            log.error('❌ Database redis connection timeout')
+            sys.exit()
+        except AuthenticationError:
+            log.error('❌ Database redis connection authentication failed')
+            sys.exit()
+        except Exception as e:
+            log.error('❌ Database redis connection exception {}', e)
+            sys.exit()
+
+    async def delete_prefix(self, prefix: str, exclude: str | list = None):
+        """
+        Delete all keys with the specified prefix
+
+        :param prefix:
+        :param exclude:
+        :return:
+        """
+        keys = []
+        async for key in self.scan_iter(match=f'{prefix}*'):
+            if isinstance(exclude, str):
+                if key != exclude:
+                    keys.append(key)
+            elif isinstance(exclude, list):
+                if key not in exclude:
+                    keys.append(key)
+            else:
+                keys.append(key)
+        if keys:
+            await self.delete(*keys)
+
+
+# Create a redis client instance
+redis_client = RedisCli()

shaapi/template/backend/entrypoint-api.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+
+cd backend
+
+# Apply database migrations (idempotent: no-op if already up to date).
+# Migrations are authored explicitly with `shaapi makemigrations`, never
+# auto-generated at boot.
+alembic upgrade head
+
+# Live-reload in development (the source is bind-mounted by the dev compose).
+# In production (ENVIRONMENT=prod) the baked-in code is served without reload.
+RELOAD=""
+if [ "${ENVIRONMENT:-dev}" = "dev" ]; then
+  RELOAD="--reload"
+fi
+
+# Start the API server (exec => uvicorn becomes PID 1 and receives signals)
+exec uvicorn backend.main:app --host 0.0.0.0 --port 8000 $RELOAD

shaapi/template/backend/lang/en/app.py

@@ -0,0 +1,18 @@
+locale = {
+  "http_200": "Request successful",
+  "http_201": "Resource created successfully",
+  "http_202": "Request accepted but not yet completed",
+  "http_204": "Request successful but no content returned",
+  "http_400": "Bad request",
+  "http_401": "Unauthorized",
+  "http_403": "Forbidden",
+  "http_404": "Resource not found",
+  "http_410": "Resource permanently deleted",
+  "http_422": "Invalid request parameters",
+  "http_425": "Request cannot be processed due to server limitations",
+  "http_429": "Too many requests, server rate limit reached",
+  "http_500": "Internal server error",
+  "http_502": "Gateway error",
+  "http_503": "Service unavailable",
+  "http_504": "Gateway timeout"
+}

shaapi/template/backend/lang/en/auth.py

@@ -0,0 +1,10 @@
+locale = {
+  'incorrect_credential': 'Incorrect email or password',
+  'account_locked': 'This account has been locked out. Please contact the system administrator',
+  'successful': 'Login Successful',
+  'refresh_token_not_found': 'Refresh Token not found',
+  'invalid_refresh_token': 'Refresh Token is invalid',
+  'enpty_password': 'Empty password',
+  'exist': 'this account already exist',
+  'code_not_found': 'We can\'t proced this request, try again.',
+}

shaapi/template/backend/lang/fr/app.py

@@ -0,0 +1,18 @@
+locale = {
+  "http_200": "Requête réussie",
+  "http_201": "Ressource créée avec succès",
+  "http_202": "Requête acceptée mais pas encore terminée",
+  "http_204": "Requête réussie mais aucun contenu retourné",
+  "http_400": "Mauvaise requête",
+  "http_401": "Non autorisé",
+  "http_403": "Interdit",
+  "http_404": "Ressource non trouvée",
+  "http_410": "Ressource supprimée de façon permanente",
+  "http_422": "Paramètres de la requête non valides",
+  "http_425": "La requête ne peut pas être traitée en raison des limitations du serveur",
+  "http_429": "Trop de requêtes, limite de débit du serveur atteinte",
+  "http_500": "Erreur interne du serveur",
+  "http_502": "Erreur de passerelle",
+  "http_503": "Service indisponible",
+  "http_504": "Délai d'attente de la passerelle dépassé"
+}

shaapi/template/backend/lang/fr/auth.py

@@ -0,0 +1,10 @@
+locale = {
+  'incorrect_credential': 'Email ou mot de passe incorrect',
+  'account_locked': 'Ce compte a été verrouillé. Veuillez contacter l\'administrateur du système',
+  'successful': 'Connexion réussie',
+  'refresh_token_not_found': 'Le Jeton de rafraîchissement est introuvable, veuillez vous reconnecter',
+  'invalid_refresh_token': 'Le jeton de rafraîchissement est invalide',
+  'enpty_password': 'Mot de passe vide',
+  'exist': 'Ce compte existe déjà',
+  'code_not_found': 'Nous ne pouvons traiter cette demande veuillez réessayer plus tard.',
+}

shaapi/template/backend/main.py

@@ -0,0 +1,54 @@
+"""shaapi application entry point.
+
+The top-level FastAPI app is a thin parent that mounts the feature
+sub-applications (currently ``/admin``: auth, users, roles, RBAC...).
+Each sub-app owns its own middleware, lifespan and OpenAPI docs.
+"""
+import logging
+
+import uvicorn
+from fastapi import FastAPI
+
+from backend.core.conf import settings
+from backend.core.registrar import register_app, register_init
+from backend.app.api import admin_router
+
+# The parent app owns the lifespan (DB tables, Redis, rate limiter) because
+# Starlette does not run the lifespan of mounted sub-applications.
+app = FastAPI(
+    title=settings.FASTAPI_TITLE,
+    lifespan=register_init,
+    docs_url=None,
+    redoc_url=None,
+    openapi_url=None,
+)
+
+# Observability (opt-in). Enable with OBSERVABILITY_ENABLED=true and a valid
+# OTLP_GRPC_ENDPOINT. Kept out of the lean core so the app boots without the
+# OpenTelemetry/Prometheus stack installed.
+if settings.OBSERVABILITY_ENABLED and settings.OTLP_GRPC_ENDPOINT:
+    from backend.utils.prometheus import EndpointFilter, metrics, setting_otlp
+
+    setting_otlp(app, settings.APP_NAME, settings.OTLP_GRPC_ENDPOINT)
+    logging.getLogger("uvicorn.access").addFilter(EndpointFilter())
+    app.add_route("/metrics", metrics)
+
+
+@app.get("/health", tags=["health"])
+async def health() -> dict:
+    """Liveness probe."""
+    return {"status": "ok"}
+
+
+# Mount feature sub-applications
+app.mount("/admin", register_app(admin_router, "admin"))
+
+
+if __name__ == "__main__":
+    # Handy for IDE debugging. In Docker the entrypoint runs uvicorn directly.
+    uvicorn.run(
+        "backend.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=settings.ENVIRONMENT == "dev",
+    )

shaapi/template/backend/middleware/__init__.py

@@ -0,0 +1 @@
+

shaapi/template/backend/middleware/access_middleware.py

@@ -0,0 +1,19 @@
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+
+from backend.common.log import log
+from backend.utils.timezone import timezone
+
+
+class AccessMiddleware(BaseHTTPMiddleware):
+    """Request Log Middleware"""
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        start_time = timezone.now()
+        response = await call_next(request)
+        end_time = timezone.now()
+        log.info(
+            f'{request.client.host: <15} | {request.method: <8} | {response.status_code: <6} | '
+            f'{request.url.path} | {round((end_time - start_time).total_seconds(), 3) * 1000.0}ms'
+        )
+        return response

shaapi/template/backend/middleware/i18n_middleware.py

@@ -0,0 +1,19 @@
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+
+
+class I18nMiddleware(BaseHTTPMiddleware):
+    WHITE_LIST = ['en', 'fr']
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
+        # 1. headers 2. path 3. query string
+        locale = request.headers.get('locale', None) or \
+                 request.path_params.get('locale', None) or \
+                 request.query_params.get('locale', None) or \
+                 'fr'
+
+        if locale not in self.WHITE_LIST:
+            locale = 'fr'
+        request.state.locale = locale
+
+        return await call_next(request)