shaapi 0.1.0__py3-none-any.whl

shaapi/template/backend/common/cloud_storage/cloud_storage.py

@@ -0,0 +1,180 @@
+import io
+import json
+import re
+import uuid
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+
+import boto3
+
+# from google.cloud import storage
+from minio import Minio
+from minio.error import S3Error
+
+from backend.core.conf import settings
+
+
+
+class CloudStorage(ABC):
+    @abstractmethod
+    def upload_file(self, file_content: bytes, filename: str) -> Any:
+        pass
+
+    @abstractmethod
+    def delete_file(self, identifier: str) -> None:
+        pass
+
+
+# GCS ( Google Cloud Storage)
+# class GoogleCloudStorage(CloudStorage):
+#     def __init__(self, bucket_name):
+#         self.bucket_name = bucket_name
+#         self.client = storage.Client()
+
+#     def upload_file(self, file_content: bytes, filename: str) -> str:
+#         bucket = self.client.get_bucket(self.bucket_name)
+#         blob = bucket.blob(filename)
+#         blob.upload_from_string(file_content)
+#         return blob.public_url
+
+#     def delete_file(self, filename: str) -> None:
+#         blob = self.client.get_bucket(self.bucket_name).blob(filename)
+#         blob.delete()
+
+
+# Amazon S3
+class AmazonS3Storage(CloudStorage):
+    def __init__(
+        self, bucket_name, aws_access_key_id, aws_secret_access_key, region_name
+    ):
+        self.bucket_name = bucket_name
+        self.s3 = boto3.client(
+            "s3",
+            aws_access_key_id=aws_access_key_id,
+            aws_secret_access_key=aws_secret_access_key,
+            region_name=region_name,
+        )
+
+    def upload_file(self, file_content: bytes, filename: str) -> str:
+        self.s3.upload_fileobj(file_content, self.bucket_name, filename)
+        file_url = f"https://{self.bucket_name}.s3.amazonaws.com/{filename}"
+        return file_url
+
+    def delete_file(self, filename: str) -> None:
+        self.s3.delete_object(Bucket=self.bucket_name, Key=filename)
+
+
+# Cloudinary
+# class CloudinaryStorage(CloudStorage):
+#     def __init__(self, cloud_name, api_key, api_secret):
+#         cloudinary.config(cloud_name=cloud_name, api_key=api_key, api_secret=api_secret)
+
+#     def upload_file(self, file_content: bytes, filename: str) -> Any:
+#         result = uploader.upload(
+#             file_content,
+#             folder="test",
+#             resource_type="raw",
+#             filename=filename,
+#             use_filename=True,
+#         )
+#         return result
+
+#     def delete_file(self, public_id: str) -> None:
+#         uploader.destroy(public_id=public_id, resource_type="raw")
+
+
+class MinioStorage(CloudStorage):
+    def __init__(self, endpoint_url, access_key, secret_key, bucket_name):
+        self.endpoint_url = endpoint_url
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.bucket_name = bucket_name
+
+        # Initialisation du client MinIO
+        self.client = Minio(
+            endpoint=self.endpoint_url,
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            secure=False,  # En local, on utilise HTTP (pas HTTPS)
+        )
+
+        # Définition de la politique de bucket pour l'accès public en lecture
+        policy = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Effect": "Allow",
+                    "Principal": "*",
+                    "Action": ["s3:GetObject"],
+                    "Resource": [f"arn:aws:s3:::{bucket_name}/*"],
+                }
+            ],
+        }
+
+        # Vérification et configuration du bucket
+        try:
+            if not self.client.bucket_exists(bucket_name):
+                # Création du bucket
+                self.client.make_bucket(bucket_name)
+                print(f"Bucket '{bucket_name}' created successfully.")
+
+                # Application de la politique d'accès public
+                self.client.set_bucket_policy(bucket_name, json.dumps(policy))
+                print(f"Public access policy applied to bucket '{bucket_name}'.")
+            else:
+                print(f"Bucket '{bucket_name}' already exists.")
+
+        except S3Error as e:
+            print(f"Error occurred: {e}")
+
+    def exists(self, filename: str) -> bool:
+        try:
+            self.client.stat_object(self.bucket_name, filename)
+            return True
+        except S3Error:
+            return False
+
+    def generate_filename(self, filename: str) -> str:
+
+        filename, ext = filename.rsplit(".", 1)
+
+        # Remplacer tous les caractères non alphanumériques (sauf les tirets bas) par des tirets bas
+        refilename = re.sub(r"[^\w\-_()]+", "_", filename)
+        finalefilename = f"{refilename}.{ext}"
+        while self.exists(finalefilename):
+            return self.generate_filename(f"{filename}_{uuid.uuid4()}.{ext}")
+        return finalefilename
+
+    def download_file(self, filename: str) -> bytes:
+        obj = self.client.get_object(self.bucket_name, filename)
+        return obj.read()
+
+    def delete_file(self, filename: str) -> None:
+        self.client.remove_object(self.bucket_name, filename)
+
+    def list_files(self) -> list[str]:
+        objects = self.client.list_objects(self.bucket_name)
+        return [obj.object_name for obj in objects]
+
+    def create_bucket(self) -> None:
+        self.client.make_bucket(self.bucket_name)
+
+    def delete_bucket(self) -> None:
+        self.client.remove_bucket(self.bucket_name)
+
+    def list_buckets(self) -> list[str]:
+        buckets = self.client.list_buckets()
+        return [bucket.name for bucket in buckets]
+
+    def upload_file(self, file_content: bytes, filename: str) -> str:
+        gen_filename = self.generate_filename(filename)
+        self.client.put_object(
+            bucket_name=self.bucket_name,
+            object_name=gen_filename,
+            data=io.BytesIO(file_content),
+            length=-1,
+            part_size=100 * 1024 * 1024,
+        )
+        file_url = f"{settings.MINIO_CLOUD_URL}/{self.bucket_name}/{gen_filename}"
+        return {"file_url": file_url, "filename": gen_filename}

shaapi/template/backend/common/dataclasses.py

@@ -0,0 +1,52 @@
+import dataclasses
+
+from datetime import datetime
+
+from fastapi import Response
+
+from backend.common.enums import StatusType
+
+
+@dataclasses.dataclass
+class IpInfo:
+    ip: str
+    country: str | None
+    region: str | None
+    city: str | None
+
+
+@dataclasses.dataclass
+class UserAgentInfo:
+    user_agent: str
+    os: str | None
+    browser: str | None
+    device: str | None
+
+
+@dataclasses.dataclass
+class RequestCallNext:
+    code: str
+    msg: str
+    status: StatusType
+    err: Exception | None
+    response: Response
+
+
+@dataclasses.dataclass
+class NewToken:
+    new_access_token: str
+    new_access_token_expire_time: datetime
+    new_refresh_token: str
+    new_refresh_token_expire_time: datetime
+
+
+@dataclasses.dataclass
+class AccessToken:
+    access_token: str
+    access_token_expire_time: datetime
+
+
+@dataclasses.dataclass
+class RefreshToken:
+    refresh_token: str
+    refresh_token_expire_time: datetime

shaapi/template/backend/common/email_conf/email.py

@@ -0,0 +1,105 @@
+from datetime import datetime
+from datetime import timedelta
+from typing import Any
+from typing import List
+
+from fastapi_mail import ConnectionConfig
+from fastapi_mail import FastMail
+from fastapi_mail import MessageSchema
+from jinja2 import Environment
+from jinja2 import PackageLoader
+from jinja2 import select_autoescape
+from pydantic import EmailStr
+
+from backend.core.conf import settings
+# from backend.common.enums import Token_type
+# from app.core.security import generate_secret_token
+# from app.models import User
+# from backend.app.admin.schema.token import Token
+
+env = Environment(
+    loader=PackageLoader("backend", f"{settings.EMAIL_TEMPLATES_DIR}/"),
+    autoescape=select_autoescape(
+        enabled_extensions=("html", "xml"), default_for_string=True
+    ),
+)
+
+
+class Email:
+    def __init__(self):
+        self.conf = ConnectionConfig(
+            MAIL_USERNAME=settings.SMTP_USER,
+            MAIL_PASSWORD=settings.SMTP_PASSWORD,
+            MAIL_FROM=settings.EMAILS_FROM_EMAIL,
+            MAIL_FROM_NAME=settings.EMAILS_FROM_NAME,
+            MAIL_PORT=settings.SMTP_PORT,
+            MAIL_SERVER=settings.SMTP_HOST,
+            MAIL_STARTTLS=settings.SMTP_TLS,
+            MAIL_SSL_TLS=False,
+            USE_CREDENTIALS=True,
+            VALIDATE_CERTS=False,
+        )
+        pass
+
+    async def send_login_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        pass
+        
+
+    async def send_reset_password_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        pass
+
+    async def send_verify_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        pass
+
+    async def send_welcome_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        template = env.get_template("welcome-one.html")
+       
+        subject = "Bienvenue sur Boilerplate"
+        html = template.render(
+            subject=subject,
+            link=url,
+            email=email
+        )
+        message = MessageSchema(
+            subject=subject, recipients=[email], body=html, subtype="html"
+        )
+
+        fm = FastMail(self.conf)
+        await fm.send_message(message)
+
+    async def send_forgot_password_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        template = env.get_template("reset-password.html")
+        subject = "Réinitialisation du mot de passe"
+        html = template.render(
+            subject=subject,
+            link=url,
+            email=email
+        )
+        message = MessageSchema(
+            subject=subject, recipients=[email], body=html, subtype="html"
+        )
+
+        fm = FastMail(self.conf)
+        await fm.send_message(message)
+
+    async def send_change_password_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        pass
+
+    async def send_change_email_mail(
+        self, email: EmailStr, url: str | None = None, name: str | None = None
+    ):
+        pass
+
+email_service = Email()

shaapi/template/backend/common/enums.py

@@ -0,0 +1,144 @@
+from enum import Enum
+from enum import IntEnum as SourceIntEnum
+from typing import Type
+
+
+class _EnumBase:
+    @classmethod
+    def get_member_keys(cls: Type[Enum]) -> list[str]:
+        return [name for name in cls.__members__.keys()]
+
+    @classmethod
+    def get_member_values(cls: Type[Enum]) -> list:
+        return [item.value for item in cls.__members__.values()]
+
+
+class IntEnum(_EnumBase, SourceIntEnum):
+    """Integer Enum"""
+
+    pass
+
+
+class StrEnum(_EnumBase, str, Enum):
+    """String Enum"""
+
+    pass
+
+
+
+class LoginLogStatusType(IntEnum):
+    """Login Log Status"""
+
+    fail = 0
+    success = 1
+
+
+
+class StatusType(IntEnum):
+    """Status Type"""
+
+    disable = 0
+    enable = 1
+
+
+class MethodType(StrEnum):
+    """Request method"""
+
+    GET = 'GET'
+    POST = 'POST'
+    PUT = 'PUT'
+    DELETE = 'DELETE'
+    PATCH = 'PATCH'
+    OPTIONS = 'OPTIONS'
+
+
+class OperaLogCipherType(IntEnum):
+    """Operation log encryption type"""
+
+    aes = 0
+    md5 = 1
+    itsdangerous = 2
+    plan = 3
+
+class RoleDataScopeType(IntEnum):
+    """Data range"""
+
+    all = 1
+    custom = 2
+
+
+class User_job_status(Enum):
+    OPEN_TO_WORK = "open_to_work" #Disponible pour un emploi ou des opportunités professionnelles.
+    EMPLOYED = "employed" #Actuellement employé.
+    NOT_LOOKING = "not_looking" #Pas à la recherche d'opportunités pour le moment.
+    AVAILABLE_FOR_FREELANCE = "available_for_freelance" #Disponible pour des missions freelance ou des contrats à court terme.
+    ON_LEAVE = "on_leave" #En congé ou indisponible pour une période définie.
+    LOOKING_FOR_INTERNSHIP = "looking_for_internship" #Recherche activement un stage ou une opportunité d'apprentissage.
+    OPEN_TO_COLLABORATION = "open_to_collaboration" #Ouvert à des collaborations ou des projets en partenariat.
+    HIRED = "hired" #A trouvé un emploi ou est actuellement employé.
+
+class Role(Enum):
+    USER = "user"
+    ADMIN = "admin"
+    MENTOR = "mentor"
+    COMPANY = "company"
+
+class Appointment_status(Enum):
+    WAITING_FOR_PAYMENT = "waiting_for_payment"
+    PENDING = "pending"
+    CANCELED = "canceled"
+    DONE = "done"
+
+class Payment_type(Enum):
+    PAYIN = "payin"
+    PAYOUT = "payout"
+    
+class Contract_type(Enum):
+    CDI = "cdi"  # Contrat à Durée Indéterminée (CDI).
+    CDD = "cdd"  # Contrat à Durée Déterminée (CDD).
+
+class Collab_invitation_status_type(Enum):
+    WAITING_FOR_RESPONSE = "waiting_for_response"
+    ACCEPTED = "accepted"
+    REJECTED = "rejected"
+    CANCELED = "canceled"
+    
+class Collab_invitation_type(Enum):
+    COLLABORATOR = "collaborator"
+    RECRUTMENT = "recrutment"
+
+class Program_follow_request_status(Enum):
+    PENDING = "pending"
+    WAITING_FOR_PAYMENT = "waiting_for_payment"
+    PAID = "paid"
+    CANCELED = "canceled"
+
+    
+class Week_task_status(Enum):
+    IN_REVIEW = "in_review"
+    COMPLETED = "completed"
+    PENDING = "pending"
+    REJECTED = "rejected"
+
+class Mentor_request_status(Enum):
+    PENDING = "Pending"
+    APPROVED = "Approved"
+    REJECTED = "Rejected"
+
+class Transaction_status(Enum):
+    PENDING = "pending"
+    SUCCESSFULLY = "successfully"
+    CANCELED = "canceled"
+    
+class Secure_token_type(Enum):
+    RESET_PWD = "reset_pwd"
+    VERIFY_ACCOUNT = "verif_account"
+    UPDATE_EMAIL = "update_email"
+    
+class Waiting_queue_filter_type(Enum):
+    COURSE = "course"
+    PROGRAM = "program"
+
+class Reason_type(Enum):
+    COMPANY = "company"
+    USER = "user"

shaapi/template/backend/common/exception/errors.py

@@ -0,0 +1,87 @@
+"""
+Classe d'exception globale pour les entreprises
+
+Les exceptions liées à l'exécution du code métier peuvent être déclenchées avec raise xxxError, qui met en œuvre des exceptions avec des tâches d'arrière-plan dans la mesure du possible, mais ne s'applique pas aux **CustomResponseStatusCodes**
+Si un **CustomResponseStatusCode** est requis, il peut être renvoyé directement par return response_base.fail(res=CustomResponseCode.xxx)
+
+Traduit avec DeepL.com (version gratuite)
+"""  # noqa: E501
+
+from typing import Any
+
+from fastapi import HTTPException
+from starlette.background import BackgroundTask
+
+from backend.common.response.response_code import CustomErrorCode, StandardResponseCode
+
+
+class BaseExceptionMixin(Exception):
+    code: int
+
+    def __init__(self, *, msg: str = None, data: Any = None, background: BackgroundTask | None = None):
+        self.msg = msg
+        self.data = data
+        # The original background task: https://www.starlette.io/background/
+        self.background = background
+
+
+class HTTPError(HTTPException):
+    def __init__(self, *, code: int, msg: Any = None, headers: dict[str, Any] | None = None):
+        super().__init__(status_code=code, detail=msg, headers=headers)
+
+
+class CustomError(BaseExceptionMixin):
+    def __init__(self, *, error: CustomErrorCode, data: Any = None, background: BackgroundTask | None = None):
+        self.code = error.code
+        super().__init__(msg=error.msg, data=data, background=background)
+
+
+class RequestError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_400
+
+    def __init__(self, *, msg: str = 'Bad Request', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class ForbiddenError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_403
+
+    def __init__(self, *, msg: str = 'Forbidden', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class NotFoundError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_404
+
+    def __init__(self, *, msg: str = 'Not Found', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class ServerError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_500
+
+    def __init__(
+        self, *, msg: str = 'Internal Server Error', data: Any = None, background: BackgroundTask | None = None
+    ):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class GatewayError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_502
+
+    def __init__(self, *, msg: str = 'Bad Gateway', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class AuthorizationError(BaseExceptionMixin):
+    code = StandardResponseCode.HTTP_401
+
+    def __init__(self, *, msg: str = 'Permission Denied', data: Any = None, background: BackgroundTask | None = None):
+        super().__init__(msg=msg, data=data, background=background)
+
+
+class TokenError(HTTPError):
+    code = StandardResponseCode.HTTP_401
+
+    def __init__(self, *, msg: str = 'Not Authenticated', headers: dict[str, Any] | None = None):
+        super().__init__(code=self.code, msg=msg, headers=headers or {'WWW-Authenticate': 'Bearer'})