Schemas updated

ApiServices/AuthService/Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.12-slim
+
+WORKDIR /
+
+# Install system dependencies and Poetry
+RUN apt-get update && apt-get install -y --no-install-recommends gcc \
+    && rm -rf /var/lib/apt/lists/* && pip install --no-cache-dir poetry
+
+# Copy Poetry configuration
+COPY /pyproject.toml ./pyproject.toml
+
+# Configure Poetry and install dependencies with optimizations
+RUN poetry config virtualenvs.create false \
+    && poetry install --no-interaction --no-ansi --no-root --only main \
+    && pip cache purge && rm -rf ~/.cache/pypoetry
+
+# Copy application code
+COPY /ApiServices/AuthService /ApiServices/AuthService
+COPY /Controllers /Controllers
+COPY /Schemas/building /Schemas/building
+COPY /Schemas/company /Schemas/company
+COPY /Schemas/identity /Schemas/identity
+
+# Set Python path to include app directory
+ENV PYTHONPATH=/ PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
+
+# Run the application using the configured uvicorn server
+CMD ["poetry", "run", "python", "ApiServices/TemplateService/app.py"]

ApiServices/AuthService/app.py

@@ -0,0 +1,16 @@
+import uvicorn
+
+from config import api_config
+
+from ApiServices.TemplateService.create_app import create_app
+# from prometheus_fastapi_instrumentator import Instrumentator
+
+
+app = create_app()                                              # Create FastAPI application
+# Instrumentator().instrument(app=app).expose(app=app)          # Setup Prometheus metrics
+
+
+if __name__ == "__main__":
+    # Run the application with Uvicorn Server
+    uvicorn_config = uvicorn.Config(**api_config.app_as_dict)
+    uvicorn.Server(uvicorn_config).run()

ApiServices/AuthService/config.py

@@ -0,0 +1,64 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from fastapi.responses import JSONResponse
+
+
+class Configs(BaseSettings):
+    """
+    ApiTemplate configuration settings.
+    """
+
+    PATH: str = ""
+    HOST: str = "",
+    PORT: int = 0,
+    LOG_LEVEL: str = "info",
+    RELOAD: int = 0
+    ACCESS_TOKEN_TAG: str = ""
+
+    ACCESS_EMAIL_EXT: str = ""
+    TITLE: str = ""
+    ALGORITHM: str = ""
+    ACCESS_TOKEN_LENGTH: int = 90
+    REFRESHER_TOKEN_LENGTH: int = 144
+    EMAIL_HOST: str = ""
+    DATETIME_FORMAT: str = ""
+    FORGOT_LINK: str = ""
+    ALLOW_ORIGINS: list = ["http://localhost:3000"]
+    VERSION: str = "0.1.001"
+    DESCRIPTION: str = ""
+
+    @property
+    def app_as_dict(self) -> dict:
+        """
+        Convert the settings to a dictionary.
+        """
+        return {
+            "app": self.PATH,
+            "host": self.HOST,
+            "port": int(self.PORT),
+            "log_level": self.LOG_LEVEL,
+            "reload": bool(self.RELOAD)
+        }
+
+    @property
+    def api_info(self):
+        """
+        Returns a dictionary with application information.
+        """
+        return {
+            "title": self.TITLE,
+            "description": self.DESCRIPTION,
+            "default_response_class": JSONResponse,
+            "version": self.VERSION,
+        }
+
+    @classmethod
+    def forgot_link(cls, forgot_key):
+        """
+        Generate a forgot password link.
+        """
+        return cls.FORGOT_LINK + forgot_key
+
+    model_config = SettingsConfigDict(env_prefix="API_")
+
+
+api_config = Configs()

ApiServices/AuthService/create_app.py

@@ -0,0 +1,41 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from ApiServices.TemplateService.create_route import RouteRegisterController
+from ApiServices.TemplateService.endpoints.routes import get_routes
+from ApiServices.TemplateService.open_api_creator import create_openapi_schema
+from ApiServices.TemplateService.middlewares.token_middleware import token_middleware
+from ApiServices.TemplateService.config import template_api_config
+
+
+def create_app():
+
+    application = FastAPI(**template_api_config.api_info)
+    # application.mount(
+    #     "/application/static",
+    #     StaticFiles(directory="application/static"),
+    #     name="static",
+    # )
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=template_api_config.ALLOW_ORIGINS,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @application.middleware("http")
+    async def add_token_middleware(request: Request, call_next):
+        return await token_middleware(request, call_next)
+
+    @application.get("/", description="Redirect Route", include_in_schema=False)
+    async def redirect_to_docs():
+        return RedirectResponse(url="/docs")
+
+    route_register = RouteRegisterController(app=application, router_list=get_routes())
+    application = route_register.register_routes()
+
+    application.openapi = lambda _=application: create_openapi_schema(_)
+    return application

ApiServices/AuthService/create_route.py

@@ -0,0 +1,14 @@
+from typing import List
+from fastapi import APIRouter, FastAPI
+
+
+class RouteRegisterController:
+
+    def __init__(self, app: FastAPI, router_list: List[APIRouter]):
+        self.router_list = router_list
+        self.app = app
+
+    def register_routes(self):
+        for router in self.router_list:
+            self.app.include_router(router)
+        return self.app

ApiServices/AuthService/endpoints/routes.py

@@ -0,0 +1,20 @@
+from fastapi import APIRouter
+from .test_template.route import test_template_route
+
+
+def get_routes() -> list[APIRouter]:
+    return [test_template_route]
+
+
+def get_safe_endpoint_urls() -> list[tuple[str, str]]:
+    return [
+        ("/", "GET"),
+        ("/docs", "GET"),
+        ("/redoc", "GET"),
+        ("/openapi.json", "GET"),
+        ("/auth/register", "POST"),
+        ("/auth/login", "POST"),
+        ("/metrics", "GET"),
+        ("/test/template", "GET"),
+        ("/test/template", "POST"),
+    ]

ApiServices/AuthService/endpoints/test_template/route.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Request, Response
+
+test_template_route = APIRouter(prefix="/test", tags=["Test"])
+
+
+@test_template_route.get(path="/template", description="Test Template Route")
+def test_template(request: Request, response: Response):
+    """
+    Test Template Route
+    """
+    headers = dict(request.headers)
+    response.headers["X-Header"] = "Test Header GET"
+    return {
+        "completed": True,
+        "message": "Test Template Route",
+        "info": {
+            "host": headers.get("host", "Not Found"),
+            "user_agent": headers.get("user-agent", "Not Found"),
+        },
+    }
+
+
+@test_template_route.post(
+    path="/template",
+    description="Test Template Route with Post Method",
+)
+def test_template_post(request: Request, response: Response):
+    """
+    Test Template Route with Post Method
+    """
+    headers = dict(request.headers)
+    response.headers["X-Header"] = "Test Header POST"
+    return {
+        "completed": True,
+        "message": "Test Template Route with Post Method",
+        "info": {
+            "host": headers.get("host", "Not Found"),
+            "user_agent": headers.get("user-agent", "Not Found"),
+        },
+    }

ApiServices/AuthService/middlewares/token_middleware.py

@@ -0,0 +1,17 @@
+from fastapi import Request, Response
+from ApiServices.TemplateService.endpoints.routes import get_safe_endpoint_urls
+
+
+async def token_middleware(request: Request, call_next):
+
+    base_url = "/".join(request.url.path.split("/")[:3])
+    safe_endpoints = [_[0] for _ in get_safe_endpoint_urls()]
+    if base_url in safe_endpoints:
+        return await call_next(request)
+
+    token = request.headers.get("Authorization")
+    if not token:
+        return Response(content="Missing token", status_code=400)
+
+    response = await call_next(request)
+    return response

ApiServices/AuthService/open_api_creator.py

@@ -0,0 +1,118 @@
+from typing import Any, Dict
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from fastapi.openapi.utils import get_openapi
+
+from ApiServices.TemplateService.config import template_api_config
+from ApiServices.TemplateService.endpoints.routes import get_safe_endpoint_urls
+
+
+class OpenAPISchemaCreator:
+    """
+    OpenAPI schema creator and customizer for FastAPI applications.
+    """
+
+    def __init__(self, app: FastAPI):
+        """
+        Initialize the OpenAPI schema creator.
+
+        Args:
+            app: FastAPI application instance
+        """
+        self.app = app
+        self.safe_endpoint_list: list[tuple[str, str]] = get_safe_endpoint_urls()
+        self.routers_list = self.app.routes
+
+    @staticmethod
+    def create_security_schemes() -> Dict[str, Any]:
+        """
+        Create security scheme definitions.
+
+        Returns:
+            Dict[str, Any]: Security scheme configurations
+        """
+
+        return {
+            "BearerAuth": {
+                "type": "apiKey",
+                "in": "header",
+                "name": template_api_config.ACCESS_TOKEN_TAG,
+                "description": "Enter: **'Bearer <JWT>'**, where JWT is the access token",
+            }
+        }
+
+    def configure_route_security(
+        self, path: str, method: str, schema: Dict[str, Any]
+    ) -> None:
+        """
+        Configure security requirements for a specific route.
+
+        Args:
+            path: Route path
+            method: HTTP method
+            schema: OpenAPI schema to modify
+        """
+        if not schema.get("paths", {}).get(path, {}).get(method):
+            return
+
+        # Check if endpoint is in safe list
+        endpoint_path = f"{path}:{method}"
+        list_of_safe_endpoints = [
+            f"{e[0]}:{str(e[1]).lower()}" for e in self.safe_endpoint_list
+        ]
+        if endpoint_path not in list_of_safe_endpoints:
+            if "security" not in schema["paths"][path][method]:
+                schema["paths"][path][method]["security"] = []
+            schema["paths"][path][method]["security"].append({"BearerAuth": []})
+
+    def create_schema(self) -> Dict[str, Any]:
+        """
+        Create the complete OpenAPI schema.
+
+        Returns:
+            Dict[str, Any]: Complete OpenAPI schema
+        """
+        openapi_schema = get_openapi(
+            title=template_api_config.TITLE,
+            description=template_api_config.DESCRIPTION,
+            version=template_api_config.VERSION,
+            routes=self.app.routes,
+        )
+
+        # Add security schemes
+        if "components" not in openapi_schema:
+            openapi_schema["components"] = {}
+
+        openapi_schema["components"][
+            "securitySchemes"
+        ] = self.create_security_schemes()
+
+        # Configure route security and responses
+        for route in self.app.routes:
+            if isinstance(route, APIRoute) and route.include_in_schema:
+                path = str(route.path)
+                methods = [method.lower() for method in route.methods]
+                for method in methods:
+                    self.configure_route_security(path, method, openapi_schema)
+
+        # Add custom documentation extensions
+        openapi_schema["x-documentation"] = {
+            "postman_collection": "/docs/postman",
+            "swagger_ui": "/docs",
+            "redoc": "/redoc",
+        }
+        return openapi_schema
+
+
+def create_openapi_schema(app: FastAPI) -> Dict[str, Any]:
+    """
+    Create OpenAPI schema for a FastAPI application.
+
+    Args:
+        app: FastAPI application instance
+
+    Returns:
+        Dict[str, Any]: Complete OpenAPI schema
+    """
+    creator = OpenAPISchemaCreator(app)
+    return creator.create_schema()

ApiServices/AuthService/schemas/__init__.py

@@ -0,0 +1 @@
+from Schemas.building.build import BuildParts, BuildLivingSpace