new api service and logic implemented

ApiLayers/AllApiNeeds/app.py

@@ -0,0 +1,25 @@
+"""
+FastAPI Application Entry Point
+
+This module initializes and configures the FastAPI application with:
+- CORS middleware for cross-origin requests
+- Request timing middleware for performance monitoring
+- Custom exception handlers for consistent error responses
+- Prometheus instrumentation for metrics
+- API routers for endpoint organization
+"""
+
+import uvicorn
+from prometheus_fastapi_instrumentator import Instrumentator
+from app_handler import setup_middleware, get_uvicorn_config
+from create_file import create_app
+
+
+app = create_app()  # Initialize FastAPI application
+Instrumentator().instrument(app=app).expose(app=app)  # Setup Prometheus metrics
+setup_middleware(app)  # Configure middleware and exception handlers
+
+
+if __name__ == "__main__":
+    uvicorn_config = get_uvicorn_config()  # Run the application with Uvicorn
+    uvicorn.Server(uvicorn.Config(**uvicorn_config)).run()

ApiLayers/AllApiNeeds/app_handler.py

@@ -0,0 +1,94 @@
+"""
+FastAPI Application Handler Module
+
+This module contains all the handler functions for configuring and setting up the FastAPI application:
+- CORS middleware configuration
+- Exception handlers setup
+- Uvicorn server configuration
+"""
+
+from typing import Dict, Any
+
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, Request, HTTPException, status
+from fastapi.responses import JSONResponse
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from middleware.auth_middleware import RequestTimingMiddleware, LoggerTimingMiddleware
+
+
+def setup_cors_middleware(app: FastAPI) -> None:
+    """
+    Configure CORS middleware for the application.
+
+    Args:
+        app: FastAPI application instance
+    """
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+
+async def generic_exception_handler(request: Request, exc: Exception) -> JSONResponse:
+    """
+    Handle generic exceptions and return formatted error responses.
+
+    Args:
+        request: FastAPI request object
+        exc: Exception instance
+
+    Returns:
+        JSONResponse: Formatted error response
+    """
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"detail": "Internal server error", "error_code": "INTERNAL_ERROR"},
+    )
+
+
+def setup_exception_handlers(app: FastAPI) -> None:
+    """
+    Configure custom exception handlers for the application.
+
+    Args:
+        app: FastAPI application instance
+    """
+    from ErrorHandlers.ErrorHandlers.api_exc_handler import HTTPExceptionApiHandler
+
+    custom_exception_handler = HTTPExceptionApiHandler(response_model=JSONResponse)
+    app.add_exception_handler(
+        HTTPExceptionApi, custom_exception_handler.handle_exception
+    )
+    app.add_exception_handler(Exception, generic_exception_handler)
+
+
+def setup_middleware(app: FastAPI) -> None:
+    """
+    Configure all middleware for the application.
+
+    Args:
+        app: FastAPI application instance
+    """
+    setup_cors_middleware(app)
+    app.add_middleware(RequestTimingMiddleware)
+    app.add_middleware(LoggerTimingMiddleware)
+    setup_exception_handlers(app)
+
+
+def get_uvicorn_config() -> Dict[str, Any]:
+    """
+    Get Uvicorn server configuration.
+
+    Returns:
+        Dict[str, Any]: Uvicorn configuration dictionary
+    """
+    return {
+        "app": "app:app",
+        "host": "0.0.0.0",
+        "port": 41575,
+        "log_level": "info",
+        "reload": True,
+    }

ApiLayers/AllApiNeeds/application/__init__.py

@@ -0,0 +1 @@
+

ApiLayers/AllApiNeeds/application/app.py

@@ -0,0 +1,21 @@
+"""
+Base FastAPI application configuration.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="API Service")
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    return app

ApiLayers/AllApiNeeds/create_file.py

@@ -0,0 +1,94 @@
+"""
+FastAPI Application Factory Module
+
+This module provides functionality to create and configure a FastAPI application with:
+- Custom OpenAPI schema configuration
+- Security scheme configuration for Bearer authentication
+- Automatic router registration
+- Response class configuration
+- Security requirements for protected endpoints
+"""
+
+from typing import Any, Dict, List, Tuple
+from fastapi import FastAPI, APIRouter
+from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.openapi.utils import get_openapi
+
+from AllConfigs.Token.config import Auth
+from AllConfigs.main import MainConfig as Config
+
+from create_routes import get_all_routers
+
+
+def setup_security_schema() -> Dict[str, Any]:
+    """
+    Configure security schema for the OpenAPI documentation.
+
+    Returns:
+        Dict[str, Any]: Security schema configuration
+    """
+    return {
+        "components": {
+            "securitySchemes": {
+                "Bearer Auth": {
+                    "type": "apiKey",
+                    "in": "header",
+                    "name": Auth.ACCESS_TOKEN_TAG,
+                    "description": "Enter: **'Bearer <JWT>'**, where JWT is the access token",
+                }
+            }
+        }
+    }
+
+
+def configure_route_security(
+    path: str, method: str, schema: Dict[str, Any], protected_paths: List[str]
+) -> None:
+    """
+    Configure security requirements for a specific route.
+
+    Args:
+        path: Route path
+        method: HTTP method
+        schema: OpenAPI schema to modify
+        protected_paths: List of paths that require authentication
+    """
+    if path in protected_paths:
+        if "paths" in schema and path in schema["paths"]:
+            if method.lower() in schema["paths"][path]:
+                schema["paths"][path][method.lower()]["security"] = [{"Bearer": []}]
+
+
+def create_app() -> FastAPI:
+    """
+    Create and configure a FastAPI application with dynamic route creation.
+
+    Returns:
+        FastAPI: Configured FastAPI application instance
+    """
+
+    from open_api_creator import create_openapi_schema
+
+    # Get all routers and protected routes using the dynamic route creation
+
+    app = FastAPI(
+        title=Config.TITLE,
+        description=Config.DESCRIPTION,
+        default_response_class=JSONResponse,
+    )  # Initialize FastAPI app
+
+    @app.get("/", include_in_schema=False, summary=str(Config.DESCRIPTION))
+    async def home() -> RedirectResponse:
+        """Redirect root path to API documentation."""
+        return RedirectResponse(url="/docs")
+
+    # Get all routers and protected routes using the dynamic route creation
+    routers, protected_routes = get_all_routers()
+
+    # Include all routers
+    for router in routers:
+        app.include_router(router)
+
+    app.openapi = lambda app=app: create_openapi_schema(app)
+
+    return app

ApiLayers/AllApiNeeds/create_routes.py

@@ -0,0 +1,127 @@
+"""
+Route configuration and factory module.
+Handles dynamic route creation based on configurations.
+"""
+
+from typing import Optional, Dict, Any, List, Callable, TypeVar, ParamSpec
+
+P = ParamSpec("P")  # For function parameters
+R = TypeVar("R")  # For return type
+
+from dataclasses import dataclass
+from functools import wraps
+from fastapi import APIRouter, Request
+from fastapi.routing import APIRoute
+from middleware.auth_middleware import MiddlewareModule
+from pydantic import BaseModel
+from AllConfigs.main import MainConfig as Config
+
+
+@dataclass
+class EndpointFactoryConfig:
+    endpoint: str
+    method: str
+    summary: str
+    description: str
+    endpoint_function: Callable[P, R]  # Now accepts any parameters and return type
+    is_auth_required: bool = True
+    is_event_required: bool = False
+    extra_options: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.extra_options is None:
+            self.extra_options = {}
+
+
+class EnhancedEndpointFactory:
+    def __init__(self, router_config: dict):
+        self.router = APIRouter(
+            prefix=router_config["prefix"],
+            tags=router_config["tags"],
+            include_in_schema=router_config.get("include_in_schema", True),
+        )
+        self.endpoints = router_config["endpoints"]
+        self.protected_routes: Dict[str, List[str]] = {}
+
+    def create_endpoint(self, config: EndpointFactoryConfig):
+        """
+        Create an endpoint directly from the configuration.
+
+        Args:
+            config: EndpointFactoryConfig instance containing endpoint configuration
+        """
+        endpoint_path = config.endpoint
+        endpoint_function = config.endpoint_function
+
+        if config.is_auth_required:
+            # endpoint_function = MiddlewareModule.auth_required(endpoint_function)
+            # Track protected routes
+            full_path = f"{self.router.prefix}{endpoint_path}"
+            if full_path not in self.protected_routes:
+                self.protected_routes[full_path] = []
+            self.protected_routes[full_path].append(config.method.lower())
+
+        # Register the endpoint with FastAPI router
+        getattr(self.router, config.method.lower())(
+            endpoint_path,
+            summary=config.summary,
+            description=config.description,
+            **config.extra_options,
+        )(endpoint_function)
+
+    def get_router(self) -> APIRouter:
+        """Get the configured router."""
+        return self.router
+
+    def get_protected_routes(self) -> Dict[str, List[str]]:
+        """Get the protected routes mapping."""
+        return self.protected_routes
+
+
+async def health_check(request: Request):
+    """Default health check endpoint."""
+    return {"status": "healthy", "message": "Service is running"}
+
+
+async def ping_test(request: Request, service_name: str = "base-router"):
+    """Default ping test endpoint."""
+    return {"ping": "pong", "service": service_name}
+
+
+def get_all_routers() -> tuple[List[APIRouter], Dict[str, List[str]]]:
+    """
+    Get all routers and protected routes from route configurations.
+
+    Returns:
+        tuple: (routers, protected_routes)
+    """
+    from ApiEvents.route_configs import get_route_configs
+
+    routers = []
+    all_protected_routes = {}
+
+    # Get route configurations from the registry
+    route_configs = get_route_configs()
+    factory_all = []
+    for config in route_configs:
+        factory = EnhancedEndpointFactory(config)
+
+        # Create endpoints from configuration
+        for endpoint_dict in config["endpoints"]:
+            endpoint_config = EndpointFactoryConfig(
+                endpoint=endpoint_dict["endpoint"],
+                method=endpoint_dict["method"],
+                summary=endpoint_dict["summary"],
+                description=endpoint_dict["description"],
+                endpoint_function=endpoint_dict["endpoint_function"],
+                is_auth_required=endpoint_dict["is_auth_required"],
+                is_event_required=endpoint_dict["is_event_required"],
+                extra_options=endpoint_dict.get("extra_options", {}),
+            )
+            factory.create_endpoint(endpoint_config)
+            factory_all.append(endpoint_config.__dict__)
+
+        # Add router and protected routes
+        routers.append(factory.get_router())
+        all_protected_routes.update(factory.get_protected_routes())
+    return routers, all_protected_routes

ApiLayers/AllApiNeeds/middleware/__init__.py

@@ -0,0 +1,14 @@
+from .token_event_middleware import TokenEventMiddleware
+from .auth_middleware import (
+    LoggerTimingMiddleware,
+    RequestTimingMiddleware,
+    MiddlewareModule,
+)
+
+
+__all__ = [
+    "TokenEventMiddleware",
+    "RequestTimingMiddleware",
+    "MiddlewareModule",
+    "LoggerTimingMiddleware",
+]

ApiLayers/AllApiNeeds/middleware/auth_middleware.py

@@ -0,0 +1,162 @@
+"""
+Authentication and Authorization middleware for FastAPI applications.
+
+This module provides authentication decorator for protecting endpoints
+and a middleware for request timing measurements.
+"""
+
+from time import perf_counter
+from typing import Callable, Optional, Dict, Any, Tuple, Union
+from functools import wraps
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from ApiLibrary.common.line_number import get_line_number_for_error
+from ErrorHandlers.ErrorHandlers.api_exc_handler import HTTPExceptionApi
+from AllConfigs.Token.config import Auth
+import inspect
+
+
+class MiddlewareModule:
+    """
+    Middleware module for handling authentication and request timing.
+    """
+
+    @staticmethod
+    def get_user_from_request(
+        request: Request,
+    ) -> dict:
+        """
+        Get authenticated token context from request.
+
+        Args:
+            request: FastAPI request object
+
+        Returns:
+            AuthContext: Context containing the authenticated token data
+
+        Raises:
+            HTTPExceptionApi: If token is missing, invalid, or user not found
+        """
+        from ApiServices.Token.token_handler import TokenService
+
+        # Get token and validate - will raise HTTPExceptionApi if invalid
+        redis_token = TokenService.get_access_token_from_request(request=request)
+        # Get token context - will validate token and raise appropriate errors
+        token_context = TokenService.get_object_via_access_key(access_token=redis_token)
+        if not token_context:
+            raise HTTPExceptionApi(
+                error_code="USER_NOT_FOUND",
+                lang="tr",
+                loc=get_line_number_for_error(),
+                sys_msg="TokenService: Token Context couldnt retrieved from redis",
+            )
+
+        return token_context
+
+    @classmethod
+    def auth_required(cls, func: Callable) -> Callable:
+        """
+        Decorator for protecting FastAPI endpoints with authentication.
+
+        Usage:
+            @router.get("/protected")
+            @MiddlewareModule.auth_required
+            async def protected_endpoint(request: Request):
+                auth = protected_endpoint.auth  # Access auth context
+                if auth.is_employee:
+                    # Handle employee logic
+                    employee_id = auth.token_context.employee_id
+                else:
+                    # Handle occupant logic
+                    occupant_id = auth.token_context.occupant_id
+                return {"user_id": auth.user_id}
+
+        Args:
+            func: The FastAPI route handler function to protect
+
+        Returns:
+            Callable: Wrapped function that checks authentication before execution
+
+        Raises:
+            HTTPExceptionApi: If authentication fails
+        """
+
+        @wraps(func)
+        async def wrapper(request: Request, *args, **kwargs):
+            # Get and validate token context from request
+            # Create auth context and Attach auth context to both wrapper and original function
+            func.auth = cls.get_user_from_request(request)
+            wrapper.auth = func.auth
+            # Call the original endpoint function
+            if inspect.iscoroutinefunction(func):
+                return await func(request, *args, **kwargs)
+            return func(request, *args, **kwargs)
+
+        return wrapper
+
+
+class RequestTimingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for measuring and logging request timing.
+    Only handles timing, no authentication.
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        """
+        Process each request through the middleware.
+
+        Args:
+            request: FastAPI request object
+            call_next: Next middleware in the chain
+
+        Returns:
+            Response: Processed response with timing headers
+        """
+        start_time = perf_counter()
+        # Process the request
+        response = await call_next(request)
+
+        # Add timing information to response headers
+        end_time = perf_counter()
+        elapsed = (end_time - start_time) * 1000  # Convert to milliseconds
+
+        response.headers.update(
+            {
+                "request-start": f"{start_time:.6f}",
+                "request-end": f"{end_time:.6f}",
+                "request-duration": f"{elapsed:.2f}ms",
+            }
+        )
+
+        return response
+
+
+class LoggerTimingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for measuring and logging request timing.
+    Only handles timing, no authentication.
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        # Log the request
+        import arrow
+
+        headers = dict(request.headers)
+        response = await call_next(request)
+        # Log the response
+        print(
+            "Loggers :",
+            {
+                "url": request.url,
+                "method": request.method,
+                "access_token": headers.get(Auth.ACCESS_TOKEN_TAG, ""),
+                "referer": headers.get("referer", ""),
+                "origin": headers.get("origin", ""),
+                "user-agent": headers.get("user-agent", ""),
+                "datetime": arrow.now().format("YYYY-MM-DD HH:mm:ss ZZ"),
+                "status_code": response.status_code,
+            },
+        )
+        return response

ApiLayers/AllApiNeeds/middleware/token_event_middleware.py

@@ -0,0 +1,297 @@
+"""
+Token event middleware for handling authentication and event tracking.
+"""
+
+import inspect
+
+from functools import wraps
+from typing import Callable, Dict, Any, Optional, Union
+from fastapi import Request
+from pydantic import BaseModel
+
+from ApiLibrary.common.line_number import get_line_number_for_error
+from ApiServices.Token.token_handler import TokenService
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from Schemas.rules.rules import EndpointRestriction
+
+from .auth_middleware import MiddlewareModule
+from Schemas import Events
+
+
+class EventFunctions:
+
+    def __init__(self, endpoint: str, request: Request):
+        self.endpoint = endpoint
+        self.request = request
+
+    def match_endpoint_with_accesiable_event(self) -> Optional[Dict[str, Any]]:
+        """
+        Match an endpoint with accessible events.
+
+        Args:
+            endpoint: The endpoint to match
+
+        Returns:
+            Dict containing the endpoint registration data
+            None if endpoint is not found in database
+        """
+        access_token = TokenService.get_access_token_from_request(self.request)
+        token_context = TokenService.get_object_via_access_key(
+            access_token=access_token
+        )
+        if token_context.is_employee:
+            reachable_event_codes: list[str] = (
+                token_context.selected_company.reachable_event_codes
+            )
+        elif token_context.is_occupant:
+            reachable_event_codes: list[str] = (
+                token_context.selected_occupant.reachable_event_codes
+            )
+        else:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Token not found",
+            )
+
+        if not access_token:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Token not found",
+            )
+
+        db = EndpointRestriction.new_session()
+        restriction = EndpointRestriction.filter_one(
+            EndpointRestriction.endpoint_name == self.endpoint,
+            db=db,
+        ).data
+        if not restriction:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Function code not found",
+            )
+
+        event_related = Events.filter_all(
+            Events.endpoint_id == restriction.id,
+            db=db,
+        ).data
+        if not event_related:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="No event is registered for this user.",
+            )
+        an_event = event_related[0]
+        event_related_codes: list[str] = [
+            event.function_code for event in event_related
+        ]
+        intersected_code: set = set(reachable_event_codes).intersection(
+            set(event_related_codes)
+        )
+        if not len(list(intersected_code)) == 1:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="No event is registered for this user.",
+            )
+        return {
+            "endpoint_url": self.endpoint,
+            "reachable_event_code": list(intersected_code)[0],
+            "class": an_event.function_class,
+        }
+
+    def retrieve_function_dict(self) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve function dictionary for a given endpoint.
+
+        Args:
+            endpoint: The endpoint to retrieve the function dictionary for
+
+        Returns:
+            Dictionary containing the function dictionary
+            None if endpoint is not found
+        """
+        access_token = TokenService.get_access_token_from_request(self.request)
+        token_context = TokenService.get_object_via_access_key(
+            access_token=access_token
+        )
+        if token_context.is_employee:
+            reachable_event_codes: list[str] = (
+                token_context.selected_company.reachable_event_codes
+            )
+        elif token_context.is_occupant:
+            reachable_event_codes: list[str] = (
+                token_context.selected_occupant.reachable_event_codes
+            )
+        else:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Token not found",
+            )
+
+        if not access_token:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Token not found",
+            )
+
+        db = EndpointRestriction.new_session()
+        restriction = EndpointRestriction.filter_one(
+            EndpointRestriction.endpoint_name == self.endpoint,
+            db=db,
+        ).data
+        if not restriction:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Function code not found",
+            )
+
+        event_related = Events.filter_all(
+            Events.endpoint_id == restriction.id,
+            db=db,
+        ).data
+        if not event_related:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="No event is registered for this user.",
+            )
+        an_event = event_related[0]
+        event_related_codes: list[str] = [
+            event.function_code for event in event_related
+        ]
+        intersected_code: set = set(reachable_event_codes).intersection(
+            set(event_related_codes)
+        )
+        if not len(list(intersected_code)) == 1:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="No event is registered for this user.",
+            )
+        return {
+            "endpoint_url": self.endpoint,
+            "reachable_event_code": list(intersected_code)[0],
+            "class": an_event.function_class,
+        }
+
+
+class TokenEventMiddleware:
+    """
+    Module containing token and event handling functionality.
+
+    This class provides:
+    - Token and event context management
+    - Event validation decorator for endpoints
+    """
+
+    @staticmethod
+    def event_required(
+        func: Callable[..., Dict[str, Any]]
+    ) -> Callable[..., Dict[str, Any]]:
+        """
+        Decorator for endpoints with token and event requirements.
+        This decorator:
+        1. First validates authentication using MiddlewareModule.auth_required
+        2. Then adds event tracking context
+
+        Args:
+            func: The function to be decorated
+
+        Returns:
+            Callable: The wrapped function with both auth and event handling
+        """
+        # # First apply authentication
+        # authenticated_func = MiddlewareModule.auth_required(func)
+        authenticated_func = func
+
+        @wraps(authenticated_func)
+        async def wrapper(request: Request, *args, **kwargs) -> Dict[str, Any]:
+
+            # Get function code from the function's metadata
+            endpoint_url = getattr(authenticated_func, "url_of_endpoint", {})
+            if not endpoint_url:
+                raise HTTPExceptionApi(
+                    error_code="",
+                    lang="en",
+                    loc=get_line_number_for_error(),
+                    sys_msg="Function code not found",
+                )
+
+            # Make handler available to all functions in the chain
+            func.func_code = EventFunctions(
+                endpoint_url, request
+            ).match_endpoint_with_accesiable_event()
+            # Call the authenticated function
+            if inspect.iscoroutinefunction(authenticated_func):
+                return await authenticated_func(request, *args, **kwargs)
+            return authenticated_func(request, *args, **kwargs)
+
+        return wrapper
+
+    @staticmethod
+    def validation_required(
+        func: Callable[..., Dict[str, Any]]
+    ) -> Callable[..., Dict[str, Any]]:
+        """
+        Decorator for endpoints with token and event requirements.
+        This decorator:
+        1. First validates authentication using MiddlewareModule.auth_required
+        2. Then adds event tracking context
+
+        Args:
+            func: The function to be decorated
+
+        Returns:
+            Callable: The wrapped function with both auth and event handling
+        """
+        # First apply authentication
+        authenticated_func = MiddlewareModule.auth_required(func)
+
+        @wraps(authenticated_func)
+        async def wrapper(
+            request: Request, *args: Any, **kwargs: Any
+        ) -> Union[Dict[str, Any], BaseModel]:
+            # Handle both async and sync functions
+            endpoint_asked = getattr(kwargs.get("data", None), "data", None).get(
+                "endpoint", None
+            )
+            if not endpoint_asked:
+                raise HTTPExceptionApi(
+                    error_code="",
+                    lang="en",
+                    loc=get_line_number_for_error(),
+                    sys_msg="Endpoint not found",
+                )
+            wrapper.validation_code = EventFunctions(
+                endpoint_asked, request
+            ).retrieve_function_dict()
+            if inspect.iscoroutinefunction(authenticated_func):
+                result = await authenticated_func(request, *args, **kwargs)
+            else:
+                result = authenticated_func(request, *args, **kwargs)
+            function_auth = getattr(authenticated_func, "auth", None)
+            wrapper.auth = function_auth
+            func.auth = function_auth
+            authenticated_func.auth = function_auth
+            # If result is a coroutine, await it
+            if inspect.iscoroutine(result):
+                result = await result
+            return result
+
+        return wrapper

ApiLayers/AllApiNeeds/open_api_creator.py

@@ -0,0 +1,273 @@
+"""
+OpenAPI Schema Creator Module
+
+This module provides functionality to create and customize OpenAPI documentation:
+- Custom security schemes (Bearer Auth, API Key)
+- Response schemas and examples
+- Tag management and descriptions
+- Error responses and validation
+- Custom documentation extensions
+"""
+
+from typing import Any, Dict, List, Optional, Set
+from fastapi import FastAPI, APIRouter
+from fastapi.routing import APIRoute
+from fastapi.openapi.utils import get_openapi
+
+from AllConfigs.Token.config import Auth
+from AllConfigs.main import MainConfig as Config
+from create_routes import get_all_routers
+
+
+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.protected_routes = get_all_routers()
+        # self.tags_metadata = self._create_tags_metadata()
+
+    @staticmethod
+    def _create_tags_metadata() -> List[Dict[str, str]]:
+        """
+        Create metadata for API tags.
+
+        Returns:
+            List[Dict[str, str]]: List of tag metadata
+        """
+        return [
+            {
+                "name": "Authentication",
+                "description": "Operations related to user authentication and authorization",
+            },
+            {
+                "name": "Users",
+                "description": "User management and profile operations",
+            },
+            # Add more tags as needed
+        ]
+
+    def _create_security_schemes(self) -> Dict[str, Any]:
+        """
+        Create security scheme definitions.
+
+        Returns:
+            Dict[str, Any]: Security scheme configurations
+        """
+        return {
+            "Bearer Auth": {
+                "type": "apiKey",
+                "in": "header",
+                "name": Auth.ACCESS_TOKEN_TAG,
+                "description": "Enter: **'Bearer <JWT>'**, where JWT is the access token",
+            }
+        }
+
+    def _create_common_responses(self) -> Dict[str, Any]:
+        """
+        Create common response schemas.
+
+        Returns:
+            Dict[str, Any]: Common response configurations
+        """
+        return {
+            "401": {
+                "description": "Unauthorized - Invalid or missing credentials",
+                "content": {
+                    "application/json": {
+                        "schema": {"$ref": "#/components/schemas/HTTPValidationError"}
+                    }
+                },
+            },
+            "403": {
+                "description": "Forbidden - Insufficient permissions",
+                "content": {
+                    "application/json": {
+                        "schema": {"$ref": "#/components/schemas/HTTPValidationError"}
+                    }
+                },
+            },
+            "422": {
+                "description": "Validation Error",
+                "content": {
+                    "application/json": {
+                        "schema": {"$ref": "#/components/schemas/HTTPValidationError"}
+                    }
+                },
+            },
+            "500": {
+                "description": "Internal Server Error",
+                "content": {
+                    "application/json": {
+                        "schema": {
+                            "type": "object",
+                            "properties": {
+                                "detail": {"type": "string"},
+                                "error_code": {"type": "string"},
+                            },
+                        },
+                        "example": {
+                            "detail": "Internal server error occurred",
+                            "error_code": "INTERNAL_ERROR",
+                        },
+                    }
+                },
+            },
+        }
+
+    def _process_request_body(
+        self, path: str, method: str, schema: Dict[str, Any]
+    ) -> None:
+        """
+        Process request body to include examples from model config.
+
+        Args:
+            path: Route path
+            method: HTTP method
+            schema: OpenAPI schema to modify
+        """
+        try:
+            route_schema = schema["paths"][path][method]
+            if "requestBody" in route_schema:
+                request_body = route_schema["requestBody"]
+                if "content" in request_body:
+                    content = request_body["content"]
+                    if "application/json" in content:
+                        json_content = content["application/json"]
+                        if (
+                            "schema" in json_content
+                            and "$ref" in json_content["schema"]
+                        ):
+                            ref = json_content["schema"]["$ref"]
+                            model_name = ref.split("/")[-1]
+                            if model_name in schema["components"]["schemas"]:
+                                model_schema = schema["components"]["schemas"][
+                                    model_name
+                                ]
+                                if "example" in model_schema:
+                                    json_content["example"] = model_schema["example"]
+        except KeyError:
+            pass
+
+    def _process_response_examples(
+        self, path: str, method: str, schema: Dict[str, Any]
+    ) -> None:
+        """
+        Process response body to include examples from model config.
+
+        Args:
+            path: Route path
+            method: HTTP method
+            schema: OpenAPI schema to modify
+        """
+        try:
+            route_schema = schema["paths"][path][method]
+            if "responses" in route_schema:
+                responses = route_schema["responses"]
+                if "200" in responses:
+                    response = responses["200"]
+                    if "content" in response:
+                        content = response["content"]
+                        if "application/json" in content:
+                            json_content = content["application/json"]
+                            if (
+                                "schema" in json_content
+                                and "$ref" in json_content["schema"]
+                            ):
+                                ref = json_content["schema"]["$ref"]
+                                model_name = ref.split("/")[-1]
+                                if model_name in schema["components"]["schemas"]:
+                                    model_schema = schema["components"]["schemas"][
+                                        model_name
+                                    ]
+                                    if "example" in model_schema:
+                                        json_content["example"] = model_schema[
+                                            "example"
+                                        ]
+        except KeyError:
+            pass
+
+    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
+        """
+        # Check if route is protected based on dynamic routing info
+        if path in self.protected_routes and method in self.protected_routes[path]:
+            schema["paths"][path][method]["security"] = [
+                {"Bearer Auth": []},
+            ]
+            schema["paths"][path][method]["responses"].update(
+                self._create_common_responses()
+            )
+
+        # Process request body examples
+        self._process_request_body(path, method, schema)
+        # Process response examples
+        self._process_response_examples(path, method, schema)
+
+    def create_schema(self) -> Dict[str, Any]:
+        """
+        Create the complete OpenAPI schema.
+
+        Returns:
+            Dict[str, Any]: Complete OpenAPI schema
+        """
+        openapi_schema = get_openapi(
+            title=Config.TITLE,
+            description=Config.DESCRIPTION,
+            version="1.1.1",
+            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()

ApiLayers/AllConfigs/Email/configs.py

@@ -0,0 +1,18 @@
+from AllConfigs import HostConfig
+
+
+class EmailConfig:
+    EMAIL_HOST: str = HostConfig.EMAIL_HOST
+    EMAIL_USERNAME: str = "karatay@mehmetkaratay.com.tr"
+    EMAIL_PASSWORD: str = "system"
+    EMAIL_PORT: int = 587
+    EMAIL_SEND: bool = False
+
+    @classmethod
+    def as_dict(cls):
+        return dict(
+            host=EmailConfig.EMAIL_HOST,
+            port=EmailConfig.EMAIL_PORT,
+            username=EmailConfig.EMAIL_USERNAME,
+            password=EmailConfig.EMAIL_PASSWORD,
+        )

ApiLayers/AllConfigs/Email/email_send_model.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+
+
+class EmailSendModel(BaseModel):
+    subject: str
+    html: str = ""
+    receivers: List[str]
+    text: Optional[str] = ""
+    cc: Optional[List[str]] = None
+    bcc: Optional[List[str]] = None
+    headers: Optional[Dict] = None
+    attachments: Optional[Dict] = None

ApiLayers/AllConfigs/NoSqlDatabase/configs.py

@@ -0,0 +1,10 @@
+from AllConfigs import HostConfig
+
+
+class MongoConfig:
+    PASSWORD = "mongo_password"
+    USER_NAME = "mongo_user"
+    DATABASE_NAME = "mongo_database"
+    HOST = HostConfig.MAIN_HOST
+    PORT = 11777
+    URL = f"mongodb://{USER_NAME}:{PASSWORD}@{HOST}:{PORT}/{DATABASE_NAME}?retryWrites=true&w=majority"

ApiLayers/AllConfigs/Redis/configs.py

@@ -0,0 +1,29 @@
+from AllConfigs import HostConfig
+
+
+class WagRedis:
+    REDIS_HOST = HostConfig.MAIN_HOST
+    REDIS_PASSWORD: str = "commercial_redis_password"
+    REDIS_PORT: int = 11222
+    REDIS_DB: int = 0
+
+    @classmethod
+    def as_dict(cls):
+        return dict(
+            host=WagRedis.REDIS_HOST,
+            password=WagRedis.REDIS_PASSWORD,
+            port=WagRedis.REDIS_PORT,
+            db=WagRedis.REDIS_DB,
+        )
+
+class RedisCategoryKeys:
+    LANGUAGE_MODELS: str = "LANGUAGE_MODELS"
+    VALIDATION_USER: str = "VALIDATION_USER"
+    CLUSTER_FUNCTION_CODES: str = "CLUSTER_FUNCTION_CODES"
+    METHOD_FUNCTION_CODES: str = "METHOD_FUNCTION_CODES"
+    MENU_FIRST_LAYER: str = "MENU_FIRST_LAYER"
+    PAGE_MAPPER: str = "PAGE_MAPPER"
+    MENU_MAPPER: str = "MENU_MAPPER"
+    AUTH: str = "AUTH"
+    OCC: str = "Occupant"
+    EMP: str = "Employee"

ApiLayers/AllConfigs/SqlDatabase/configs.py

@@ -0,0 +1,17 @@
+from AllConfigs import HostConfig
+
+
+class WagDatabase:
+    HOST: str = HostConfig.MAIN_HOST
+    PORT: str = "5444"
+    SQL: str = "postgresql+psycopg2"
+    USERNAME: str = "berkay_wag_user"
+    PASSWORD: str = "berkay_wag_user_password"
+    DATABASE_NAME: str = "wag_database"
+    DATABASE_URL: str = f"{SQL}://{USERNAME}:{PASSWORD}@{HOST}:{PORT}/{DATABASE_NAME}"
+
+
+class PaginateConfig:
+    DEFAULT_SIZE = 10
+    MIN_SIZE = 10
+    MAX_SIZE = 50

ApiLayers/AllConfigs/Token/config.py

@@ -0,0 +1,71 @@
+import datetime
+
+
+class ApiStatic:
+    PLACEHOLDER = "https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg"
+    FORGOT_LINK = "https://www.evyos.com.tr/password/create?tokenUrl="
+    BLACKLIST_LINK = "https://www.evyos.com.tr/support/unknown-login-notice/"
+    APP_DIR = "/home/berkay/git-evyos/api-managment-backend/"
+
+    @classmethod
+    def forgot_link(cls, forgot_key):
+        return cls.FORGOT_LINK + forgot_key
+
+    @classmethod
+    def blacklist_login(cls, record_id):
+        return cls.BLACKLIST_LINK + record_id
+
+
+class Auth:
+    ACCESS_EMAIL_EXT = "evyos.com.tr"
+    ACCESS_TOKEN_TAG = "evyos-session-key"
+    REFRESHER_TOKEN_TAG = "eys-session-refresher"
+    SECRET_KEY_72 = (
+        "t3sUAmjTGeTgDc6dAUrB41u2SNg0ZHzj4HTjem95y3fRH1nZXOHIBj163kib6iLybT0gLaxq"
+    )
+    SECRET_KEY_96 = "7ct8VpiwaP1hR2bVSet4dEEAgepuTZUOnO1QxOgKyDqBR2PkqNhcubSrbUUigQKoQA1PBoeeQn5ZCo24pESmVtKs76nA4EKq"
+    SECRET_KEY_144 = (
+        "R2p5Rq6KCr6PCfjFYUeH1keF2VWHFEuqINVjBGGnvRA2m10pYUKqfOtIGBcaj2v5wZmElDndzSHGOS7roQsoTelPSok0"
+        + "qqMucurMWE0FGexGpFuJkfPEm9tH2OjMOqegvEetpSVywH0W4Kh4"
+    )
+
+    ALGORITHM = "HS256"
+    ACCESS_TOKEN_LENGTH: int = 90
+    REFRESHER_TOKEN_LENGTH: int = 144
+    PASSWORD_EXPIRE_DAY = datetime.timedelta(days=30)
+    TOKEN_EXPIRE_MINUTES_1 = datetime.timedelta(minutes=1)
+    TOKEN_EXPIRE_MINUTES_15 = datetime.timedelta(minutes=15)
+    TOKEN_EXPIRE_MINUTES_30 = datetime.timedelta(minutes=30)
+    TOKEN_EXPIRE_DAY_1 = datetime.timedelta(days=1)
+    TOKEN_EXPIRE_DAY_5 = datetime.timedelta(days=5)
+    TOKEN_EXPIRE_DAY_15 = datetime.timedelta(days=15)
+    TOKEN_EXPIRE_DAY_30 = datetime.timedelta(days=30)
+
+
+class Routers:
+    NO_TOKEN_REQUIRES = [
+        "/",
+        "/metrics",
+        "/openapi.json",
+        "/docs",
+        "/redoc",
+        "/auth/login",
+        "/favicon.ico",
+        "/docs/oauth2-redirect",
+        "/authentication/select",
+        "/authentication/login",
+        "/authentication/logout",
+        "/authentication/refresher",
+        "/authentication/refresh",
+        "/authentication/disconnect",
+        "/authentication/create_password",
+        "/authentication/reset_password",
+        "/authentication/forgot",
+        "/authentication/valid",
+    ]
+    NO_EVENT_REQUIRES = [
+        "/access/endpoints/available",
+        "/access/endpoint/available",
+        "/validations/endpoint",
+        "/authentication/avatar",
+    ]

ApiLayers/AllConfigs/__init__.py

@@ -0,0 +1,3 @@
+from .main import HostConfig
+
+__all__ = ["HostConfig"]

ApiLayers/AllConfigs/main.py

@@ -0,0 +1,19 @@
+class HostConfig:
+    MAIN_HOST = "10.10.2.36"  # http://10.10.2.36
+    EMAIL_HOST = "10.10.2.34"  # http://10.10.2.34
+
+
+class MainConfig:
+
+    APP_NAME = "evyos-web-api-gateway"
+    TITLE = "WAG API Web Api Gateway"
+    DESCRIPTION = "This api is serves as web api gateway only to evyos web services."
+    APP_URL = "https://www.wag.eys.gen.tr"
+
+    DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss Z"
+    DATETIME_FORMAT_JS = "YYYY-MM-DD HH:mm:ss +0"
+
+    # Timezone Configuration
+    DEFAULT_TIMEZONE = "GMT+3"  # Default timezone for the application
+    SYSTEM_TIMEZONE = "GMT+0"  # System timezone (used for internal operations)
+    SUPPORTED_TIMEZONES = ["GMT+0", "GMT+3"]  # List of supported timezones

ApiLayers/ApiLibrary/__init__.py

@@ -0,0 +1,16 @@
+from ApiLibrary.date_time_actions.date_functions import (
+    DateTimeLocal,
+    system_arrow,
+    client_arrow,
+)
+from ApiLibrary.extensions.select import SelectActionWithEmployee, SelectAction
+from ApiLibrary.common.line_number import get_line_number_for_error
+
+__all__ = [
+    "DateTimeLocal",
+    "system_arrow",
+    "client_arrow",
+    "get_line_number_for_error",
+    "SelectActionWithEmployee",
+    "SelectAction",
+]

ApiLayers/ApiLibrary/common/line_number.py

@@ -0,0 +1,14 @@
+"""Utility functions for getting line numbers and file locations."""
+
+from inspect import currentframe, getframeinfo, stack
+
+
+def get_line_number_for_error() -> str:
+    """Get the file name and line number of where an error occurred.
+
+    Returns:
+        str: A string in the format 'filename | line_number' showing where the error occurred
+    """
+    caller = stack()[1]  # Get the caller's frame
+    frameinfo = getframeinfo(caller[0])
+    return f"{frameinfo.filename} | {frameinfo.lineno}"

ApiLayers/ApiLibrary/date_time_actions/date_functions.py

@@ -0,0 +1,116 @@
+import arrow
+import calendar
+from AllConfigs.main import MainConfig as Config
+
+
+class DateTimeLocal:
+
+    def __init__(self, timezone: str = None, is_client: bool = True):
+        if timezone and timezone not in Config.SUPPORTED_TIMEZONES:
+            raise ValueError(
+                f"Unsupported timezone: {timezone}. Must be one of {Config.SUPPORTED_TIMEZONES}"
+            )
+
+        self.timezone = Config.SYSTEM_TIMEZONE
+        if is_client:
+            self.timezone = (timezone or Config.DEFAULT_TIMEZONE).replace("-", "+")
+
+    def find_last_day_of_month(self, date_value):
+        today = self.get(date_value).date()
+        _, last_day = calendar.monthrange(today.year, today.month)
+        return self.get(today.year, today.month, last_day, 23, 59, 59).to(self.timezone)
+
+    def find_first_day_of_month(self, date_value):
+        today = self.get(date_value).date()
+        return self.get(today.year, today.month, 1).to(self.timezone)
+
+    def get(self, *args):
+        return arrow.get(*args).to(str(self.timezone))
+
+    def now(self):
+        return arrow.now().to(str(self.timezone))
+
+    def shift(self, date, **kwargs):
+        return self.get(date).shift(**kwargs)
+
+    def date(self, date):
+        return self.get(date).date()
+
+    def time(self, date):
+        return self.get(date).time()
+
+    def string_date(self, date, splitter: str = "-"):
+        return str(self.get(date).date()).replace("-", splitter)
+
+    def string_time_only(self, date):
+        return self.get(date).format("HH:mm:ss")
+
+    def string_date_only(self, date):
+        return self.get(date).format("YYYY-MM-DD")
+
+    def to_timestamp(self, date):
+        """Convert datetime to UTC timestamp"""
+        return self.get(date).timestamp()
+
+    def from_timestamp(self, timestamp):
+        """Convert timestamp to timezone-aware datetime"""
+        return arrow.get(timestamp).to(str(self.timezone))
+
+    def is_timezone_aware(self, date):
+        """Check if a date is timezone-aware"""
+        return self.get(date).tzinfo is not None
+
+    def standardize_timezone(self, date):
+        """Ensure date is in the correct timezone"""
+        if not self.is_timezone_aware(date):
+            return self.get(date).to(str(self.timezone))
+        return self.get(date)
+
+    def get_expiry_time(self, **kwargs):
+        """Get future time for cache expiry
+        Example: get_expiry_time(hours=1, minutes=30)
+        """
+        return self.now().shift(**kwargs)
+
+    def is_expired(self, timestamp):
+        """Check if a timestamp is expired"""
+        if not timestamp:
+            return True
+        return self.from_timestamp(timestamp) < self.now()
+
+    def get_cache_key(self, base_key, *args):
+        """Generate a cache key with timezone info
+        Example: get_cache_key('user_profile', user_id, 'details')
+        """
+        components = [str(base_key)]
+        components.extend(str(arg) for arg in args)
+        components.append(f"tz_{self.timezone}")
+        return ":".join(components)
+
+    def format_for_db(self, date):
+        """Format date for database storage"""
+        return self.get(date).format("YYYY-MM-DD HH:mm:ss.SSSZZ")
+
+    def parse_from_db(self, date_str):
+        """Parse date from database format"""
+        if not date_str:
+            return None
+        return self.get(date_str)
+
+    def get_day_boundaries(self, date=None):
+        """Get start and end of day in current timezone"""
+        dt = self.get(date) if date else self.now()
+        start = dt.floor("day")
+        end = dt.ceil("day")
+        return start, end
+
+    def get_month_boundaries(self, date=None):
+        """Get start and end of month in current timezone"""
+        dt = self.get(date) if date else self.now()
+        start = dt.floor("month")
+        end = dt.ceil("month")
+        return start, end
+
+
+client_arrow = DateTimeLocal(is_client=True)
+system_arrow = DateTimeLocal(is_client=False)

ApiLayers/ApiLibrary/extensions/select.py

@@ -0,0 +1,76 @@
+class SelectorsBase:
+    @classmethod
+    def add_confirmed_filter(cls, first_table, second_table) -> tuple:
+        return (
+            first_table.active == True,
+            first_table.is_confirmed == True,
+            first_table.deleted == False,
+            second_table.active == True,
+            second_table.is_confirmed == True,
+            second_table.deleted == False,
+        )
+
+
+class SelectActionWithEmployee:
+
+    @classmethod
+    def select_action(cls, employee_id, filter_expr: list = None):
+        if filter_expr is not None:
+            filter_expr = (cls.__many__table__.employee_id == employee_id, *filter_expr)
+            data = (
+                cls.session.query(cls.id)
+                .select_from(cls)
+                .join(cls.__many__table__, cls.__many__table__.member_id == cls.id)
+                .filter(
+                    *filter_expr,
+                    *SelectorsBase.add_confirmed_filter(
+                        first_table=cls, second_table=cls.__many__table__
+                    ),
+                )
+            )
+            return cls.query.filter(cls.id.in_([comp[0] for comp in data.all()]))
+        data = (
+            cls.session.query(cls.id)
+            .select_from(cls)
+            .join(cls.__many__table__, cls.__many__table__.member_id == cls.id)
+            .filter(
+                cls.__many__table__.employee_id == employee_id,
+                *SelectorsBase.add_confirmed_filter(
+                    first_table=cls, second_table=cls.__many__table__
+                ),
+            )
+        )
+        return cls.query.filter(cls.id.in_([comp[0] for comp in data.all()]))
+
+
+class SelectAction:
+
+    @classmethod
+    def select_action(cls, duty_id_list: list, filter_expr: list = None):
+        if filter_expr is not None:
+            data = (
+                cls.session.query(cls.id)
+                .select_from(cls)
+                .join(cls.__many__table__, cls.__many__table__.member_id == cls.id)
+                .filter(
+                    cls.__many__table__.duties_id.in_(duty_id_list),
+                    *SelectorsBase.add_confirmed_filter(
+                        first_table=cls, second_table=cls.__many__table__
+                    ),
+                    *filter_expr,
+                )
+            )
+            return cls.query.filter(cls.id.in_([comp[0] for comp in data.all()]))
+
+        data = (
+            cls.session.query(cls.id)
+            .select_from(cls)
+            .join(cls.__many__table__, cls.__many__table__.member_id == cls.id)
+            .filter(
+                cls.__many__table__.duties_id.in_(duty_id_list),
+                *SelectorsBase.add_confirmed_filter(
+                    first_table=cls, second_table=cls.__many__table__
+                ),
+            )
+        )
+        return cls.query.filter(cls.id.in_([comp[0] for comp in data.all()]))

ApiLayers/ApiLibrary/token/password_module.py

@@ -0,0 +1,43 @@
+import hashlib
+import uuid
+import secrets
+import random
+
+from AllConfigs.Token.config import Auth
+
+
+class PasswordModule:
+
+    @staticmethod
+    def generate_random_uu_id(str_std: bool = True):
+        return str(uuid.uuid4()) if str_std else uuid.uuid4()
+
+    @staticmethod
+    def generate_token(length=32):
+        letters = "abcdefghijklmnopqrstuvwxyz"
+        merged_letters = [letter for letter in letters] + [
+            letter.upper() for letter in letters
+        ]
+        token_generated = secrets.token_urlsafe(length)
+        for i in str(token_generated):
+            if i not in merged_letters:
+                token_generated = token_generated.replace(
+                    i, random.choice(merged_letters), 1
+                )
+        return token_generated
+
+    @staticmethod
+    def generate_access_token():
+        return secrets.token_urlsafe(Auth.ACCESS_TOKEN_LENGTH)
+
+    @staticmethod
+    def generate_refresher_token():
+        return secrets.token_urlsafe(Auth.REFRESHER_TOKEN_LENGTH)
+
+    @staticmethod
+    def create_hashed_password(domain: str, id_: str, password: str):
+        return hashlib.sha256(f"{domain}:{id_}:{password}".encode("utf-8")).hexdigest()
+
+    @classmethod
+    def check_password(cls, domain, id_, password, password_hashed):
+        return cls.create_hashed_password(domain, id_, password) == password_hashed

ApiLayers/ApiServices/Login/user_login_handler.py

@@ -0,0 +1,71 @@
+from typing import Any, ClassVar, Dict
+from sqlalchemy import or_
+from ApiLibrary.common.line_number import get_line_number_for_error
+from Schemas import Users
+from ErrorHandlers import HTTPExceptionApi
+from ApiValidations.Request.authentication import Login
+from ApiLibrary.token.password_module import PasswordModule
+from ApiServices.Token.token_handler import TokenService
+
+
+class UserLoginModule:
+
+    def __init__(self, request: "Request"):
+        self.request = request
+
+    @staticmethod
+    async def check_user_exists(access_key) -> ClassVar[Users]:
+        """Check if user exists."""
+        db_session = Users.new_session()
+        if "@" in access_key:
+            found_user = Users.filter_one(
+                Users.email == access_key.lower(), db=db_session
+            ).data
+        else:
+            found_user = Users.filter_one(
+                Users.phone_number == access_key.replace(" ", ""), db=db_session
+            ).data
+        if not found_user:
+            raise HTTPExceptionApi(
+                error_code="HTTP_400_BAD_REQUEST",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="User not found",
+            )
+        return found_user
+
+    async def login_user_via_credentials(self, access_data: "Login") -> Dict[str, Any]:
+        """Login user via credentials."""
+        # Get the actual data from the BaseRequestModel if needed
+        if hasattr(access_data, "data"):
+            access_data = access_data.data
+
+        found_user: Users = await self.check_user_exists(
+            access_key=access_data.access_key
+        )
+        if len(found_user.hash_password) < 5:
+            raise HTTPExceptionApi(
+                error_code="HTTP_400_BAD_REQUEST",
+                lang=found_user.lang,
+                loc=get_line_number_for_error(),
+                sys_msg="Invalid password create a password to user first",
+            )
+
+        if PasswordModule.check_password(
+            domain=access_data.domain,
+            id_=found_user.uu_id,
+            password=access_data.password,
+            password_hashed=found_user.hash_password,
+        ):
+            return TokenService.set_access_token_to_redis(
+                request=self.request,
+                user=found_user,
+                domain=access_data.domain,
+                remember=access_data.remember_me,
+            )
+        raise HTTPExceptionApi(
+            error_code="HTTP_400_BAD_REQUEST",
+            lang=found_user.lang,
+            loc=get_line_number_for_error(),
+            sys_msg="login_user_via_credentials raised error",
+        )

ApiLayers/ApiServices/Token/token_handler.py

@@ -0,0 +1,444 @@
+"""Token service for handling authentication tokens and user sessions."""
+
+from typing import List, Union, TypeVar, Dict, Any, Optional, TYPE_CHECKING
+
+from AllConfigs.Token.config import Auth
+from ApiLibrary.common.line_number import get_line_number_for_error
+from ApiLibrary.date_time_actions.date_functions import DateTimeLocal
+from ApiLibrary.token.password_module import PasswordModule
+from ErrorHandlers import HTTPExceptionApi
+from Schemas.identity.identity import UsersTokens, People
+from Services.Redis import RedisActions, AccessToken
+from ApiValidations.Custom.token_objects import (
+    EmployeeTokenObject,
+    OccupantTokenObject,
+    UserType,
+    CompanyToken,
+    OccupantToken,
+)
+from Schemas import (
+    Users,
+    BuildLivingSpace,
+    BuildParts,
+    Employees,
+    Addresses,
+    Companies,
+    Staff,
+    Duty,
+    Duties,
+    Departments,
+    OccupantTypes,
+)
+from Services.Redis.Models.response import RedisResponse
+
+if TYPE_CHECKING:
+    from fastapi import Request
+
+T = TypeVar("T", EmployeeTokenObject, OccupantTokenObject)
+
+
+class TokenService:
+    """Service class for handling authentication tokens and user sessions."""
+
+    @classmethod
+    def _create_access_token(cls, access: bool = True) -> str:
+        """Generate a new access token."""
+        if not access:
+            return PasswordModule.generate_token(Auth.REFRESHER_TOKEN_LENGTH)
+        return PasswordModule.generate_token(Auth.ACCESS_TOKEN_LENGTH)
+
+    @classmethod
+    def _get_user_tokens(cls, user: Users) -> RedisResponse:
+        """Get all tokens for a user from Redis."""
+        return RedisActions.get_json(
+            list_keys=AccessToken(
+                userUUID=user.uu_id,
+            ).to_list()
+        )
+
+    @classmethod
+    def do_occupant_login(
+        cls, request: "Request", user: Users, domain: str
+    ) -> Dict[str, Any]:
+        """Handle occupant login process and return login information."""
+        db_session = BuildLivingSpace.new_session()
+        living_spaces: list[BuildLivingSpace] = BuildLivingSpace.filter_all(
+            BuildLivingSpace.person_id == user.person_id, db=db_session
+        ).data
+        if not living_spaces:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="User does not have any living space",
+            )
+
+        occupants_selection_dict: Dict[str, Any] = {}
+        for living_space in living_spaces:
+            build_parts_selection = BuildParts.filter_all(
+                BuildParts.id == living_space.build_parts_id,
+                db=db_session,
+            ).data
+            if not build_parts_selection:
+                raise HTTPExceptionApi(
+                    error_code="",
+                    lang="en",
+                    loc=get_line_number_for_error(),
+                    sys_msg="User does not have any living space",
+                )
+
+            build_part = build_parts_selection.get(1)
+            build = build_part.buildings
+            occupant_type = OccupantTypes.filter_by_one(
+                id=living_space.occupant_type,
+                db=db_session,
+                system=True,
+            ).data
+
+            occupant_data = {
+                "part_uu_id": str(build_part.uu_id),
+                "part_name": build_part.part_name,
+                "part_level": build_part.part_level,
+                "uu_id": str(occupant_type.uu_id),
+                "description": occupant_type.occupant_description,
+                "code": occupant_type.occupant_code,
+            }
+
+            build_key = str(build.uu_id)
+            if build_key not in occupants_selection_dict:
+                occupants_selection_dict[build_key] = {
+                    "build_uu_id": build_key,
+                    "build_name": build.build_name,
+                    "build_no": build.build_no,
+                    "occupants": [occupant_data],
+                }
+            else:
+                occupants_selection_dict[build_key]["occupants"].append(occupant_data)
+        model_value = OccupantTokenObject(
+            domain=domain,
+            user_type=UserType.occupant.value,
+            user_uu_id=str(user.uu_id),
+            credentials=user.credentials(),
+            user_id=user.id,
+            person_id=user.person_id,
+            person_uu_id=str(user.person.uu_id),
+            request=dict(request.headers),
+            available_occupants=occupants_selection_dict,
+            timezone=user.local_timezone or "GMT+0",
+            lang=user.lang or "tr",
+        ).model_dump()
+        if access_token := cls.set_object_to_redis(user, model_value):
+            return {
+                "access_token": access_token,
+                "user_type": UserType.occupant.name,
+                "available_occupants": occupants_selection_dict,
+            }
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Creating Token failed...",
+        )
+
+    @classmethod
+    def set_object_to_redis(cls, user, model: Dict):
+        access_object = AccessToken(
+            userUUID=user.uu_id,
+            accessToken=cls._create_access_token(),
+        )
+        redis_action = RedisActions.set_json(
+            list_keys=access_object.to_list(),
+            value=model,
+            expires={"seconds": int(Auth.TOKEN_EXPIRE_MINUTES_30.seconds)},
+        )
+        if redis_action.status:
+            return access_object.accessToken
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Saving Token failed...",
+        )
+
+    @classmethod
+    def update_object_to_redis(cls, access_token: str, user_uu_id: str, model: Dict):
+        access_object = AccessToken(
+            userUUID=user_uu_id,
+            accessToken=access_token,
+        )
+        redis_action = RedisActions.set_json(
+            list_keys=access_object.to_list(),
+            value=model,
+            expires={"seconds": int(Auth.TOKEN_EXPIRE_MINUTES_30.seconds)},
+        )
+        if redis_action.status:
+            return access_object.accessToken
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Saving Token failed...",
+        )
+
+    @classmethod
+    def do_employee_login(
+        cls, request: "Request", user: Users, domain: str
+    ) -> Dict[str, Any]:
+        """Handle employee login process and return login information."""
+        db_session = Employees.new_session()
+        list_employee = Employees.filter_all(
+            Employees.people_id == user.person_id, db=db_session
+        ).data
+
+        companies_uu_id_list: List[str] = []
+        companies_id_list: List[int] = []
+        companies_list: List[Dict[str, Any]] = []
+        duty_uu_id_list: List[str] = []
+        duty_id_list: List[int] = []
+
+        for employee in list_employee:
+            staff = Staff.filter_one(Staff.id == employee.staff_id, db=db_session).data
+            if duties := Duties.filter_one(
+                Duties.id == staff.duties_id, db=db_session
+            ).data:
+                if duty_found := Duty.filter_by_one(
+                    id=duties.duties_id, db=db_session
+                ).data:
+                    duty_uu_id_list.append(str(duty_found.uu_id))
+                    duty_id_list.append(duty_found.id)
+
+            department = Departments.filter_one(
+                Departments.id == duties.department_id, db=db_session
+            ).data
+
+            if company := Companies.filter_one(
+                Companies.id == department.company_id, db=db_session
+            ).data:
+                companies_uu_id_list.append(str(company.uu_id))
+                companies_id_list.append(company.id)
+                company_address = Addresses.filter_by_one(
+                    id=company.official_address_id, db=db_session
+                ).data
+                companies_list.append(
+                    {
+                        "uu_id": str(company.uu_id),
+                        "public_name": company.public_name,
+                        "company_type": company.company_type,
+                        "company_address": company_address,
+                    }
+                )
+        person = People.filter_one(People.id == user.person_id, db=db_session).data
+        model_value = EmployeeTokenObject(
+            domain=domain,
+            user_type=UserType.employee.value,
+            user_uu_id=str(user.uu_id),
+            credentials=user.credentials(),
+            user_id=user.id,
+            person_id=person.id,
+            person_uu_id=str(person.uu_id),
+            request=dict(request.headers),
+            companies_uu_id_list=companies_uu_id_list,
+            companies_id_list=companies_id_list,
+            duty_uu_id_list=duty_uu_id_list,
+            duty_id_list=duty_id_list,
+            timezone=user.local_timezone or "GMT+0",
+            lang=user.lang or "tr",
+        ).model_dump()
+        if access_token := cls.set_object_to_redis(user, model_value):
+            return {
+                "access_token": access_token,
+                "user_type": UserType.employee.name,
+                "companies_list": companies_list,
+            }
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Creating Token failed...",
+        )
+
+    @classmethod
+    def remove_token_with_domain(cls, user: Users, domain: str) -> None:
+        """Remove all tokens for a user with specific domain."""
+        redis_rows = cls._get_user_tokens(user)
+        for redis_row in redis_rows.all:
+            if redis_row.data.get("domain") == domain:
+                RedisActions.delete_key(redis_row.key)
+
+    @classmethod
+    def remove_all_token(cls, user: Users) -> None:
+        """Remove all tokens for a user."""
+        redis_rows = cls._get_user_tokens(user)
+        RedisActions.delete([redis_row.key for redis_row in redis_rows.all])
+
+    @classmethod
+    def set_access_token_to_redis(
+        cls,
+        request: "Request",
+        user: Users,
+        domain: str,
+        remember: bool,
+    ) -> Dict[str, Any]:
+        """Set access token to redis and handle user session."""
+        cls.remove_token_with_domain(user=user, domain=domain)
+        Users.client_arrow = DateTimeLocal(is_client=True, timezone=user.local_timezone)
+        db_session = UsersTokens.new_session()
+        # Handle login based on user type
+        if user.is_occupant:
+            login_dict = cls.do_occupant_login(
+                request=request, user=user, domain=domain
+            )
+        elif user.is_employee:
+            login_dict = cls.do_employee_login(
+                request=request, user=user, domain=domain
+            )
+
+        # Handle remember me functionality
+        if remember:
+            users_token = UsersTokens.find_or_create(
+                db=db_session,
+                user_id=user.id,
+                token_type="RememberMe",
+                token=cls._create_access_token(access=False),
+                domain=domain,
+            )
+            if users_token.meta_data.get("created"):
+                user.remember_me = True
+        else:
+            if UsersTokens.filter_all(
+                UsersTokens.user_id == user.id,
+                UsersTokens.token_type == "RememberMe",
+                UsersTokens.domain == domain,
+                db=db_session,
+            ).data:
+                UsersTokens.filter_all(
+                    UsersTokens.user_id == user.id,
+                    UsersTokens.token_type == "RememberMe",
+                    UsersTokens.domain == domain,
+                    db=db_session,
+                ).query.delete(synchronize_session=False)
+            user.remember_me = False
+        user.save(db=db_session)
+        return {
+            **login_dict,
+            "user": user.get_dict(),
+        }
+
+    @classmethod
+    def update_token_at_redis(
+        cls, request: "Request", add_payload: Union[CompanyToken, OccupantToken]
+    ) -> Dict[str, Any]:
+        """Update token at Redis."""
+        access_token = cls.get_access_token_from_request(request=request)
+        token_object = cls.get_object_via_access_key(access_token=access_token)
+        if isinstance(token_object, EmployeeTokenObject) and isinstance(
+            add_payload, CompanyToken
+        ):
+            token_object.selected_company = add_payload
+            cls.update_object_to_redis(
+                access_token=access_token,
+                user_uu_id=token_object.user_uu_id,
+                model=token_object.model_dump(),
+            )
+            return token_object.selected_company.model_dump()
+        elif isinstance(token_object, OccupantTokenObject) and isinstance(
+            add_payload, OccupantToken
+        ):
+            token_object.selected_occupant = add_payload
+            cls.update_object_to_redis(
+                access_token=access_token,
+                user_uu_id=token_object.user_uu_id,
+                model=token_object.model_dump(),
+            )
+            return token_object.selected_occupant.model_dump()
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Token not found",
+        )
+
+    @classmethod
+    def raise_error_if_request_has_no_token(cls, request: "Request") -> None:
+        """Validate request has required token headers."""
+        if not hasattr(request, "headers"):
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Request has no headers",
+            )
+        if not request.headers.get(Auth.ACCESS_TOKEN_TAG):
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Request has no access token presented",
+            )
+
+    @classmethod
+    def access_token_is_valid(cls, request: "Request") -> bool:
+        """Check if access token in request is valid."""
+        access_token = cls.get_access_token_from_request(request=request)
+        return RedisActions.get_json(
+            list_keys=AccessToken(accessToken=access_token).to_list()
+        ).status
+
+    @classmethod
+    def get_access_token_from_request(cls, request: "Request") -> str:
+        """Extract access token from request headers."""
+        cls.raise_error_if_request_has_no_token(request=request)
+        return request.headers.get(Auth.ACCESS_TOKEN_TAG)
+
+    @classmethod
+    def _process_redis_object(cls, redis_object: Dict[str, Any]) -> T:
+        """Process Redis object and return appropriate token object."""
+        if not redis_object.get("selected_company"):
+            redis_object["selected_company"] = None
+        if not redis_object.get("selected_occupant"):
+            redis_object["selected_occupant"] = None
+        if redis_object.get("user_type") == UserType.employee.value:
+            return EmployeeTokenObject(**redis_object)
+        elif redis_object.get("user_type") == UserType.occupant.value:
+            return OccupantTokenObject(**redis_object)
+
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Unknown user type",
+        )
+
+    @classmethod
+    def get_object_via_access_key(cls, access_token: str) -> T:
+        """Get token object using access key."""
+        access_token_obj = AccessToken(accessToken=access_token)
+        redis_response = RedisActions.get_json(list_keys=access_token_obj.to_list())
+        if not redis_response.status:
+            raise HTTPExceptionApi(
+                error_code="",
+                lang="en",
+                loc=get_line_number_for_error(),
+                sys_msg="Access token token is not found or unable to retrieve",
+            )
+        if redis_object := redis_response.first:
+            redis_object_dict = redis_object.data
+            access_token_obj.userUUID = redis_object_dict.get("user_uu_id")
+            return cls._process_redis_object(redis_object_dict)
+
+    @classmethod
+    def get_object_via_user_uu_id(cls, user_id: str) -> T:
+        """Get token object using user UUID."""
+        access_token = AccessToken(userUUID=user_id)
+        redis_response = RedisActions.get_json(list_keys=access_token.to_list())
+
+        if redis_object := redis_response.first.data:
+            access_token.userUUID = redis_object.get("user_uu_id")
+            return cls._process_redis_object(redis_object)
+
+        raise HTTPExceptionApi(
+            error_code="",
+            lang="en",
+            loc=get_line_number_for_error(),
+            sys_msg="Invalid access token",
+        )

ApiLayers/ApiServices/__init__.py

@@ -0,0 +1,5 @@
+from ApiServices.Token.token_handler import TokenService
+
+__all__ = [
+    "TokenService",
+]

ApiLayers/ApiValidations/Custom/token_objects.py

@@ -0,0 +1,121 @@
+import enum
+from typing import Optional, List, Any
+from pydantic import BaseModel
+
+
+# Company / Priority / Department / Duty / Employee / Occupant / Module / Endpoint are changeable dynamics
+
+
+class UserType(enum.Enum):
+
+    employee = 1
+    occupant = 2
+
+
+class Credentials(BaseModel):
+
+    person_id: int
+    person_name: str
+
+
+class ApplicationToken(BaseModel):
+    # Application Token Object -> is the main object for the user
+
+    domain: Optional[str] = "app.evyos.com.tr"
+    lang: Optional[str] = "TR"
+    timezone: Optional[str] = "GMT+3"
+
+    user_type: int = UserType.occupant.value
+    credentials: dict = None
+
+    user_uu_id: str
+    user_id: int
+
+    person_id: int
+    person_uu_id: str
+
+    request: Optional[dict] = None  # Request Info of Client
+    expires_at: Optional[float] = None  # Expiry timestamp
+
+
+class OccupantToken(BaseModel):
+    # Selection of the occupant type for a build part is made by the user
+
+    living_space_id: int  # Internal use
+    living_space_uu_id: str  # Outer use
+
+    occupant_type_id: int
+    occupant_type_uu_id: str
+    occupant_type: str
+
+    build_id: int
+    build_uuid: str
+    build_part_id: int
+    build_part_uuid: str
+
+    responsible_company_id: Optional[int] = None
+    responsible_company_uuid: Optional[str] = None
+    responsible_employee_id: Optional[int] = None
+    responsible_employee_uuid: Optional[str] = None
+
+    reachable_event_codes: Optional[list[str]] = None  # ID list of reachable modules
+    reachable_event_endpoints: Optional[list[str]] = None
+
+
+class CompanyToken(BaseModel):  # Required Company Object for an employee
+
+    company_id: int
+    company_uu_id: str
+
+    department_id: int  # ID list of departments
+    department_uu_id: str  # ID list of departments
+
+    duty_id: int
+    duty_uu_id: str
+
+    staff_id: int
+    staff_uu_id: str
+
+    employee_id: int
+    employee_uu_id: str
+
+    bulk_duties_id: int
+
+    reachable_event_codes: Optional[list[str]] = None  # ID list of reachable modules
+    reachable_event_endpoints: Optional[list[str]] = None
+
+
+class OccupantTokenObject(ApplicationToken):
+    # Occupant Token Object -> Requires selection of the occupant type for a specific build part
+
+    available_occupants: dict = None
+
+    selected_occupant: Optional[OccupantToken] = None  # Selected Occupant Type
+
+    @property
+    def is_employee(self) -> bool:
+        return False
+
+    @property
+    def is_occupant(self) -> bool:
+        return True
+
+
+class EmployeeTokenObject(ApplicationToken):
+    #  Full hierarchy Employee[staff_id] -> Staff -> Duty -> Department -> Company
+
+    companies_id_list: List[int]  # List of company objects
+    companies_uu_id_list: List[str]  # List of company objects
+
+    duty_id_list: List[int]  # List of duty objects
+    duty_uu_id_list: List[str]  # List of duty objects
+
+    selected_company: Optional[CompanyToken] = None  # Selected Company Object
+
+    @property
+    def is_employee(self) -> bool:
+        return True
+
+    @property
+    def is_occupant(self) -> bool:
+        return False

ApiLayers/ApiValidations/Custom/validation_response.py

@@ -0,0 +1,83 @@
+import json
+from typing import Any, ClassVar, TypeVar, Dict, Tuple, List
+from pydantic import BaseModel
+
+from ErrorHandlers import HTTPExceptionApi
+from ApiLibrary.common.line_number import get_line_number_for_error
+from ApiValidations.Request.base_validations import CrudRecords, PydanticBaseModel
+
+
+class ValidationParser:
+
+    def __init__(self, active_validation: BaseModel):
+        self.core_validation = active_validation
+        self.annotations = active_validation.model_json_schema()
+        self.annotations = json.loads(json.dumps(self.annotations))
+        self.schema = {}
+        self.parse()
+
+    def parse(self):
+        from ApiValidations.Request.base_validations import (
+            CrudRecords,
+            PydanticBaseModel,
+        )
+
+        properties = dict(self.annotations.get("properties")).items()
+        total_class_annotations = {
+            **self.core_validation.__annotations__,
+            **PydanticBaseModel.__annotations__,
+            **CrudRecords.__annotations__,
+        }
+        for key, value in properties:
+            default, required, possible_types = (
+                dict(value).get("default", None),
+                True,
+                [],
+            )
+            if dict(value).get("anyOf", None):
+                for _ in dict(value).get("anyOf") or []:
+                    type_opt = json.loads(json.dumps(_))
+                    if not type_opt.get("type") == "null":
+                        possible_types.append(type_opt.get("type"))
+                field_type = possible_types[0]
+                required = False
+            else:
+                field_type = dict(value).get("type", "string")
+            attribute_of_class = total_class_annotations.get(key, None)
+            aoc = str(attribute_of_class) if attribute_of_class else None
+            if attribute_of_class:
+                if aoc in ("<class 'str'>", "typing.Optional[str]"):
+                    field_type, required = "string", aoc == "<class 'str'>"
+                elif aoc in ("<class 'int'>", "typing.Optional[int]"):
+                    field_type, required = "integer", aoc == "<class 'int'>"
+                elif aoc in ("<class 'bool'>", "typing.Optional[bool]"):
+                    field_type, required = "boolean", aoc == "<class 'bool'>"
+                elif aoc in ("<class 'float'>", "typing.Optional[float]"):
+                    field_type, required = "float", aoc == "<class 'float'>"
+                elif aoc in (
+                    "<class 'datetime.datetime'>",
+                    "typing.Optional[datetime.datetime]",
+                ):
+                    field_type, required = (
+                        "datetime",
+                        aoc == "<class 'datetime.datetime'>",
+                    )
+            self.schema[key] = {
+                "type": field_type,
+                "required": required,
+                "default": default,
+            }
+
+
+class ValidationModel:
+
+    def __init__(self, response_model: BaseModel, language_model, language_models):
+        self.response_model = response_model
+        self.validation = None
+        self.headers = language_model
+        self.language_models = language_models
+        self.get_validation()
+
+    def get_validation(self) -> Tuple:
+        self.headers = self.language_models
+        self.validation = ValidationParser(self.response_model).schema

ApiLayers/ApiValidations/Request/__init__.py

@@ -0,0 +1,239 @@
+from .base_validations import (
+    BaseModelRegular,
+    PydanticBaseModel,
+    ListOptions,
+    CrudRecords,
+)
+from .address import (
+    InsertAddress,
+    UpdateAddress,
+    UpdatePostCode,
+    InsertPostCode,
+    SearchAddress,
+)
+from .application import (
+    SingleEnumUUID,
+    SingleEnumClassKey,
+    SingleEnumOnlyClass,
+    SingleOccupantTypeUUID,
+    SingleOccupantTypeClassKey,
+)
+from .area import (
+    InsertBuildArea,
+    InsertBuildSites,
+    UpdateBuildArea,
+    UpdateBuildSites,
+)
+from .authentication import (
+    Login,
+    Logout,
+    ChangePassword,
+    Remember,
+    Forgot,
+    CreatePassword,
+    OccupantSelection,
+    EmployeeSelection,
+)
+from .account_records import (
+    InsertAccountRecord,
+    UpdateAccountRecord,
+)
+
+from .build_living_space import (
+    InsertBuildLivingSpace,
+    UpdateBuildLivingSpace,
+)
+from .build_part import (
+    InsertBuildParts,
+    InsertBuildTypes,
+    UpdateBuildParts,
+    UpdateBuildTypes,
+)
+from .building import (
+    InsertBuild,
+    UpdateBuild,
+)
+from .company import (
+    MatchCompany2Company,
+    InsertCompany,
+    UpdateCompany,
+)
+from .decision_book import (
+    DecisionBookDecisionBookInvitations,
+    DecisionBookDecisionBookInvitationsUpdate,
+    DecisionBookDecisionBookInvitationsAttend,
+    DecisionBookDecisionBookInvitationsAssign,
+    UpdateDecisionBook,
+    UpdateBuildDecisionBookItems,
+    UpdateBuildDecisionBookItemDebits,
+    InsertBuildDecisionBookItems,
+    InsertBuildDecisionBookItemDebits,
+    InsertDecisionBookCompleted,
+    InsertDecisionBook,
+    InsertDecisionBookPerson,
+    ListDecisionBook,
+    RemoveDecisionBookPerson,
+)
+from .departments import (
+    DepartmentsPydantic,
+)
+from .employee import (
+    InsertDuties,
+    UpdateDuties,
+    InsertEmployees,
+    SelectDuties,
+    UnBindEmployees2People,
+    BindEmployees2People,
+    UpdateCompanyEmployees,
+    InsertCompanyEmployees,
+    InsertCompanyEmployeesSalaries,
+    InsertCompanyDuty,
+    UpdateCompanyEmployeesSalaries,
+    UpdateCompanyDuty,
+)
+from .events import (
+    # CreateEvents,
+    RegisterEvents2Employee,
+    RegisterEvents2Occupant,
+)
+from .people import (
+    UpdatePerson,
+    InsertPerson,
+)
+from .project_decision_book import (
+    InsertBuildDecisionBookProjectItemDebits,
+    UpdateBuildDecisionBookProjectItemDebits,
+    InsertBuildDecisionBookProjects,
+    UpdateBuildDecisionBookProjects,
+    InsertBuildDecisionBookProjectPerson,
+    UpdateBuildDecisionBookProjectPerson,
+    InsertBuildDecisionBookProjectItems,
+    UpdateBuildDecisionBookProjectItems,
+    ApprovalsBuildDecisionBookProjects,
+)
+from .rules import (
+    UpdateEndpointAccess,
+    UpdateEndpointAccessList,
+    InsertEndpointAccess,
+    CheckEndpointAccess,
+)
+from .services import (
+    RegisterServices2Employee,
+    RegisterServices2Occupant,
+)
+from .staff import (
+    InsertStaff,
+    SelectStaff,
+)
+from .user import (
+    InsertUsers,
+    UpdateUsers,
+    QueryUsers,
+    # ActiveUsers,
+    # ListUsers,
+    # DeleteUsers,
+)
+from .modules import (
+    RegisterModules2Occupant,
+    RegisterModules2Employee,
+)
+
+
+__all__ = [
+    "BaseModelRegular",
+    "PydanticBaseModel",
+    "ListOptions",
+    "CrudRecords",
+    "ListOptions",
+    "CrudRecords",
+    "PydanticBaseModel",
+    "BaseModelRegular",
+    "InsertAddress",
+    "UpdateAddress",
+    "UpdatePostCode",
+    "InsertPostCode",
+    "SearchAddress",
+    "SingleEnumUUID",
+    "SingleEnumClassKey",
+    "SingleEnumOnlyClass",
+    "SingleOccupantTypeUUID",
+    "SingleOccupantTypeClassKey",
+    "InsertBuildArea",
+    "InsertBuildSites",
+    "UpdateBuildArea",
+    "UpdateBuildSites",
+    "Login",
+    "Logout",
+    "ChangePassword",
+    "Remember",
+    "Forgot",
+    "CreatePassword",
+    "OccupantSelection",
+    "EmployeeSelection",
+    "InsertAccountRecord",
+    "UpdateAccountRecord",
+    "InsertBuildLivingSpace",
+    "UpdateBuildLivingSpace",
+    "InsertBuildParts",
+    "InsertBuildTypes",
+    "UpdateBuildParts",
+    "UpdateBuildTypes",
+    "InsertBuild",
+    "UpdateBuild",
+    "MatchCompany2Company",
+    "InsertCompany",
+    "UpdateCompany",
+    "DecisionBookDecisionBookInvitations",
+    "DecisionBookDecisionBookInvitationsUpdate",
+    "DecisionBookDecisionBookInvitationsAttend",
+    "DecisionBookDecisionBookInvitationsAssign",
+    "UpdateDecisionBook",
+    "UpdateBuildDecisionBookItems",
+    "UpdateBuildDecisionBookItemDebits",
+    "InsertBuildDecisionBookItems",
+    "InsertBuildDecisionBookItemDebits",
+    "InsertDecisionBookCompleted",
+    "InsertDecisionBook",
+    "InsertDecisionBookPerson",
+    "ListDecisionBook",
+    "RemoveDecisionBookPerson",
+    "DepartmentsPydantic",
+    "InsertDuties",
+    "UpdateDuties",
+    "InsertEmployees",
+    "SelectDuties",
+    "UnBindEmployees2People",
+    "BindEmployees2People",
+    "UpdateCompanyEmployees",
+    "InsertCompanyEmployees",
+    "InsertCompanyEmployeesSalaries",
+    "InsertCompanyDuty",
+    "UpdateCompanyEmployeesSalaries",
+    "UpdateCompanyDuty",
+    "RegisterEvents2Employee",
+    "RegisterEvents2Occupant",
+    "UpdatePerson",
+    "InsertPerson",
+    "InsertBuildDecisionBookProjectItems",
+    "UpdateBuildDecisionBookProjectItems",
+    "ApprovalsBuildDecisionBookProjects",
+    "InsertBuildDecisionBookProjectItemDebits",
+    "UpdateBuildDecisionBookProjectItemDebits",
+    "InsertBuildDecisionBookProjects",
+    "UpdateBuildDecisionBookProjects",
+    "InsertBuildDecisionBookProjectPerson",
+    "UpdateBuildDecisionBookProjectPerson",
+    "UpdateEndpointAccess",
+    "UpdateEndpointAccessList",
+    "InsertEndpointAccess",
+    "CheckEndpointAccess",
+    "RegisterServices2Employee",
+    "RegisterServices2Occupant",
+    "InsertStaff",
+    "SelectStaff",
+    "InsertUsers",
+    "UpdateUsers",
+    "QueryUsers",
+    "RegisterModules2Occupant",
+    "RegisterModules2Employee",
+]

ApiLayers/ApiValidations/Request/account_records.py

@@ -0,0 +1,159 @@
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+from typing import Optional
+
+
+class AccountValidation:
+    tr = {
+        "iban": "IBAN Numarası",
+        "bank_date": "Bank Tarih",
+        "currency_value": "Para Değeri",
+        "bank_balance": "Banka Bakiye",
+        "currency": "Para Birimi",
+        "additional_balance": "Ek Bakiye",
+        "channel_branch": "Kanal Şubesi",
+        "process_name": "İşlem Adı",
+        "process_type": "İşlem Tipi",
+        "process_comment": "İşlem Yorum",
+        "bank_reference_code": "Banka Referans Kodu",
+        "add_comment_note": "Yorum Not",
+        "is_receipt_mail_send": "Fiş Mail Gönderildi",
+        "found_from": "Bulunduğu Yer",
+        "similarity": "Benzerlik",
+        "remainder_balance": "Kalan Bakiye",
+        "bank_date_y": "Bank Tarih Yıl",
+        "bank_date_m": "Bank Tarih Ay",
+        "bank_date_w": "Bank Tarih Hafta",
+        "bank_date_d": "Bank Tarih Gün",
+        "approving_accounting_record": "Onaylayan Muhasebe Kaydı",
+        "accounting_receipt_date": "Muhasebe Fiş Tarihi",
+        "accounting_receipt_number": "Muhasebe Fiş Numarası",
+        "approved_record": "Onaylanmış Kayıt",
+        "import_file_name": "İçe Aktarım Dosya Adı",
+        "receive_debit_uu_id": "Alacak UUID",
+        "budget_type_uu_id": "Bütçe Tipi UUID",
+        "company_uu_id": "Şirket UUID",
+        "send_company_uu_id": "Gönderen Şirket UUID",
+        "customer_id": "Müşteri ID",
+        "customer_uu_id": "Müşteri UUID",
+        "send_person_uu_id": "Gönderen Kişi UUID",
+        "approving_accounting_person_uu_id": "Onaylayan Muhasebe Kişi UUID",
+        "build_parts_uu_id": "Daire UUID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+    }
+    en = {
+        "iban": "IBAN Number",
+        "bank_date": "Bank Date",
+        "currency_value": "Currency Value",
+        "bank_balance": "Bank Balance",
+        "currency": "Currency",
+        "additional_balance": "Additional Balance",
+        "channel_branch": "Channel Branch",
+        "process_name": "Process Name",
+        "process_type": "Process Type",
+        "process_comment": "Process Comment",
+        "bank_reference_code": "Bank Reference Code",
+        "add_comment_note": "Comment Note",
+        "is_receipt_mail_send": "Receipt Mail Send",
+        "found_from": "Found From",
+        "similarity": "Similarity",
+        "remainder_balance": "Remainder Balance",
+        "bank_date_y": "Bank Date Year",
+        "bank_date_m": "Bank Date Month",
+        "bank_date_w": "Bank Date Week",
+        "bank_date_d": "Bank Date Day",
+        "approving_accounting_record": "Approving Accounting Record",
+        "accounting_receipt_date": "Accounting Receipt Date",
+        "accounting_receipt_number": "Accounting Receipt Number",
+        "approved_record": "Approved Record",
+        "import_file_name": "Import File Name",
+        "receive_debit_uu_id": "Receive Debit UUID",
+        "budget_type_uu_id": "Budget Type UUID",
+        "company_uu_id": "Company UUID",
+        "send_company_uu_id": "Send Company UUID",
+        "customer_id": "Customer ID",
+        "customer_uu_id": "Customer UUID",
+        "send_person_uu_id": "Send Person UUID",
+        "approving_accounting_person_uu_id": "Approving Accounting Person UUID",
+        "build_parts_uu_id": "Build Parts UUID",
+        "build_decision_book_uu_id": "Build Decision Book UUID",
+    }
+
+
+class InsertAccountRecord(BaseModelRegular, AccountValidation):
+
+    iban: str
+    bank_date: str
+    currency_value: float
+    bank_balance: float
+    currency: str
+    additional_balance: float
+    channel_branch: str
+    process_name: str
+    process_type: str
+    process_comment: str
+    bank_reference_code: str
+
+    add_comment_note: Optional[str] = None
+    is_receipt_mail_send: Optional[bool] = None
+    found_from: Optional[str] = None
+    similarity: Optional[float] = None
+    remainder_balance: Optional[float] = None
+    bank_date_y: Optional[int] = None
+    bank_date_m: Optional[int] = None
+    bank_date_w: Optional[int] = None
+    bank_date_d: Optional[int] = None
+    approving_accounting_record: Optional[bool] = None
+    accounting_receipt_date: Optional[str] = None
+    accounting_receipt_number: Optional[int] = None
+    approved_record: Optional[bool] = None
+    import_file_name: Optional[str] = None
+    # receive_debit_uu_id: Optional[str] = None
+    budget_type_uu_id: Optional[str] = None
+    company_uu_id: Optional[str] = None
+    send_company_uu_id: Optional[str] = None
+    customer_id: Optional[str] = None
+    customer_uu_id: Optional[str] = None
+    send_person_uu_id: Optional[str] = None
+    approving_accounting_person_uu_id: Optional[str] = None
+    build_parts_uu_id: Optional[str] = None
+    build_decision_book_uu_id: Optional[str] = None
+
+
+class UpdateAccountRecord(PydanticBaseModel, AccountValidation):
+
+    iban: Optional[str] = None
+    bank_date: Optional[str] = None
+    currency_value: Optional[float] = None
+    bank_balance: Optional[float] = None
+    currency: Optional[str] = None
+    additional_balance: Optional[float] = None
+    channel_branch: Optional[str] = None
+    process_name: Optional[str] = None
+    process_type: Optional[str] = None
+    process_comment: Optional[str] = None
+    bank_reference_code: Optional[str] = None
+
+    add_comment_note: Optional[str] = None
+    is_receipt_mail_send: Optional[bool] = None
+    found_from: Optional[str] = None
+    similarity: Optional[float] = None
+    remainder_balance: Optional[float] = None
+    bank_date_y: Optional[int] = None
+    bank_date_m: Optional[int] = None
+    bank_date_w: Optional[int] = None
+    bank_date_d: Optional[int] = None
+    approving_accounting_record: Optional[bool] = None
+    accounting_receipt_date: Optional[str] = None
+    accounting_receipt_number: Optional[int] = None
+    approved_record: Optional[bool] = None
+    import_file_name: Optional[str] = None
+    receive_debit_uu_id: Optional[str] = None
+    budget_type_uu_id: Optional[str] = None
+    company_uu_id: Optional[str] = None
+    send_company_uu_id: Optional[str] = None
+    customer_id: Optional[str] = None
+    customer_uu_id: Optional[str] = None
+    send_person_uu_id: Optional[str] = None
+    approving_accounting_person_uu_id: Optional[str] = None
+    build_parts_uu_id: Optional[str] = None
+    build_decision_book_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Request/address.py

@@ -0,0 +1,128 @@
+from typing import Optional
+
+from ApiValidations.Request import PydanticBaseModel, ListOptions
+from ApiValidations.handler import BaseModelRegular
+
+
+class PostCodeValidation:
+    tr = {
+        "post_code": "Posta Kodu",
+        "street_uu_id": "Sokak UUID",
+    }
+    en = {
+        "post_code": "Post Code",
+        "street_uu_id": "Street UUID",
+    }
+
+
+class InsertPostCode(BaseModelRegular, PostCodeValidation):
+    street_uu_id: str
+    post_code: str
+
+
+class UpdatePostCode(PydanticBaseModel, PostCodeValidation):
+    street_uu_id: Optional[str] = None
+    post_code: Optional[str] = None
+
+
+class SearchAddressValidation:
+    tr = {
+        "search": "Ara",
+        "list_options": "Liste Seçenekleri",
+    }
+    en = {
+        "search": "Search",
+        "list_options": "List Options",
+    }
+
+
+class SearchAddress(PydanticBaseModel, SearchAddressValidation):
+    search: str
+    list_options: ListOptions
+
+
+class StreetValidation:
+    tr = {
+        "street_code": "Sokak Kodu",
+        "street_name": "Sokak Adı",
+        "postcode": "Posta Kodu",
+        "type_code": "Tip Kodu",
+        "type_description": "Tip Açıklaması",
+        "gov_code": "Devlet Kodu",
+        "address_geographic_uu_id": "Coğrafi UUID",
+    }
+    en = {
+        "street_code": "Street Code",
+        "street_name": "Street Name",
+        "postcode": "Post Code",
+        "type_code": "Type Code",
+        "type_description": "Type Description",
+        "gov_code": "Government Code",
+        "address_geographic_uu_id": "Address Geographic UUID",
+    }
+
+
+class InsertStreet(PydanticBaseModel, StreetValidation):
+    street_code: str
+    street_name: str
+    postcode: str
+
+    type_code: Optional[str] = None
+    type_description: Optional[str] = None
+    gov_code: Optional[str] = None
+    address_geographic_uu_id: Optional[str] = None
+
+
+class AddressValidation:
+    tr = {
+        "post_code_uu_id": "Posta Kodu UUID",
+        "comment_address": "Adres Yorumu",
+        "letter_address": "Mektup Adresi",
+        "build_number": "Bina Numarası",
+        "door_number": "Kapı Numarası",
+        "floor_number": "Kat Numarası",
+        "short_letter_address": "Kısa Mektup Adresi",
+        "latitude": "Enlem",
+        "longitude": "Boylam",
+    }
+    en = {
+        "post_code_uu_id": "Post Code UUID",
+        "comment_address": "Address Comment",
+        "letter_address": "Letter Address",
+        "build_number": "Build Number",
+        "door_number": "Door Number",
+        "floor_number": "Floor Number",
+        "short_letter_address": "Short Letter Address",
+        "latitude": "Latitude",
+        "longitude": "Longitude",
+    }
+
+
+class InsertAddress(BaseModelRegular, AddressValidation):
+    post_code_uu_id: str
+
+    comment_address: Optional[str] = None
+    letter_address: Optional[str] = None
+
+    build_number: str
+    door_number: Optional[str] = None
+    floor_number: Optional[str] = None
+
+    short_letter_address: Optional[str] = None
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None
+
+
+class UpdateAddress(PydanticBaseModel, AddressValidation):
+    post_code_uu_id: Optional[str] = None
+
+    comment_address: Optional[str] = None
+    letter_address: Optional[str] = None
+
+    build_number: Optional[str] = None
+    door_number: Optional[str] = None
+    floor_number: Optional[str] = None
+
+    short_letter_address: Optional[str] = None
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None

ApiLayers/ApiValidations/Request/application.py

@@ -0,0 +1,69 @@
+from ApiValidations.Request import BaseModelRegular
+
+
+class SingleEnumClassKeyValidation:
+    tr = {
+        "class_name": "Sınıf Adı",
+        "key_name": "Anahtar Adı",
+    }
+    en = {
+        "class_name": "Class Name",
+        "key_name": "Key Name",
+    }
+
+
+class SingleEnumClassKey(BaseModelRegular):
+    class_name: str
+    key_name: str
+
+
+class SingleEnumUUIDValidation:
+    tr = {
+        "uu_id": "UUID",
+    }
+    en = {
+        "uu_id": "UUID",
+    }
+
+
+class SingleEnumUUID(BaseModelRegular):
+    uu_id: str
+
+
+class SingleEnumOnlyClassValidation:
+    tr = {
+        "class_name": "Sınıf Adı",
+    }
+    en = {
+        "class_name": "Class Name",
+    }
+
+
+class SingleEnumOnlyClass(BaseModelRegular):
+    class_name: str
+
+
+class SingleOccupantTypeClassKeyValidation:
+    tr = {
+        "type_code": "Tip Kodu",
+    }
+    en = {
+        "type_code": "Type Code",
+    }
+
+
+class SingleOccupantTypeClassKey(BaseModelRegular):
+    type_code: str
+
+
+class SingleOccupantTypeUUIDValidation:
+    tr = {
+        "uu_id": "Görev UUID",
+    }
+    en = {
+        "uu_id": "Occupant UUID",
+    }
+
+
+class SingleOccupantTypeUUID(BaseModelRegular):
+    uu_id: str

ApiLayers/ApiValidations/Request/area.py

@@ -0,0 +1,73 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class BuildAreaValidation:
+
+    tr = {
+        "area_name": "Alan Adı",
+        "area_code": "Alan Kodu",
+        "area_type": "Alan Tipi",
+        "area_direction": "Alan Yönü",
+        "area_gross_size": "Brüt Alan",
+        "area_net_size": "Net Alan",
+        "width": "Genişlik",
+        "size": "En",
+    }
+    en = {
+        "area_name": "Area Name",
+        "area_code": "Area Code",
+        "area_type": "Area Type",
+        "area_direction": "Area Direction",
+        "area_gross_size": "Gross Size",
+        "area_net_size": "Net Size",
+        "width": "Width",
+        "size": "Size",
+    }
+
+
+class InsertBuildArea(BaseModelRegular, BuildAreaValidation):
+
+    build_uu_id: str
+    area_name: str
+    area_code: str
+    area_type: str
+    area_direction: Optional[str] = None
+    area_gross_size: Optional[float] = None
+    area_net_size: Optional[float] = None
+    width: Optional[int] = None
+    size: Optional[int] = None
+
+
+class UpdateBuildArea(PydanticBaseModel, BuildAreaValidation):
+
+    area_name: Optional[str] = None
+    area_code: Optional[str] = None
+    area_type: Optional[str] = None
+    area_direction: Optional[str] = None
+    area_gross_size: Optional[float] = None
+    area_net_size: Optional[float] = None
+    width: Optional[int] = None
+    size: Optional[int] = None
+
+
+class BuildSites:
+    tr = {"address_uu_id": "Adres UU ID", "site_name": "Site Adı", "site_no": "Site No"}
+    en = {
+        "address_uu_id": "Address UU ID",
+        "site_name": "Site Name",
+        "site_no": "Site No",
+    }
+
+
+class InsertBuildSites(BaseModelRegular, BuildSites):
+
+    address_uu_id: str
+    site_name: str
+    site_no: str
+
+
+class UpdateBuildSites(PydanticBaseModel, BuildSites):
+
+    site_name: Optional[str] = None
+    site_no: Optional[str] = None

ApiLayers/ApiValidations/Request/authentication.py

@@ -0,0 +1,182 @@
+from ApiValidations.Request import BaseModelRegular
+
+from typing import Optional
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ChangePasswordValidation:
+    tr = {"old_password": "Eski Şifre", "new_password": "Yeni Şifre"}
+    en = {"old_password": "Old Password", "new_password": "New Password"}
+
+
+class ChangePassword(BaseModelRegular, ChangePasswordValidation):
+    old_password: str = Field(..., example="current123")
+    new_password: str = Field(..., example="newpass456")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {"old_password": "current123", "new_password": "newpass456"}
+        }
+    )
+
+
+class CreatePasswordValidation:
+    tr = {
+        "password_token": "Şifre Token",
+        "password": "Şifre",
+        "re_password": "Şifre Tekrar",
+    }
+    en = {
+        "password_token": "Password Token",
+        "password": "Password",
+        "re_password": "Re-Password",
+    }
+
+
+class CreatePassword(BaseModelRegular, CreatePasswordValidation):
+    password_token: str = Field(..., example="abc123token")
+    password: str = Field(..., example="newpass123")
+    re_password: str = Field(..., example="newpass123")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "password_token": "abc123token",
+                "password": "newpass123",
+                "re_password": "newpass123",
+            }
+        }
+    )
+
+
+class OccupantSelectionValidation:
+    tr = {"occupant_uu_id": "Kiracı UU ID", "build_part_uu_id": "Bölüm UU ID"}
+    en = {"occupant_uu_id": "Occupant UU ID", "build_part_uu_id": "Build Part UU ID"}
+
+
+class OccupantSelection(BaseModel, OccupantSelectionValidation):
+    build_living_space_uu_id: str = Field(
+        ..., example="987fcdeb-51a2-43e7-9876-543210987654"
+    )
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": [
+                {"company_uu_id": "abcdef12-3456-7890-abcd-ef1234567890"},
+                {"build_living_space_uu_id": "987fcdeb-51a2-43e7-9876-543210987654"},
+            ],
+        }
+    )
+
+    @property
+    def is_employee(self):
+        return False
+
+    @property
+    def is_occupant(self):
+        return True
+
+
+class EmployeeSelectionValidation:
+    tr = {"company_uu_id": "Şirket UU ID"}
+    en = {"company_uu_id": "Company UU ID"}
+
+
+class EmployeeSelection(BaseModel, EmployeeSelectionValidation):
+    company_uu_id: str = Field(..., example="abcdef12-3456-7890-abcd-ef1234567890")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": [
+                {"company_uu_id": "abcdef12-3456-7890-abcd-ef1234567890"},
+                {"build_living_space_uu_id": "987fcdeb-51a2-43e7-9876-543210987654"},
+            ],
+        }
+    )
+
+    @property
+    def is_employee(self):
+        return True
+
+    @property
+    def is_occupant(self):
+        return False
+
+
+class LoginValidation:
+    tr = {
+        "domain": "Domain",
+        "access_key": "Erişim Anahtarı",
+        "password": "Şifre",
+        "remember_me": "Beni Hatırla",
+    }
+    en = {
+        "domain": "Domain",
+        "access_key": "Access Key",
+        "password": "Password",
+        "remember_me": "Remember Me",
+    }
+
+
+class Login(BaseModelRegular, LoginValidation):
+    domain: str = Field(..., example="example.com")
+    access_key: str = Field(..., example="user@example.com")
+    password: str = Field(..., example="password123")
+    remember_me: Optional[bool] = Field(False, example=True)
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "domain": "evyos.com.tr",
+                "access_key": "karatay.berkay.sup@evyos.com.tr",
+                "password": "string",
+                "remember_me": False,
+            }
+        }
+    )
+
+
+class LogoutValidation:
+    tr = {"domain": "Domain"}
+    en = {"domain": "Domain"}
+
+
+class Logout(BaseModelRegular, LogoutValidation):
+    domain: str = Field(..., example="example.com")
+
+    model_config = ConfigDict(json_schema_extra={"example": {"domain": "example.com"}})
+
+
+class RememberValidation:
+    tr = {"domain": "Domain", "refresh_token": "Yenileme Anahtarı"}
+    en = {"domain": "Domain", "refresh_token": "Refresh Token"}
+
+
+class Remember(BaseModelRegular, RememberValidation):
+    domain: str = Field(..., example="example.com")
+    refresh_token: str = Field(..., example="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "domain": "example.com",
+                "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+            }
+        }
+    )
+
+
+class ForgotValidation:
+    tr = {"domain": "Domain", "access_key": "Erişim Anahtarı"}
+    en = {"domain": "Domain", "access_key": "Access Key"}
+
+
+class Forgot(BaseModelRegular, ForgotValidation):
+    domain: str = Field(..., example="example.com")
+    access_key: str = Field(..., example="user@example.com")
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {"domain": "example.com", "access_key": "user@example.com"}
+        }
+    )

ApiLayers/ApiValidations/Request/base_validations.py

@@ -0,0 +1,33 @@
+from typing import Optional
+from ApiValidations.handler import BaseModelRegular
+
+
+class ListOptions(BaseModelRegular):
+    page: Optional[int] = 1
+    size: Optional[int] = 10
+    order_field: Optional[str] = "id"
+    order_type: Optional[str] = "asc"
+    include_joins: Optional[list] = None
+    query: Optional[dict] = None
+
+
+class CrudRecords:
+    uu_id: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    created_by: Optional[str] = None
+    updated_by: Optional[str] = None
+    confirmed_by: Optional[str] = None
+    is_confirmed: Optional[bool] = None
+    active: Optional[bool] = None
+    is_notification_send: Optional[bool] = None
+    is_email_send: Optional[bool] = None
+
+
+class PydanticBaseModel(BaseModelRegular):
+
+    active: Optional[bool] = None
+    deleted: Optional[bool] = None
+    expiry_starts: Optional[str] = None
+    # expiry_ends: Optional[str] = None
+    is_confirmed: Optional[bool] = None

ApiLayers/ApiValidations/Request/build_living_space.py

@@ -0,0 +1,22 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular
+
+# from api_validations.validations_request import (
+#     PydanticBaseModel,
+#     PydanticBaseModelValidation,
+# )
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertBuildLivingSpace(BaseModelRegular):
+    person_uu_id: str
+    build_parts_uu_id: str
+    occupant_type_uu_id: str
+    expiry_starts: str
+    expiry_ends: Optional[str] = None
+
+
+class UpdateBuildLivingSpace(PydanticBaseModel):
+    is_tenant_live: Optional[bool] = None
+    build_parts_uu_id: Optional[str] = None
+    person_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Request/build_part.py

@@ -0,0 +1,43 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertBuildTypes(BaseModelRegular):
+    function_code: str
+    type_code: str
+    lang: str
+    type_name: str
+
+
+class UpdateBuildTypes(PydanticBaseModel): ...
+
+
+class InsertBuildParts(BaseModelRegular):
+    build_uu_id: str
+    address_gov_code: str
+    part_no: int
+    part_level: int
+    build_part_type_uu_id: str
+
+    part_gross_size: Optional[int] = None
+    part_net_size: Optional[int] = None
+    default_accessory: Optional[str] = None
+    human_livable: Optional[bool] = False
+    part_direction_uu_id: Optional[str] = None
+    ref_id: Optional[str] = None
+
+
+class UpdateBuildParts(PydanticBaseModel):
+    address_gov_code: Optional[str] = None
+    part_no: Optional[int] = None
+    part_level: Optional[int] = None
+    build_part_type_uu_id: Optional[str] = None
+
+    part_code: Optional[int] = None
+    part_gross_size: Optional[int] = None
+    part_net_size: Optional[int] = None
+    default_accessory: Optional[str] = None
+    human_livable: Optional[bool] = False
+    part_direction: Optional[str] = None
+    current_owner_person_uu_id: Optional[str] = None
+    current_tenant_person_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Request/building.py

@@ -0,0 +1,43 @@
+from typing import Optional
+from datetime import datetime
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertBuild(BaseModelRegular):
+
+    gov_address_code: str
+    build_name: str
+    build_types_uu_id: str
+    max_floor: int
+    underground_floor: int
+    address_uu_id: str
+    build_date: datetime
+    decision_period_date: datetime
+
+    tax_no: Optional[str] = None
+    lift_count: Optional[int] = None
+    heating_system: Optional[bool] = None
+    cooling_system: Optional[bool] = None
+    hot_water_system: Optional[bool] = None
+    block_service_man_count: Optional[int] = None
+    security_service_man_count: Optional[int] = None
+    garage_count: Optional[int] = None
+
+
+class UpdateBuild(PydanticBaseModel):
+    gov_address_code: Optional[str] = None
+    build_name: Optional[str] = None
+    build_no: Optional[str] = None
+    build_types_uu_id: Optional[str] = None
+    max_floor: Optional[int] = None
+    underground_floor: Optional[int] = None
+    build_date: Optional[datetime] = None
+    tax_no: Optional[str] = None
+    lift_count: Optional[int] = None
+    heating_system: Optional[bool] = None
+    cooling_system: Optional[bool] = None
+    hot_water_system: Optional[bool] = None
+    block_service_man_count: Optional[int] = None
+    security_service_man_count: Optional[int] = None
+    garage_count: Optional[int] = None
+    address_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Request/company.py

@@ -0,0 +1,32 @@
+from typing import Optional, List
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertCompany(BaseModelRegular):
+    formal_name: str
+    company_type: str
+    commercial_type: str
+    tax_no: str
+    public_name: Optional[str] = None
+    company_tag: Optional[str] = None
+    default_lang_type: Optional[str] = None
+    default_money_type: Optional[str] = None
+    official_address_uu_id: Optional[str] = None
+    # parent_uu_id: Optional[int] = None
+
+
+class UpdateCompany(PydanticBaseModel):
+    company_uu_id: str
+    public_name: Optional[str] = None
+    formal_name: Optional[str] = None
+    tax_no: Optional[str] = None
+    company_tag: Optional[str] = None
+    default_lang_type: Optional[str] = None
+    default_money_type: Optional[str] = None
+    official_address_uu_id: Optional[str] = None
+
+
+class MatchCompany2Company(PydanticBaseModel):
+    match_company_uu_id: List[str]
+    duty_uu_id: str
+    show_only: Optional[bool] = None

ApiLayers/ApiValidations/Request/core_request_validations.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from ApiValidations.Request import BaseModelRegular
+
+
+class ListOptionsValidation:
+    tr = {
+        "page": "Sayfa",
+        "size": "Boyut",
+        "order_field": "Sıralama Alanı",
+        "order_type": "Sıralama Türü",
+        "include_joins": "Alt İçerikleri",
+        "query": "Sorgu",
+    }
+    en = {
+        "page": "Page",
+        "size": "Size",
+        "order_field": "Order Field",
+        "order_type": "Order Type",
+        "include_joins": "Include Joins",
+        "query": "Query",
+    }
+
+
+class ListOptions(BaseModelRegular, ListOptionsValidation):
+    page: Optional[int] = 1
+    size: Optional[int] = 10
+    order_field: Optional[str] = "id"
+    order_type: Optional[str] = "asc"
+    include_joins: Optional[list] = None
+    query: Optional[dict] = None
+
+
+class CrudRecordValidation:
+    tr = {
+        "uu_id": "UUID",
+        "created_at": "Oluşturulma Tarihi",
+        "updated_at": "Güncellenme Tarihi",
+        "created_by": "Oluşturan",
+        "updated_by": "Güncelleyen",
+        "confirmed_by": "Onaylayan",
+        "is_confirmed": "Onay",
+        "expiry_starts": "Geçerlilik Başlangıç Tarihi",
+        "expiry_ends": "Geçerlilik Bitiş Tarihi",
+        "active": "Aktif",
+        "is_notification_send": "Bildirim Gönderildi",
+        "is_email_send": "E-posta Gönderildi",
+    }
+    en = {
+        "uu_id": "UUID",
+        "created_at": "Created At",
+        "updated_at": "Updated At",
+        "created_by": "Created By",
+        "updated_by": "Updated By",
+        "confirmed_by": "Confirmed By",
+        "is_confirmed": "Confirmed",
+        "expiry_starts": "Expiry Starts",
+        "expiry_ends": "Expiry Ends",
+        "active": "Active",
+        "is_notification_send": "Notification Send",
+        "is_email_send": "Email Send",
+    }
+
+
+class CrudRecords:
+    uu_id: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    created_by: Optional[str] = None
+    updated_by: Optional[str] = None
+    confirmed_by: Optional[str] = None
+    is_confirmed: Optional[bool] = None
+    active: Optional[bool] = None
+    is_notification_send: Optional[bool] = None
+    is_email_send: Optional[bool] = None
+
+
+class PydanticBaseModelValidation:
+    tr = {
+        "active": "Aktif",
+        "deleted": "Silinmiş",
+        "expiry_starts": "Geçerlilik Başlangıç Tarihi",
+        "expiry_ends": "Geçerlilik Bitiş Tarihi",
+        "is_confirmed": "Onay",
+    }
+    en = {
+        "active": "Active",
+        "deleted": "Deleted",
+        "expiry_starts": "Expiry Starts",
+        "expiry_ends": "Expiry Ends",
+        "is_confirmed": "Confirmed",
+    }
+
+
+class PydanticBaseModel(BaseModelRegular):
+
+    active: Optional[bool] = None
+    deleted: Optional[bool] = None
+    expiry_starts: Optional[str] = None
+    # expiry_ends: Optional[str] = None
+    is_confirmed: Optional[bool] = None
+
+
+class EndpointPydantic(BaseModelRegular):
+    data: Optional[dict] = None
+
+
+class EndpointValidation(BaseModelRegular):
+    endpoint: Optional[str] = None
+
+
+class PatchRecord(BaseModelRegular):
+
+    confirm: Optional[bool] = None
+    delete: Optional[bool] = None
+    active: Optional[bool] = None

ApiLayers/ApiValidations/Request/create_model.py

@@ -0,0 +1,73 @@
+import typing
+
+from datetime import datetime
+
+
+class ConvertField:
+
+    def __init__(self, match, default_val=None):
+        self.match = match
+        self.default_val = default_val
+
+    def typing_return(self):
+        typing_dict = {
+            "<class 'float'>": float,
+            "<class 'bool'>": bool,
+            "<class 'int'>": int,
+            "<class 'str'>": str,
+            "<class 'dict'>": dict,
+            "<class 'list'>": list,
+            "<class 'datetime.datetime'>": datetime,
+            "typing.Optional[datetime.datetime]": typing.Optional[datetime],
+            "typing.Optional[bool]": typing.Optional[bool],
+            "typing.Optional[list]": typing.Optional[list],
+            "typing.Optional[str]": typing.Optional[str],
+            "typing.Optional[int]": typing.Optional[int],
+            "typing.Optional[float]": typing.Optional[float],
+            "typing.Optional[dict]": typing.Optional[dict],
+        }
+        matches_with = typing_dict.get(self.match, typing.Optional[str])
+        default_value = getattr(self.default_val, "field_default_value", None)
+        return matches_with, default_value
+
+
+#
+# def create_model_from_database(model_id: typing.Union[int, str]):
+#     if isinstance(model_id, int):
+#         selected_model = Models.find_one(id=model_id)
+#     else:
+#         selected_model = Models.find_one(uu_id=str(model_id))
+#
+#     if not selected_model:
+#         raise HTTPException(
+#             status_code=202,
+#             detail=f"Model {selected_model.model_name} not found in database. Please add model to api.",
+#         )
+#     pydantic_class = getattr(root_validates, selected_model.model_type, None)
+#     if not pydantic_class:
+#         raise HTTPException(
+#             status_code=202,
+#             detail=f"Pydantic class {selected_model.model_type} not found in database. Please add model to api.",
+#         )
+#
+#     model_entities_records = ModelEntities.filter_all(
+#         ModelEntities.model_id == selected_model.id
+#     ).data
+#
+#     if not model_entities_records:
+#         raise HTTPException(
+#             status_code=202,
+#             detail="Model has no entities registered. Please add entities to model.",
+#         )
+#
+#     fields = {}
+#     for entity in model_entities_records:
+#         fields[entity.field_name] = ConvertField(
+#             entity.field_type, entity.field_default_value
+#         ).typing_return()
+#
+#     return create_model(
+#         __model_name=selected_model.model_name,  # pydantic_name(User)
+#         __module__=pydantic_class.__module__,  # field_name(uu_id)
+#         **fields,  # field_name = (field_type (Optional[str]), default_value(None))
+#     )

ApiLayers/ApiValidations/Request/decision_book.py

@@ -0,0 +1,110 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel, ListOptions
+
+
+class DecisionBookDecisionBookInvitations(BaseModelRegular):
+    build_decision_book_uu_id: str
+    message: str
+    planned_date: str
+
+
+class DecisionBookDecisionBookInvitationsAttend(BaseModelRegular):
+    token: str
+    is_attend: bool
+
+
+class DecisionBookDecisionBookInvitationsAssign(BaseModelRegular):
+    token: str
+    build_living_space_uu_id: str
+    occupant_type_uu_id: str
+
+
+class DecisionBookDecisionBookInvitationsUpdate(PydanticBaseModel):
+    token: str
+    occupant_type_uu_id: Optional[str] = None
+
+
+class ListDecisionBook(ListOptions):
+    build_decision_book_uu_id: Optional[str] = None
+
+
+class InsertDecisionBook(PydanticBaseModel):
+    build_uu_id: str
+    decision_type: str
+    meeting_date: str
+    is_out_sourced: bool
+
+    resp_company_fix_wage: Optional[float] = None
+    resp_company_uu_id: Optional[str] = None
+
+
+class InsertDecisionBookCompleted(BaseModelRegular):
+    build_decision_book_uu_id: str
+    meeting_completed_date: str
+
+
+class InsertDecisionBookPerson(BaseModelRegular):
+    person_uu_id: str
+    build_decision_book_uu_id: str
+    management_typecode_uu_id: str
+
+    dues_discount_approval_date: Optional[str] = None
+    dues_fix_discount: Optional[float] = None
+    dues_percent_discount: Optional[int] = None
+
+
+class UpdateDecisionBookPerson(PydanticBaseModel):
+
+    dues_fix_discount: Optional[float] = None
+    dues_percent_discount: Optional[int] = None
+
+
+class RemoveDecisionBookPerson(PydanticBaseModel):
+    person_uu_id: str
+    build_decision_book_person_uu_id: str
+
+
+class UpdateDecisionBook(PydanticBaseModel):
+    decision_book_pdf_path: Optional[str] = None
+    is_out_sourced: Optional[bool] = None
+    contact_agreement_path: Optional[str] = None
+    contact_agreement_date: Optional[str] = None
+    meeting_date: Optional[str] = None
+    decision_type: Optional[str] = None
+
+    resp_company_fix_wage: Optional[float] = None
+    resp_company_uu_id: Optional[str] = None
+
+
+class InsertBuildDecisionBookItems(BaseModelRegular):
+    token: str
+    info_type_uu_id: str
+    item_comment: str
+
+    currency: Optional[str] = "TL"
+    unit_type: Optional[str] = "M2"
+    debit_start_date: Optional[str] = None
+    debit_end_date: Optional[str] = None
+    unit_price_is_fixed: Optional[bool] = False
+    unit_price: Optional[float] = 0.00
+
+    # build_decision_book_uu_id: str
+    # item_objection: Optional[str] = None
+
+
+class UpdateBuildDecisionBookItems(PydanticBaseModel):
+    item_comment: Optional[str] = None
+    item_objection: Optional[str] = None
+
+
+class InsertBuildDecisionBookItemDebits(BaseModelRegular):
+    build_decision_book_item_uu_id: str
+    dues_values: dict
+    # dues_types_uu_id: str
+    # decision_taken: Optional[bool] = None
+
+
+class UpdateBuildDecisionBookItemDebits(PydanticBaseModel):
+    dues_types_uu_id: Optional[str] = None
+    dues_values: Optional[dict] = None
+    decision_taken: Optional[bool] = None

ApiLayers/ApiValidations/Request/departments.py

@@ -0,0 +1,22 @@
+from typing import Optional
+from ApiValidations.Request import (
+    PydanticBaseModel,
+)
+
+
+class DepartmentsPydantic(PydanticBaseModel):
+
+    department_code: Optional[str]
+    department_name: Optional[str]
+    department_description: Optional[str] = None
+    company_uu_id: Optional[str] = None
+    parent_department_uu_id: Optional[int] = None
+
+
+# class UpdateDepartments(PydanticBaseModel):
+#
+#     department_code: Optional[str] = None
+#     department_name: Optional[str] = None
+#     department_description: Optional[str] = None
+#     company_uu_id: Optional[str] = None
+#     parent_department_uu_id: Optional[int] = None

ApiLayers/ApiValidations/Request/employee.py

@@ -0,0 +1,77 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class BindEmployees2People(PydanticBaseModel):
+    staff_uu_id: str
+    people_uu_id: str
+    expiry_starts: Optional[str] = None
+
+
+class UnBindEmployees2People(PydanticBaseModel):
+    people_uu_id: str
+    expiry_ends: str
+
+
+class InsertEmployees(BaseModelRegular):
+    staff_uu_id: str
+    people_uu_id: Optional[str] = None
+
+
+class InsertCompanyDuty(BaseModelRegular):
+    duty_code: str
+    duty_name: str
+    duty_description: Optional[str] = None
+
+
+class SelectDuties(BaseModelRegular):
+    duty_uu_id: Optional[str] = None
+
+
+class InsertDuties(BaseModelRegular):
+    duties_uu_id: str
+    department_uu_id: str
+    is_default_duty: Optional[bool] = False
+
+
+class UpdateDuties(PydanticBaseModel):
+    duties_uu_id: Optional[str] = None
+    department_uu_id: Optional[str] = None
+    is_default_duty: Optional[bool] = None
+
+
+class UpdateCompanyDuty(PydanticBaseModel):
+    duty_code: Optional[str] = None
+    duty_name: Optional[str] = None
+    duty_description: Optional[str] = None
+
+
+class InsertCompanyEmployeesSalaries(BaseModelRegular):
+    gross_salary: float
+    net_salary: float
+    start_date: str
+    stop_date: Optional[str] = None
+    people_id: int
+
+
+class UpdateCompanyEmployeesSalaries(PydanticBaseModel):
+    gross_salary: Optional[float] = None
+    net_salary: Optional[float] = None
+    start_date: Optional[str] = None
+    stop_date: Optional[str] = None
+    people_id: Optional[int] = None
+
+
+class InsertCompanyEmployees(BaseModelRegular):
+
+    employee_description: Optional[str] = None
+    person_uu_id: str
+    duty_uu_id: str
+
+    start_date: Optional[str] = None
+    stop_date: Optional[str] = None
+
+
+class UpdateCompanyEmployees(PydanticBaseModel):
+    stop_date: Optional[str] = None
+    employee_description: Optional[str] = None

ApiLayers/ApiValidations/Request/events.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular
+
+
+class RegisterEvents2EmployeeValidation:
+    tr = {
+        "event_uu_id_list": "Etkinlikler Listesi",
+        "employee_uu_id": "Çalışan UU ID",
+    }
+    en = {
+        "event_uu_id_list": "Event List",
+        "employee_uu_id": "Employee UU ID",
+    }
+
+
+class RegisterEvents2Employee(BaseModelRegular, RegisterEvents2EmployeeValidation):
+    event_uu_id_list: list[str] = None
+    employee_uu_id: Optional[str] = None
+
+
+class RegisterEvents2OccupantValidation:
+    tr = {
+        "event_uu_id_list": "Etkinlikler Listesi",
+        "build_part_uu_id": "Bina Parça UU ID",
+        "occupant_uu_id": "Apartman Sakini UU ID",
+    }
+    en = {
+        "event_uu_id_list": "Event List",
+        "build_part_uu_id": "Building Part UU ID",
+        "occupant_uu_id": "Occupant UU ID",
+    }
+
+
+class RegisterEvents2Occupant(BaseModelRegular, RegisterEvents2OccupantValidation):
+    event_uu_id_list: list[str] = None
+    build_part_uu_id: Optional[str] = None
+    occupant_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Request/modules.py

@@ -0,0 +1,36 @@
+from ApiValidations.Request import BaseModelRegular
+
+
+class RegisterModules2OccupantValidation:
+    tr = {
+        "modules_uu_id": "Modül Listesi",
+        "occupant_uu_id": "Mülk Sahibi",
+        "build_part_uu_id": "Daire UUID",
+    }
+    en = {
+        "modules_uu_id": "Module List",
+        "occupant_uu_id": "Occupant",
+        "build_part_uu_id": "Flat UUID",
+    }
+
+
+class RegisterModules2Occupant(BaseModelRegular, RegisterModules2OccupantValidation):
+    modules_uu_id: str
+    occupant_uu_id: str
+    build_part_uu_id: str
+
+
+class RegisterModules2EmployeeValidation:
+    tr = {
+        "modules_uu_id": "Modül Listesi",
+        "employee_uu_id": "Çalışan",
+    }
+    en = {
+        "modules_uu_id": "Module List",
+        "employee_uu_id": "Employee",
+    }
+
+
+class RegisterModules2Employee(BaseModelRegular, RegisterModules2EmployeeValidation):
+    modules_uu_id: str
+    employee_uu_id: str

ApiLayers/ApiValidations/Request/people.py

@@ -0,0 +1,66 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertPerson(BaseModelRegular):
+    firstname: str
+    surname: str
+    sex_code: str
+    national_identity_id: str
+    middle_name: Optional[str] = None
+    father_name: Optional[str] = None
+    mother_name: Optional[str] = None
+    country_code: Optional[str] = "TR"
+    birth_place: Optional[str] = None
+    birth_date: Optional[str] = None
+    tax_no: Optional[str] = None
+    ref_id: Optional[str] = None
+
+
+class UpdatePerson(PydanticBaseModel):
+    firstname: Optional[str] = None
+    surname: Optional[str] = None
+    middle_name: Optional[str]
+    father_name: Optional[str] = None
+    mother_name: Optional[str] = None
+    sex_code: Optional[str] = None
+    country_code: Optional[str] = None
+    national_identity_id: Optional[str] = None
+    birth_place: Optional[str] = None
+    birth_date: Optional[str] = None
+    tax_no: Optional[str] = None
+
+
+#
+# class QueryPeople(PydanticBaseModel):
+#     uu_id: Optional[str] = None
+#
+#
+# class InsertPeople(PydanticBaseModel):
+#     key_id: Optional[str] = None
+#     query: Optional[dict] = None
+#     data: Optional[_InsertPerson] = None
+#
+#
+# class UpdatePeople(PydanticBaseModel):
+#     key_id: Optional[str] = None
+#     query: Optional[QueryPeople] = None
+#     data: Optional[_UpdatePerson] = None
+#
+#
+# class DeletePeople(PydanticBaseModel):
+#     key_id: Optional[str] = None
+#     query: Optional[List[QueryPeople]] = None
+#     data: Optional[dict] = None
+#
+#
+# class ListPeople(PydanticBaseModel):
+#     key_id: Optional[str] = None
+#     query: Optional[QueryPeople] = None
+#     data: Optional[ListOptions] = None
+#
+#
+# class ActivePeople(PydanticBaseModel):
+#     key_id: Optional[str] = None
+#     query: Optional[List[QueryPeople]] = None
+#     data: Optional[dict] = None

ApiLayers/ApiValidations/Request/project_decision_book.py

@@ -0,0 +1,99 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertBuildDecisionBookProjectItems(BaseModelRegular):
+    build_decision_book_project_uu_id: str
+    item_header: str
+    item_comment: str
+    attachment_pdf_path: Optional[str] = None
+    item_objection: Optional[str] = None
+
+
+class UpdateBuildDecisionBookProjectItems(PydanticBaseModel):
+    item_header: Optional[str] = None
+    item_comment: Optional[str] = None
+    attachment_pdf_path: Optional[str] = None
+    item_estimated_cost: Optional[float] = None
+    build_decision_book_project_uu_id: Optional[str] = None
+
+
+class InsertBuildDecisionBookProjectPerson(BaseModelRegular):
+    dues_percent_discount: Optional[int] = None
+    job_fix_wage: Optional[float] = None
+    bid_price: Optional[float] = None
+    decision_price: Optional[float] = None
+    build_decision_book_project_uu_id: str
+    living_space_uu_id: str
+    project_team_type_uu_id: str
+
+
+class UpdateBuildDecisionBookProjectPerson(PydanticBaseModel):
+    dues_percent_discount: Optional[int] = None
+    job_fix_wage: Optional[float] = None
+    bid_price: Optional[float] = None
+    decision_price: Optional[float] = None
+    build_decision_book_project_uu_id: Optional[str] = None
+    living_space_uu_id: Optional[str] = None
+    project_team_type_uu_id: Optional[str] = None
+
+
+class InsertBuildDecisionBookProjects(BaseModelRegular):
+    build_decision_book_item_uu_id: str
+    project_responsible_person_uu_id: str
+    project_name: str
+    project_start_date: str
+    project_stop_date: str
+    project_type: str
+
+    is_out_sourced: Optional[bool] = False
+    project_note: Optional[str] = None
+    decision_book_pdf_path: Optional[str] = None
+    resp_company_fix_wage: Optional[float] = None
+    contact_agreement_path: Optional[str] = None
+    contact_agreement_date: Optional[str] = None
+    meeting_date: Optional[str] = None
+    currency: Optional[str] = None
+    bid_price: Optional[float] = None
+    resp_company_uu_id: Optional[str] = None
+
+
+class UpdateBuildDecisionBookProjects(PydanticBaseModel):
+    build_decision_book_project_uu_id: str
+    is_out_sourced: Optional[bool] = False
+    project_note: Optional[str] = None
+    # decision_book_pdf_path: Optional[str] = None
+    status_id: Optional[int] = None
+    resp_company_fix_wage: Optional[float] = None
+    contact_agreement_path: Optional[str] = None
+    contact_agreement_date: Optional[str] = None
+    contact_uu_id: Optional[str] = None
+    resp_company_uu_id: Optional[str] = None
+    approved_price: Optional[float] = None
+
+
+class ApprovalsBuildDecisionBookProjects(PydanticBaseModel):
+    build_decision_book_project_uu_id: str
+    project_stop_date: str
+    status_code: Optional[int] = None
+    final_price_list: Optional[list[dict]] = (
+        None  # {"date": "2021-01-01", "price": 1000}
+    )
+
+
+class InsertBuildDecisionBookProjectItemDebits(PydanticBaseModel):
+    build_decision_book_project_item_uu_id: str
+    payment_date: str
+    dues_values: dict
+    is_official: Optional[bool] = False
+    discount_value: Optional[float] = None
+    discount_fix: Optional[float] = None
+    decision_taken: Optional[bool] = None
+
+
+class UpdateBuildDecisionBookProjectItemDebits(PydanticBaseModel):
+    dues_values: Optional[str] = None
+    discount_value: Optional[float] = None
+    discount_fix: Optional[float] = None
+    decision_taken: Optional[bool] = None
+    is_official: Optional[bool] = None

ApiLayers/ApiValidations/Request/rules.py

@@ -0,0 +1,23 @@
+from typing import Optional, List
+from ApiValidations.Request import BaseModelRegular
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class CheckEndpointAccess(BaseModelRegular):
+    endpoint: str
+
+
+class InsertEndpointAccess(PydanticBaseModel):
+    duty_uu_id: str
+    endpoint_restriction_list_uu_ids: list
+
+
+class UpdateEndpointAccess(PydanticBaseModel):
+    endpoint_restriction_uu_id: Optional[str] = None
+    deleted: Optional[bool] = None
+    active: Optional[bool] = None
+    is_confirmed: Optional[bool] = None
+
+
+class UpdateEndpointAccessList(PydanticBaseModel):
+    endpoint_restriction_list: List[UpdateEndpointAccess]

ApiLayers/ApiValidations/Request/services.py

@@ -0,0 +1,36 @@
+from ApiValidations.Request import BaseModelRegular
+
+
+class RegisterServices2OccupantValidation:
+    tr = {
+        "service_uu_id": "Hizmet UUID",
+        "occupant_uu_id": "Müşteri UUID",
+        "build_part_uu_id": "Bina Parça UUID",
+    }
+    en = {
+        "service_uu_id": "Service UUID",
+        "occupant_uu_id": "Occupant UUID",
+        "build_part_uu_id": "Building Part UUID",
+    }
+
+
+class RegisterServices2Occupant(BaseModelRegular, RegisterServices2OccupantValidation):
+    service_uu_id: str
+    occupant_uu_id: str
+    build_part_uu_id: str
+
+
+class RegisterServices2EmployeeValidation:
+    tr = {
+        "service_uu_id": "Hizmet UUID",
+        "employee_uu_id": "Personel UUID",
+    }
+    en = {
+        "service_uu_id": "Service UUID",
+        "employee_uu_id": "Employee UUID",
+    }
+
+
+class RegisterServices2Employee(BaseModelRegular, RegisterServices2EmployeeValidation):
+    service_uu_id: str
+    employee_uu_id: str

ApiLayers/ApiValidations/Request/staff.py

@@ -0,0 +1,39 @@
+from typing import Optional
+from ApiValidations.Request import BaseModelRegular, PydanticBaseModel
+
+
+class InsertStaffValidation:
+    tr = {
+        "staff_name": "Kadro Adı",
+        "staff_description": "Kadro Açıklaması",
+        "staff_code": "Kadro Kodu",
+        "duties_uu_id": "Görev UUID",
+    }
+    en = {
+        "staff_name": "Staff Name",
+        "staff_description": "Staff Description",
+        "staff_code": "Staff Code",
+        "duties_uu_id": "Duties UUID",
+    }
+
+
+class InsertStaff(BaseModelRegular, InsertStaffValidation):
+
+    staff_name: str
+    staff_description: Optional[str] = None
+    staff_code: Optional[str] = None
+    duties_uu_id: str
+
+
+class SelectStaffValidation:
+    tr = {
+        "duties_uu_id": "Görev UUID",
+    }
+    en = {
+        "duties_uu_id": "Duties UUID",
+    }
+
+
+class SelectStaff(PydanticBaseModel, SelectStaffValidation):
+
+    duties_uu_id: str

ApiLayers/ApiValidations/Request/user.py

@@ -0,0 +1,68 @@
+from typing import Optional
+from ApiValidations.Request import PydanticBaseModel
+
+
+class InsertUsersValidation:
+    tr = {
+        "people_uu_id": "Kişi UUID",
+        "user_tag": "Kullanıcı Etiketi",
+        "email": "E-posta",
+        "phone_number": "Telefon Numarası",
+        "avatar": "Avatar",
+    }
+    en = {
+        "people_uu_id": "People UUID",
+        "user_tag": "User Tag",
+        "email": "Email",
+        "phone_number": "Phone Number",
+        "avatar": "Avatar",
+    }
+
+
+class InsertUsers(PydanticBaseModel, InsertUsersValidation):
+    people_uu_id: str
+    user_tag: str
+    email: Optional[str] = None
+    phone_number: Optional[str] = None
+    avatar: Optional[str] = None
+
+
+class UpdateUsersValidation:
+    tr = {
+        "people_uu_id": "Kişi UUID",
+        "nick_name": "Kullanıcı Etiketi",
+        "domain_name": "Domain Adı",
+        "email": "E-posta",
+        "phone_number": "Telefon Numarası",
+        "avatar": "Avatar",
+    }
+    en = {
+        "people_uu_id": "People UUID",
+        "nick_name": "User Tag",
+        "domain_name": "Domain Name",
+        "email": "Email",
+        "phone_number": "Phone Number",
+        "avatar": "Avatar",
+    }
+
+
+class UpdateUsers(PydanticBaseModel, UpdateUsersValidation):
+    people_uu_id: Optional[str] = None
+    nick_name: Optional[str] = None
+    domain_name: Optional[str] = None
+    email: Optional[str] = None
+    phone_number: Optional[str] = None
+    avatar: Optional[str] = None
+
+
+class QueryUsersValidation:
+    tr = {
+        "uu_id": "UUID",
+    }
+    en = {
+        "uu_id": "UUID",
+    }
+
+
+class QueryUsers(PydanticBaseModel):
+    uu_id: Optional[str] = None

ApiLayers/ApiValidations/Response/__init__.py

@@ -0,0 +1,16 @@
+from .account_responses import AccountRecordResponse
+from .address_responses import ListAddressResponse
+from .auth_responses import (
+    AuthenticationLoginResponse,
+    AuthenticationRefreshResponse,
+    AuthenticationUserInfoResponse,
+)
+
+
+__all__ = [
+    "AccountRecordResponse",
+    "ListAddressResponse",
+    "AuthenticationLoginResponse",
+    "AuthenticationRefreshResponse",
+    "AuthenticationUserInfoResponse",
+]

ApiLayers/ApiValidations/Response/account_responses.py

@@ -0,0 +1,260 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from decimal import Decimal
+from uuid import UUID
+from pydantic import BaseModel
+
+
+class AccountBooksResponse(BaseModel):
+    """Response model for account books"""
+
+    country: str
+    branch_type: int
+    company_id: int
+    company_uu_id: str
+    branch_id: Optional[int]
+    branch_uu_id: Optional[str]
+
+
+class AccountCodesResponse(BaseModel):
+    """Response model for account codes"""
+
+    account_code: str
+    comment_line: str
+    is_receive_or_debit: bool
+    product_id: int = 0
+    nvi_id: str = ""
+    status_id: int = 0
+    account_code_seperator: str = "."
+    system_id: int = 0
+    locked: bool = False
+    company_id: Optional[int]
+    company_uu_id: str
+    customer_id: Optional[int]
+    customer_uu_id: str
+    person_id: Optional[int]
+    person_uu_id: str
+
+
+class AccountCodeParserResponse(BaseModel):
+    """Response model for account code parser"""
+
+    account_code_1: str
+    account_code_2: str
+    account_code_3: str
+    account_code_4: str = ""
+    account_code_5: str = ""
+    account_code_6: str = ""
+    account_code_id: int
+    account_code_uu_id: str
+
+
+class AccountMasterResponse(BaseModel):
+    """Response model for account master"""
+
+    doc_date: datetime
+    plug_type: str
+    plug_number: int
+    special_code: str = ""
+    authorization_code: str = ""
+    doc_code: str = ""
+    doc_type: int = 0
+    comment_line1: str = ""
+    comment_line2: str = ""
+    comment_line3: str = ""
+    comment_line4: str = ""
+    comment_line5: str = ""
+    comment_line6: str = ""
+    project_code: str = ""
+    module_no: str = ""
+    journal_no: int = 0
+    status_id: int = 0
+    canceled: bool = False
+    print_count: int = 0
+    total_active: Decimal = Decimal("0")
+    total_passive: Decimal = Decimal("0")
+    total_active_1: Decimal = Decimal("0")
+    total_passive_1: Decimal = Decimal("0")
+    total_active_2: Decimal = Decimal("0")
+    total_passive_2: Decimal = Decimal("0")
+    total_active_3: Decimal = Decimal("0")
+    total_passive_3: Decimal = Decimal("0")
+    total_active_4: Decimal = Decimal("0")
+    total_passive_4: Decimal = Decimal("0")
+    cross_ref: int = 0
+    data_center_id: str = ""
+    data_center_rec_num: int = 0
+    account_header_id: int
+    account_header_uu_id: str
+    project_item_id: Optional[int]
+    project_item_uu_id: Optional[str]
+    department_id: Optional[int]
+    department_uu_id: Optional[str]
+
+
+class AccountDetailResponse(BaseModel):
+    """Response model for account detail"""
+
+    doc_date: datetime
+    line_no: int
+    receive_debit: str
+    debit: Decimal
+    department: str = ""
+    special_code: str = ""
+    account_ref: int = 0
+    account_fiche_ref: int = 0
+    center_ref: int = 0
+    general_code: str = ""
+    credit: Decimal = Decimal("0")
+    currency_type: str = "TL"
+    exchange_rate: Decimal = Decimal("0")
+    debit_cur: Decimal = Decimal("0")
+    credit_cur: Decimal = Decimal("0")
+    discount_cur: Decimal = Decimal("0")
+    amount: Decimal = Decimal("0")
+    cross_account_code: str = ""
+    inf_index: Decimal = Decimal("0")
+    not_inflated: int = 0
+    not_calculated: int = 0
+    comment_line1: str = ""
+    comment_line2: str = ""
+    comment_line3: str = ""
+    comment_line4: str = ""
+    comment_line5: str = ""
+    comment_line6: str = ""
+    owner_acc_ref: int = 0
+    from_where: int = 0
+    orj_eid: int = 0
+    canceled: int = 0
+    cross_ref: int = 0
+    data_center_id: str = ""
+    data_center_rec_num: str = "0"
+    status_id: int = 0
+    plug_type_id: Optional[int]
+    plug_type_uu_id: str
+    account_header_id: int
+    account_header_uu_id: str
+    account_code_id: int
+    account_code_uu_id: str
+    account_master_id: int
+    account_master_uu_id: str
+    project_id: Optional[int]
+    project_uu_id: Optional[str]
+
+
+class AccountRecordResponse(BaseModel):
+    """Response model for account financial records.
+
+    This model represents a financial transaction record in the system,
+    including bank transaction details, amounts, and related metadata.
+
+    Attributes:
+        iban (str): International Bank Account Number
+        bank_date (datetime): Date when the transaction occurred at the bank
+        currency_value (Decimal): Original transaction amount
+        bank_balance (Decimal): Account balance after the transaction
+        currency (str): Currency code (e.g., "TRY", "USD")
+        additional_balance (Decimal): Any additional balance adjustments
+        channel_branch (str): Bank branch or channel where transaction occurred
+        process_name (str): Name/type of the transaction
+        process_type (str): Classification of the transaction
+        process_comment (str): Additional transaction details or notes
+        bank_reference_code (str): Bank's reference code for the transaction
+        add_comment_note (Optional[str]): Additional internal notes
+        is_receipt_mail_send (Optional[bool]): Whether receipt was emailed
+        found_from (Optional[str]): Source of the transaction record
+        similarity (Optional[float]): Matching confidence for duplicate detection
+        remainder_balance (Optional[Decimal]): Remaining balance if partial
+        bank_date_y (Optional[int]): Year of bank transaction
+        bank_date_m (Optional[int]): Month of bank transaction
+        bank_date_w (Optional[int]): Week of bank transaction
+        bank_date_d (Optional[int]): Day of bank transaction
+        approving_accounting_record (Optional[bool]): Accounting approval status
+        accounting_receipt_date (Optional[datetime]): When receipt was processed
+        accounting_receipt_number (Optional[int]): Receipt reference number
+        approved_record (Optional[bool]): Whether record is approved
+        import_file_name (Optional[str]): Source file if imported
+        receive_debit_uu_id (Optional[str]): Related debit record ID
+        budget_type_uu_id (Optional[str]): Associated budget type ID
+        company_uu_id (Optional[str]): Associated company ID
+        send_company_uu_id (Optional[str]): Sending company ID
+        customer_id (Optional[str]): Associated customer ID
+        customer_uu_id (Optional[str]): Associated customer UUID
+        send_person_uu_id (Optional[str]): Sending person ID
+        approving_accounting_person_uu_id (Optional[str]): Approver ID
+        build_parts_uu_id (Optional[str]): Related building part ID
+        build_decision_book_uu_id (Optional[str]): Related decision book ID
+    """
+
+    iban: str
+    bank_date: datetime
+    currency_value: Decimal
+    bank_balance: Decimal
+    currency: str = "TRY"
+    additional_balance: Decimal = Decimal("0")
+    channel_branch: str
+    process_name: str
+    process_type: str
+    process_comment: str
+    bank_reference_code: str
+    add_comment_note: Optional[str]
+    is_receipt_mail_send: Optional[bool] = False
+    found_from: Optional[str]
+    similarity: Optional[float]
+    remainder_balance: Optional[Decimal]
+    bank_date_y: Optional[int]
+    bank_date_m: Optional[int]
+    bank_date_w: Optional[int]
+    bank_date_d: Optional[int]
+    approving_accounting_record: Optional[bool]
+    accounting_receipt_date: Optional[datetime]
+    accounting_receipt_number: Optional[int]
+    approved_record: Optional[bool]
+    import_file_name: Optional[str]
+    receive_debit_uu_id: Optional[str]
+    budget_type_uu_id: Optional[str]
+    company_uu_id: Optional[str]
+    send_company_uu_id: Optional[str]
+    customer_id: Optional[str]
+    customer_uu_id: Optional[str]
+    send_person_uu_id: Optional[str]
+    approving_accounting_person_uu_id: Optional[str]
+    build_parts_uu_id: Optional[str]
+    build_decision_book_uu_id: Optional[str]
+
+
+class AccountRecordExchangeResponse(BaseModel):
+    """Response model for currency exchange records.
+
+    This model represents a currency exchange transaction, tracking
+    exchange rates and converted amounts for financial records.
+
+    Attributes:
+        account_record_id (int): ID of the related account record
+        account_record_uu_id (str): UUID of the related account record
+        exchange_rate (Decimal): Applied exchange rate
+        exchange_currency (str): Target currency code
+        exchange_value (Decimal): Converted amount
+        exchange_date (datetime): When the exchange was calculated
+    """
+
+    account_record_id: int
+    account_record_uu_id: str
+    exchange_rate: Decimal
+    exchange_currency: str = "TRY"
+    exchange_value: Decimal
+    exchange_date: datetime
+
+
+class AccountRecordsListResponse(BaseModel):
+    """Response model for account records list endpoint"""
+
+    uu_id: UUID
+    account_name: str
+    account_code: str
+    company_id: int
+    company_uu_id: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False

ApiLayers/ApiValidations/Response/address_responses.py

@@ -0,0 +1,20 @@
+from typing import Optional
+from pydantic import BaseModel
+
+
+class ListAddressResponse(BaseModel):
+    build_number: Optional[str] = None
+    door_number: Optional[str] = None
+    floor_number: Optional[str] = None
+    comment_address: Optional[str] = None
+    letter_address: Optional[str] = None
+    short_letter_address: Optional[str] = None
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None
+    street_uu_id: Optional[str] = None
+
+
+class AddressPostCodeResponse:
+    street_id: Optional[int] = None
+    street_uu_id: Optional[str] = None
+    postcode: Optional[str] = None

ApiLayers/ApiValidations/Response/auth_responses.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from uuid import UUID
+
+
+class AuthenticationLoginResponse(BaseModel):
+    """Response model for authentication login endpoint"""
+
+    token: str
+    refresh_token: str
+    token_type: str
+    expires_in: int
+    user_info: Dict[str, Any]
+
+
+class AuthenticationRefreshResponse(BaseModel):
+    """Response model for authentication refresh endpoint"""
+
+    token: str
+    refresh_token: str
+    token_type: str
+    expires_in: int
+
+
+class AuthenticationUserInfoResponse(BaseModel):
+    """Response model for authentication user info endpoint"""
+
+    user_id: int
+    username: str
+    email: str
+    first_name: str
+    last_name: str
+    is_active: bool
+    created_at: datetime
+    updated_at: Optional[datetime]

ApiLayers/ApiValidations/Response/base_responses.py

@@ -0,0 +1,105 @@
+from pydantic import BaseModel
+from typing import Optional, TypeVar, Generic, List
+from datetime import datetime
+from uuid import UUID
+
+T = TypeVar("T")
+
+
+class BaseResponse(BaseModel):
+    """Base response model that all response models inherit from.
+
+    This model provides common fields that are present in all database records,
+    including tracking information (created/updated timestamps), user actions
+    (created by, updated by, confirmed by), and record status (active, deleted).
+
+    Attributes:
+        uu_id (str): Unique identifier for the record, typically a UUID
+        created_at (datetime): Timestamp when the record was created
+        updated_at (Optional[datetime]): Timestamp when the record was last updated
+        created_by (Optional[str]): Username or identifier of the user who created the record
+        updated_by (Optional[str]): Username or identifier of the user who last updated the record
+        confirmed_by (Optional[str]): Username or identifier of the user who confirmed the record
+        is_confirmed (Optional[bool]): Whether the record has been confirmed/approved
+        active (Optional[bool]): Whether the record is currently active
+        deleted (Optional[bool]): Whether the record has been marked as deleted
+        expiry_starts (Optional[datetime]): When the record becomes valid/active
+        expiry_ends (Optional[datetime]): When the record expires/becomes inactive
+        is_notification_send (Optional[bool]): Whether notifications have been sent for this record
+        is_email_send (Optional[bool]): Whether emails have been sent for this record
+    """
+
+    uu_id: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    created_by: Optional[str]
+    updated_by: Optional[str]
+    confirmed_by: Optional[str]
+    is_confirmed: Optional[bool] = None
+    active: Optional[bool] = True
+    deleted: Optional[bool] = False
+    expiry_starts: Optional[datetime]
+    expiry_ends: Optional[datetime]
+    is_notification_send: Optional[bool] = False
+    is_email_send: Optional[bool] = False
+
+    class Config:
+        """Pydantic configuration for the base response model.
+
+        Attributes:
+            from_attributes (bool): Enables ORM mode for SQLAlchemy integration
+        """
+
+        from_attributes = True
+
+
+class CrudCollection(BaseModel, Generic[T]):
+    """Base collection model for paginated responses.
+
+    This model is used to return collections of items with pagination information.
+    It is generic over the type of items in the collection, allowing it to be
+    used with any response model.
+
+    Type Parameters:
+        T: The type of items in the collection
+
+    Attributes:
+        page (int): Current page number, 1-based indexing
+        size (int): Number of items per page
+        total (int): Total number of items across all pages
+        order_field (str): Field used for sorting the collection
+        order_type (str): Sort direction ('asc' or 'desc')
+        items (List[T]): List of items in the current page
+
+    Example:
+        ```python
+        class UserResponse(BaseResponse):
+            name: str
+            email: str
+
+        users = CrudCollection[UserResponse](
+            page=1,
+            size=10,
+            total=100,
+            order_field="name",
+            order_type="asc",
+            items=[...]
+        )
+        ```
+    """
+
+    page: int = 1
+    size: int = 10
+    total: int = 0
+    order_field: str = "id"
+    order_type: str = "asc"
+    items: List[T] = []
+
+    class Config:
+        """Pydantic configuration for the collection model.
+
+        Attributes:
+            from_attributes (bool): Enables ORM mode for SQLAlchemy integration
+        """
+
+        from_attributes = True

ApiLayers/ApiValidations/Response/budget_responses.py

@@ -0,0 +1,90 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from uuid import UUID
+from decimal import Decimal
+from .base_responses import BaseResponse, CrudCollection
+
+
+class DecisionBookBudgetBooksResponse(BaseResponse):
+    """Response model for decision book budget books"""
+
+    country: str
+    branch_type: int = 0
+    company_id: int
+    company_uu_id: str
+    branch_id: Optional[int]
+    branch_uu_id: Optional[str]
+    build_decision_book_id: int
+    build_decision_book_uu_id: Optional[str]
+
+
+class DecisionBookBudgetBooksCollection(
+    CrudCollection[DecisionBookBudgetBooksResponse]
+):
+    """Collection of decision book budget books"""
+
+    pass
+
+
+class DecisionBookBudgetCodesResponse(BaseResponse):
+    """Response model for decision book budget codes"""
+
+    budget_code: str
+    comment_line: str
+    budget_type: str
+    budget_code_seperator: str = "."
+    system_id: int = 0
+    locked: bool = False
+    company_id: Optional[int]
+    company_uu_id: str
+    customer_id: Optional[int]
+    customer_uu_id: str
+
+
+class DecisionBookBudgetCodesCollection(
+    CrudCollection[DecisionBookBudgetCodesResponse]
+):
+    """Collection of decision book budget codes"""
+
+    pass
+
+
+class DecisionBookBudgetMasterResponse(BaseResponse):
+    """Response model for decision book budget master"""
+
+    budget_type: str
+    currency: str = "TRY"
+    total_budget: Decimal
+    tracking_period_id: Optional[int]
+    tracking_period_uu_id: Optional[str]
+    budget_books_id: int
+    budget_books_uu_id: Optional[str]
+    department_id: int
+    department_uu_id: Optional[str]
+
+
+class DecisionBookBudgetMasterCollection(
+    CrudCollection[DecisionBookBudgetMasterResponse]
+):
+    """Collection of decision book budget masters"""
+
+    pass
+
+
+class DecisionBookBudgetsResponse(BaseResponse):
+    """Response model for decision book budgets"""
+
+    process_date: datetime
+    budget_codes_id: int
+    total_budget: Decimal
+    used_budget: Decimal = Decimal("0")
+    remaining_budget: Decimal = Decimal("0")
+    decision_book_budget_master_id: int
+    decision_book_budget_master_uu_id: Optional[str]
+
+
+class DecisionBookBudgetsCollection(CrudCollection[DecisionBookBudgetsResponse]):
+    """Collection of decision book budgets"""
+
+    pass

ApiLayers/ApiValidations/Response/building_responses.py

@@ -0,0 +1,309 @@
+from typing import Optional, List, Generic
+from datetime import datetime
+from uuid import UUID
+from decimal import Decimal
+
+from api_validations.validations_response.base_responses import (
+    BaseResponse,
+    CrudCollection,
+)
+from api_validations.validations_request import PydanticBaseModel
+
+
+class ListBuildingResponse(PydanticBaseModel):
+
+    gov_address_code: str
+    build_name: str
+    build_types_uu_id: Optional[str] = None
+    build_no: Optional[str] = None
+    max_floor: Optional[int] = None
+    underground_floor: Optional[int] = None
+    address_uu_id: Optional[str] = None
+    build_date: Optional[str] = None
+    decision_period_date: Optional[str] = None
+    tax_no: Optional[str] = None
+    lift_count: Optional[int] = None
+    heating_system: Optional[bool] = None
+    cooling_system: Optional[bool] = None
+    hot_water_system: Optional[bool] = None
+    block_service_man_count: Optional[int] = None
+    security_service_man_count: Optional[int] = None
+    garage_count: Optional[int] = None
+    site_uu_id: Optional[str] = None
+
+
+class BuildAreaListResponse(BaseResponse):
+    """Response model for building area list endpoint"""
+
+    uu_id: UUID
+    build_id: int
+    build_uu_id: str
+    area_name: str
+    area_value: float
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class BuildAreaListCollection(CrudCollection[BuildAreaListResponse]):
+    """Collection of building area list"""
+
+    pass
+
+
+class BuildSitesListResponse(BaseResponse):
+    """Response model for building sites list endpoint"""
+
+    uu_id: UUID
+    address_id: int
+    site_name: str
+    site_value: float
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class BuildSitesListCollection(CrudCollection[BuildSitesListResponse]):
+    """Collection of building sites list"""
+
+    pass
+
+
+class BuildTypesListResponse(BaseResponse):
+    """Response model for building types list endpoint"""
+
+    uu_id: UUID
+    type_name: str
+    type_value: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class BuildTypesListCollection(CrudCollection[BuildTypesListResponse]):
+    """Collection of building types list"""
+
+    pass
+
+
+class BuildTypesResponse(BaseResponse):
+    """Response model for building types"""
+
+    function_code: str
+    type_code: str
+    lang: str = "TR"
+
+
+class BuildTypesCollection(CrudCollection[BuildTypesResponse]):
+    """Collection of building types"""
+
+    pass
+
+
+class Part2EmployeeResponse(BaseResponse):
+    """Response model for part to employee mapping"""
+
+    build_id: int
+    part_id: int
+    employee_id: int
+
+
+class Part2EmployeeCollection(CrudCollection[Part2EmployeeResponse]):
+    """Collection of part to employee mappings"""
+
+    pass
+
+
+class RelationshipEmployee2BuildResponse(BaseResponse):
+    """Response model for employee to build relationship"""
+
+    company_id: int
+    employee_id: int
+    member_id: int
+    relationship_type: Optional[str] = "Employee"
+    show_only: bool = False
+
+
+class RelationshipEmployee2BuildCollection(
+    CrudCollection[RelationshipEmployee2BuildResponse]
+):
+    """Collection of employee to build relationships"""
+
+    pass
+
+
+class BuildResponse(BaseResponse):
+    """Response model for buildings"""
+
+    gov_address_code: str = ""
+    build_name: str
+    build_no: str
+    max_floor: int = 1
+    underground_floor: int = 0
+    build_date: datetime
+    decision_period_date: datetime
+    tax_no: str = ""
+    lift_count: int = 0
+    heating_system: bool = True
+    cooling_system: bool = False
+    hot_water_system: bool = False
+    block_service_man_count: int = 0
+    security_service_man_count: int = 0
+    garage_count: int = 0
+    management_room_id: Optional[int]
+    site_id: Optional[int]
+    site_uu_id: Optional[str]
+    address_id: int
+    address_uu_id: str
+    build_types_id: int
+    build_types_uu_id: Optional[str]
+
+
+class BuildCollection(CrudCollection[BuildResponse]):
+    """Collection of buildings"""
+
+    pass
+
+
+class BuildPartsResponse(BaseResponse):
+    """Response model for building parts"""
+
+    address_gov_code: str
+    part_no: int = 0
+    part_level: int = 0
+    part_code: str
+    part_gross_size: int = 0
+    part_net_size: int = 0
+    default_accessory: str = "0"
+    human_livable: bool = True
+    due_part_key: str
+    build_id: int
+    build_uu_id: str
+    part_direction_id: Optional[int]
+    part_direction_uu_id: Optional[str]
+    part_type_id: int
+    part_type_uu_id: str
+
+
+class BuildPartsCollection(CrudCollection[BuildPartsResponse]):
+    """Collection of building parts"""
+
+    pass
+
+
+class BuildLivingSpaceResponse(BaseResponse):
+    """Response model for building living space"""
+
+    fix_value: Decimal = Decimal("0")
+    fix_percent: Decimal = Decimal("0")
+    agreement_no: str = ""
+    marketing_process: bool = False
+    marketing_layer: int = 0
+    build_parts_id: int
+    build_parts_uu_id: str
+    person_id: int
+    person_uu_id: str
+    occupant_type: int
+    occupant_type_uu_id: str
+
+
+class BuildLivingSpaceCollection(CrudCollection[BuildLivingSpaceResponse]):
+    """Collection of building living spaces"""
+
+    pass
+
+
+class BuildManagementResponse(BaseResponse):
+    """Response model for building management"""
+
+    discounted_percentage: Decimal = Decimal("0.00")
+    discounted_price: Decimal = Decimal("0.00")
+    calculated_price: Decimal = Decimal("0.00")
+    occupant_type: int
+    occupant_type_uu_id: str
+    build_id: int
+    build_uu_id: str
+    build_parts_id: int
+    build_parts_uu_id: str
+
+
+class BuildManagementCollection(CrudCollection[BuildManagementResponse]):
+    """Collection of building management records"""
+
+    pass
+
+
+class BuildAreaResponse(BaseResponse):
+    """Response model for building area"""
+
+    area_name: str = ""
+    area_code: str = ""
+    area_type: str = "GREEN"
+    area_direction: str = "NN"
+    area_gross_size: Decimal = Decimal("0")
+    area_net_size: Decimal = Decimal("0")
+    width: int = 0
+    size: int = 0
+    build_id: int
+    build_uu_id: str
+    part_type_id: Optional[int]
+    part_type_uu_id: Optional[str]
+
+
+class BuildAreaCollection(CrudCollection[BuildAreaResponse]):
+    """Collection of building areas"""
+
+    pass
+
+
+class BuildSitesResponse(BaseResponse):
+    """Response model for building sites"""
+
+    site_name: str
+    site_no: str
+    address_id: int
+    address_uu_id: Optional[str]
+
+
+class BuildSitesCollection(CrudCollection[BuildSitesResponse]):
+    """Collection of building sites"""
+
+    pass
+
+
+class BuildCompaniesProvidingResponse(BaseResponse):
+    """Response model for building companies providing services"""
+
+    build_id: int
+    build_uu_id: Optional[str]
+    company_id: int
+    company_uu_id: Optional[str]
+    provide_id: Optional[int]
+    provide_uu_id: Optional[str]
+    contract_id: Optional[int]
+
+
+class BuildCompaniesProvidingCollection(
+    CrudCollection[BuildCompaniesProvidingResponse]
+):
+    """Collection of building companies providing services"""
+
+    pass
+
+
+class BuildPersonProvidingResponse(BaseResponse):
+    """Response model for building person providing services"""
+
+    build_id: int
+    build_uu_id: Optional[str]
+    people_id: int
+    people_uu_id: Optional[str]
+    provide_id: Optional[int]
+    provide_uu_id: Optional[str]
+    contract_id: Optional[int]
+
+
+class BuildPersonProvidingCollection(CrudCollection[BuildPersonProvidingResponse]):
+    """Collection of building person providing services"""
+
+    pass

ApiLayers/ApiValidations/Response/company_responses.py

@@ -0,0 +1,59 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from uuid import UUID
+
+
+class CompanyListResponse(BaseModel):
+    """Response model for company list endpoint"""
+
+    uu_id: UUID
+    company_name: str
+    company_code: str
+    company_email: str
+    company_phone: str
+    company_address: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class CompanyDepartmentListResponse(BaseModel):
+    """Response model for company department list endpoint"""
+
+    uu_id: UUID
+    department_name: str
+    department_code: str
+    company_id: int
+    company_uu_id: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class CompanyDutyListResponse(BaseModel):
+    """Response model for company duty list endpoint"""
+
+    uu_id: UUID
+    duty_name: str
+    duty_code: str
+    department_id: int
+    department_uu_id: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False
+
+
+class CompanyEmployeeListResponse(BaseModel):
+    """Response model for company employee list endpoint"""
+
+    uu_id: UUID
+    employee_id: int
+    employee_uu_id: str
+    company_id: int
+    company_uu_id: str
+    duty_id: int
+    duty_uu_id: str
+    created_at: datetime
+    updated_at: Optional[datetime]
+    deleted: bool = False

ApiLayers/ApiValidations/Response/decision_book_responses.py

@@ -0,0 +1,204 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from uuid import UUID
+from decimal import Decimal
+from .base_responses import BaseResponse, CrudCollection
+
+
+class BuildDecisionBookResponse(BaseResponse):
+    """Response model for building decision book"""
+
+    decision_book_pdf_path: Optional[str] = ""
+    resp_company_fix_wage: float = 0
+    contact_agreement_path: Optional[str] = ""
+    contact_agreement_date: Optional[datetime]
+    meeting_date: Optional[str]
+    decision_type: Optional[str]
+
+
+class BuildDecisionBookCollection(CrudCollection[BuildDecisionBookResponse]):
+    """Collection of building decision books"""
+
+    pass
+
+
+class BuildDecisionBookInvitationsResponse(BaseResponse):
+    """Response model for building decision book invitations"""
+
+    build_id: int
+    build_uu_id: Optional[str]
+    decision_book_id: int
+    decision_book_uu_id: Optional[str]
+    invitation_type: str
+    invitation_attempt: int = 1
+    living_part_count: int = 1
+    living_part_percentage: Decimal = Decimal("0.51")
+    message: Optional[str]
+    planned_date: datetime
+    planned_date_expires: datetime
+
+
+class BuildDecisionBookInvitationsCollection(
+    CrudCollection[BuildDecisionBookInvitationsResponse]
+):
+    """Collection of building decision book invitations"""
+
+    pass
+
+
+class BuildDecisionBookPersonResponse(BaseResponse):
+    """Response model for building decision book person"""
+
+    dues_percent_discount: int = 0
+    dues_fix_discount: Decimal = Decimal("0")
+    dues_discount_approval_date: datetime
+    send_date: datetime
+    is_attending: bool = False
+    confirmed_date: Optional[datetime]
+    token: str = ""
+    vicarious_person_id: Optional[int]
+    vicarious_person_uu_id: Optional[str]
+    invite_id: int
+    invite_uu_id: str
+    build_decision_book_id: int
+    build_decision_book_uu_id: str
+    build_living_space_id: int
+    build_living_space_uu_id: Optional[str]
+    person_id: int
+
+
+class BuildDecisionBookPersonCollection(
+    CrudCollection[BuildDecisionBookPersonResponse]
+):
+    """Collection of building decision book persons"""
+
+    pass
+
+
+class BuildDecisionBookPersonOccupantsResponse(BaseResponse):
+    """Response model for building decision book person occupants"""
+
+    build_decision_book_person_id: int
+    build_decision_book_person_uu_id: Optional[str]
+    invite_id: Optional[int]
+    invite_uu_id: Optional[str]
+    occupant_type_id: int
+    occupant_type_uu_id: Optional[str]
+
+
+class BuildDecisionBookPersonOccupantsCollection(
+    CrudCollection[BuildDecisionBookPersonOccupantsResponse]
+):
+    """Collection of building decision book person occupants"""
+
+    pass
+
+
+class BuildDecisionBookItemsResponse(BaseResponse):
+    """Response model for building decision book items"""
+
+    item_order: int
+    item_comment: str
+    item_objection: Optional[str]
+    info_is_completed: bool = False
+    is_payment_created: bool = False
+    info_type_id: Optional[int]
+    info_type_uu_id: Optional[str]
+    build_decision_book_id: int
+    build_decision_book_uu_id: Optional[str]
+    item_short_comment: Optional[str]
+
+
+class BuildDecisionBookItemsCollection(CrudCollection[BuildDecisionBookItemsResponse]):
+    """Collection of building decision book items"""
+
+    pass
+
+
+class BuildDecisionBookItemsUnapprovedResponse(BaseResponse):
+    """Response model for building decision book items unapproved"""
+
+    item_objection: str
+    item_order: int
+    decision_book_item_id: int
+    decision_book_item_uu_id: Optional[str]
+    person_id: int
+    person_uu_id: Optional[str]
+    build_decision_book_item: int
+    build_decision_book_item_uu_id: Optional[str]
+
+
+class BuildDecisionBookItemsUnapprovedCollection(
+    CrudCollection[BuildDecisionBookItemsUnapprovedResponse]
+):
+    """Collection of building decision book items unapproved"""
+
+    pass
+
+
+class BuildDecisionBookPaymentsResponse(BaseResponse):
+    """Response model for building decision book payments"""
+
+    payment_plan_time_periods: str
+    process_date: datetime
+    payment_amount: Decimal
+    currency: str = "TRY"
+    payment_types_id: Optional[int]
+    payment_types_uu_id: Optional[str]
+    period_time: str
+    process_date_y: int
+    process_date_m: int
+    build_decision_book_item_id: int
+    build_decision_book_item_uu_id: str
+    build_parts_id: int
+    build_parts_uu_id: str
+    decision_book_project_id: Optional[int]
+    decision_book_project_uu_id: Optional[str]
+    account_records_id: Optional[int]
+    account_records_uu_id: Optional[str]
+
+
+class BuildDecisionBookPaymentsCollection(
+    CrudCollection[BuildDecisionBookPaymentsResponse]
+):
+    """Collection of building decision book payments"""
+
+    pass
+
+
+class BuildDecisionBookLegalResponse(BaseResponse):
+    """Response model for building decision book legal"""
+
+    period_start_date: datetime
+    lawsuits_decision_number: str
+    lawsuits_decision_date: datetime
+    period_stop_date: datetime
+    decision_book_pdf_path: Optional[str] = ""
+    resp_company_total_wage: Optional[Decimal] = Decimal("0")
+    contact_agreement_path: Optional[str] = ""
+    contact_agreement_date: Optional[datetime]
+    meeting_date: str
+    lawsuits_type: str = "C"
+    lawsuits_name: str
+    lawsuits_note: str
+    lawyer_cost: Decimal
+    mediator_lawyer_cost: Decimal
+    other_cost: Decimal
+    legal_cost: Decimal
+    approved_cost: Decimal
+    total_price: Decimal
+    build_db_item_id: int
+    build_db_item_uu_id: Optional[str]
+    resp_attorney_id: int
+    resp_attorney_uu_id: Optional[str]
+    resp_attorney_company_id: int
+    resp_attorney_company_uu_id: Optional[str]
+    mediator_lawyer_person_id: int
+    mediator_lawyer_person_uu_id: Optional[str]
+
+
+class BuildDecisionBookLegalCollection(CrudCollection[BuildDecisionBookLegalResponse]):
+    """Collection of building decision book legal records"""
+
+    pass

ApiLayers/ApiValidations/Response/default_response.py

@@ -0,0 +1,175 @@
+from ast import Dict
+from typing import Any, Optional
+from fastapi import status
+from fastapi.responses import JSONResponse
+
+class BaseEndpointResponse:
+
+    def __init__(self, code: str, lang: str):
+        self.code = code
+        self.lang = lang
+
+    def retrieve_message(self):
+        messages = {}
+        return messages[self.code][self.lang]
+    
+
+# 1. 200 OK
+class EndpointSuccessResponse(BaseEndpointResponse):
+
+    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content=dict(
+                completed=True,
+                message=self.retrieve_message(),
+                lang=self.lang,
+                data=data
+            )
+        )
+
+
+# 2. 201 Created
+class EndpointCreatedResponse(BaseEndpointResponse):
+
+    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+        return JSONResponse(
+            status_code=status.HTTP_201_CREATED,
+            content=dict(
+                completed=True,
+                message=self.retrieve_message(),
+                lang=self.lang,
+                data=data
+            )
+        )
+
+
+# 3. 202 Accepted
+class EndpointAcceptedResponse(BaseEndpointResponse):
+
+
+    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+        return JSONResponse(
+            status_code=status.HTTP_202_ACCEPTED,
+            content=dict(
+                completed=True,
+                message=self.retrieve_message(),
+                lang=self.lang,
+                data=data
+            )
+        )
+
+
+# 4. 400 Bad Request
+class EndpointBadRequestResponse(BaseEndpointResponse):
+
+    def as_dict(self, data: Optional[Dict[str, Any]] = None):
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang,
+                data=data
+            )
+        )
+
+
+# 5. 401 Unauthorized
+class EndpointUnauthorizedResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+
+# 6. 404 Not Found
+class EndpointNotFoundResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+
+# 3. 403 Forbidden
+class EndpointForbiddenResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_403_FORBIDDEN,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+
+# 6. 409 Conflict
+class EndpointConflictResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_409_CONFLICT,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+# 7. 429 Too Many Requests
+class EndpointTooManyRequestsResponse(BaseEndpointResponse):
+    
+    def __init__(self, retry_after: int):
+        self.retry_after = retry_after
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            headers={"Retry-After": str(self.retry_after)},
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+
+# 7. 500 Internal Server Error
+class EndpointInternalErrorResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )
+
+
+class EndpointErrorResponse(BaseEndpointResponse):
+
+    def as_dict(self):
+        return JSONResponse(
+            status_code=status.HTTP_304_NOT_MODIFIED,
+            content=dict(
+                completed=False,
+                message=self.retrieve_message(),
+                lang=self.lang
+            )
+        )

ApiLayers/ApiValidations/Response/living_space_responses.py

@@ -0,0 +1,52 @@
+from typing import Optional
+from api_validations.core_validations import BaseModelRegular
+from api_validations.validations_request import (
+    CrudRecordValidation,
+    CrudRecords,
+)
+
+
+class LivingSpaceListValidation:
+    tr = {
+        **CrudRecordValidation.tr,
+        "fix_value": "Sabit Değer",
+        "fix_percent": "Sabit Yüzde",
+        "agreement_no": "Anlaşma No",
+        "marketing_process": "Pazarlama Süreci",
+        "marketing_layer": "Pazarlama Katmanı",
+        "build_parts_id": "Bölüm ID",
+        "build_parts_uu_id": "Bölüm UUID",
+        "person_id": "Sorumlu Kişi ID",
+        "person_uu_id": "Sorumlu Kişi UUID",
+        "occupant_type": "Kiracı Tipi",
+        "occupant_type_uu_id": "Kiracı Tipi UUID",
+    }
+    en = {
+        **CrudRecordValidation.en,
+        "fix_value": "Fixed Value",
+        "fix_percent": "Fixed Percent",
+        "agreement_no": "Agreement No",
+        "marketing_process": "Marketing Process",
+        "marketing_layer": "Marketing Layer",
+        "build_parts_id": "Part ID",
+        "build_parts_uu_id": "Part UUID",
+        "person_id": "Responsible Person ID",
+        "person_uu_id": "Responsible Person UUID",
+        "occupant_type": "Occupant Type",
+        "occupant_type_uu_id": "Occupant Type UUID",
+    }
+
+
+class LivingSpaceListResponse(BaseModelRegular, CrudRecords, LivingSpaceListValidation):
+
+    fix_value: Optional[float] = None
+    fix_percent: Optional[float] = None
+    agreement_no: Optional[str] = None
+    marketing_process: Optional[str] = None
+    marketing_layer: Optional[str] = None
+    build_parts_id: Optional[int] = None
+    build_parts_uu_id: Optional[str] = None
+    person_id: Optional[int] = None
+    person_uu_id: Optional[str] = None
+    occupant_type: Optional[str] = None
+    occupant_type_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Response/parts_responses.py

@@ -0,0 +1,54 @@
+from typing import Optional
+from api_validations.core_validations import BaseModelRegular
+from api_validations.validations_request import (
+    CrudRecordValidation,
+    CrudRecords,
+)
+
+
+class BuildPartsListValidation:
+    tr = {
+        **CrudRecordValidation.tr,
+        "address_gov_code": "Adres Kapı Kodu",
+        "part_no": "Bölüm No",
+        "part_level": "Bölüm Seviyesi",
+        "part_code": "Bölüm Kodu",
+        "part_gross": "Bölüm Brüt",
+        "part_net": "Bölüm Net",
+        "default_accessory": "Varsayılan Aksesuar",
+        "human_livable": "İnsan Yaşamı",
+        "due_part_key": "Sabit Ödeme Grubu",
+        "build_uu_id": "Bina UUID",
+        "part_direction_uu_id": "Bölüm Yönü UUID",
+        "part_type_uu_id": "Bölüm Tipi UUID",
+    }
+    en = {
+        **CrudRecordValidation.en,
+        "address_gov_code": "Address Government Code",
+        "part_no": "Part Number",
+        "part_level": "Part Level",
+        "part_code": "Part Code",
+        "part_gross": "Part Gross",
+        "part_net": "Part Net",
+        "default_accessory": "Default Accessory",
+        "human_livable": "Human Livable",
+        "due_part_key": "Constant Payment Group",
+        "build_uu_id": "Building UUID",
+        "part_direction_uu_id": "Part Direction UUID",
+        "part_type_uu_id": "Part Type UUID",
+    }
+
+
+class BuildPartsListResponse(BaseModelRegular, CrudRecords, BuildPartsListValidation):
+    address_gov_code: Optional[str] = None
+    part_no: Optional[int] = None
+    part_level: Optional[int] = None
+    part_code: Optional[str] = None
+    part_gross: Optional[int] = None
+    part_net: Optional[int] = None
+    default_accessory: Optional[str] = None
+    human_livable: Optional[bool] = None
+    due_part_key: Optional[str] = None
+    build_uu_id: Optional[str] = None
+    part_direction_uu_id: Optional[str] = None
+    part_type_uu_id: Optional[str] = None

ApiLayers/ApiValidations/Response/people_responses.py

@@ -0,0 +1,57 @@
+from typing import Optional
+from api_validations.core_validations import BaseModelRegular
+from api_validations.validations_request import (
+    CrudRecordValidation,
+    CrudRecords,
+)
+
+
+class PeopleListValidation:
+    tr = {
+        **CrudRecordValidation.tr,
+        "firstname": "Ad",
+        "surname": "Soyad",
+        "middle_name": "Orta İsim",
+        "sex_code": "Cinsiyet Kodu",
+        "person_ref": "Kişi Referansı",
+        "person_tag": "Kişi Etiketi",
+        "father_name": "Baba Adı",
+        "mother_name": "Anne Adı",
+        "country_code": "Ülke Kodu",
+        "national_identity_id": "Kimlik Numarası",
+        "birth_place": "Doğum Yeri",
+        "birth_date": "Doğum Tarihi",
+        "tax_no": "Vergi Numarası",
+    }
+    en = {
+        **CrudRecordValidation.en,
+        "firstname": "First Name",
+        "surname": "Surname",
+        "middle_name": "Middle Name",
+        "sex_code": "Sex Code",
+        "person_ref": "Person Reference",
+        "person_tag": "Person Tag",
+        "father_name": "Father's Name",
+        "mother_name": "Mother's Name",
+        "country_code": "Country Code",
+        "national_identity_id": "National Identity ID",
+        "birth_place": "Birth Place",
+        "birth_date": "Birth Date",
+        "tax_no": "Tax Number",
+    }
+
+
+class PeopleListResponse(BaseModelRegular, CrudRecords, PeopleListValidation):
+    firstname: Optional[str] = None
+    surname: Optional[str] = None
+    middle_name: Optional[str] = None
+    sex_code: Optional[str] = None
+    person_ref: Optional[str] = None
+    person_tag: Optional[str] = None
+    father_name: Optional[str] = None
+    mother_name: Optional[str] = None
+    country_code: Optional[str] = None
+    national_identity_id: Optional[str] = None
+    birth_place: Optional[str] = None
+    birth_date: Optional[str] = None
+    tax_no: Optional[str] = None

ApiLayers/ApiValidations/handler.py

@@ -0,0 +1,58 @@
+"""
+Base validation models and utilities.
+"""
+
+from pydantic import BaseModel, ConfigDict
+
+
+def rewrite_input_data(data):
+    """Remove empty and None values from input data."""
+    return {
+        item[0]: item[1]
+        for item in data.items()
+        if not item[1] == "" and item[1] is not None
+    }
+
+
+class BaseModelRegular(BaseModel):
+    """Base model for all validation models with proper schema handling."""
+
+    model_config = ConfigDict(
+        json_schema_extra={"example": {}}  # Will be populated by subclasses
+    )
+
+    def __init__(self, **kwargs):
+        super().__init__(**rewrite_input_data(kwargs))
+
+    def excluded_dump(self):
+        return self.model_dump(exclude_unset=True, exclude_none=True)
+
+    def dump(self):
+        return self.model_dump()
+
+    @classmethod
+    def model_json_schema(cls, *args, **kwargs):
+        """Generate JSON schema with proper examples."""
+        schema = super().model_json_schema(*args, **kwargs)
+
+        # Add examples based on field types
+        if "properties" in schema:
+            example = {}
+            for field_name, field_schema in schema["properties"].items():
+                field_type = field_schema.get("type")
+                if field_type == "string":
+                    example[field_name] = f"example_{field_name}"
+                elif field_type == "integer":
+                    example[field_name] = 0
+                elif field_type == "number":
+                    example[field_name] = 0.0
+                elif field_type == "boolean":
+                    example[field_name] = False
+                elif field_type == "array":
+                    example[field_name] = []
+                elif field_type == "object":
+                    example[field_name] = {}
+
+            schema["example"] = example
+
+        return schema

ApiLayers/ErrorHandlers/ErrorHandlers/api_exc_handler.py

@@ -0,0 +1,59 @@
+from typing import Any, Dict, Union, Awaitable
+from fastapi import Request, WebSocket
+from fastapi.responses import Response
+
+from LanguageModels.Errors.merge_all_error_languages import MergedErrorLanguageModels
+from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
+from ErrorHandlers.bases import BaseErrorModelClass
+
+
+class HTTPExceptionApiHandler:
+
+    def __init__(
+        self,
+        response_model: Any,
+    ):
+        self.RESPONSE_MODEL: Any = response_model
+
+    @staticmethod
+    def retrieve_error_status_code(exc: HTTPExceptionApi) -> int:
+        error_by_codes = BaseErrorModelClass.retrieve_error_by_codes()
+        grab_status_code = error_by_codes.get(str(exc.error_code).upper(), 500)
+        return int(grab_status_code)
+
+    @staticmethod
+    def retrieve_error_message(exc: HTTPExceptionApi, error_languages) -> str:
+        from ErrorHandlers import DEFAULT_ERROR
+
+        return error_languages.get(str(exc.error_code).upper(), DEFAULT_ERROR)
+
+    async def handle_exception(
+        self, request: Union[Request, WebSocket], exc: Exception
+    ) -> Union[Response, Awaitable[None]]:
+        request_string = (
+            str(request.url) if isinstance(request, Request) else request.url.path
+        )
+        if isinstance(exc, HTTPExceptionApi):
+            error_languages = MergedErrorLanguageModels.get_language_models(
+                language=exc.lang
+            )
+            status_code = self.retrieve_error_status_code(exc)
+            error_message = self.retrieve_error_message(exc, error_languages)
+            return self.RESPONSE_MODEL(
+                status_code=int(status_code),
+                content={
+                    "message": error_message,
+                    "lang": exc.lang,
+                    "request": request_string,
+                    "loc": exc.loc,
+                },
+            )
+        return self.RESPONSE_MODEL(
+            status_code=500,
+            content={
+                "message": "Internal Server Error",
+                "lang": "def",
+                "request": request_string,
+                "loc": exc.loc,
+            },
+        )  # Handle other exceptions with a generic 500 error

ApiLayers/ErrorHandlers/Exceptions/api_exc.py

@@ -0,0 +1,7 @@
+class HTTPExceptionApi(Exception):
+
+    def __init__(self, error_code: str, lang: str, loc: str = "", sys_msg: str = ""):
+        self.error_code = error_code
+        self.lang = lang
+        self.loc = loc
+        self.sys_msg = sys_msg

ApiLayers/ErrorHandlers/__init__.py

@@ -0,0 +1,10 @@
+from ErrorHandlers.ErrorHandlers.api_exc_handler import (
+    HTTPExceptionApiHandler,
+)
+from ErrorHandlers.Exceptions.api_exc import (
+    HTTPExceptionApi,
+)
+
+DEFAULT_ERROR = "UNKNOWN_ERROR"
+
+__all__ = ["HTTPExceptionApiHandler", "HTTPExceptionApi", "DEFAULT_ERROR"]

ApiLayers/ErrorHandlers/base.py

@@ -0,0 +1,13 @@
+class BaseError:
+    NOT_CREATED: int = 405
+    NOT_DELETED: int = 405
+    NOT_UPDATED: int = 405
+    NOT_LISTED: int = 404
+    NOT_FOUND: int = 404
+    ALREADY_EXISTS: int = 400
+    IS_NOT_CONFIRMED: int = 405
+    NOT_AUTHORIZED: int = 401
+    NOT_VALID: int = 406
+    NOT_ACCEPTABLE: int = 406
+    INVALID_DATA: int = 422
+    UNKNOWN_ERROR: int = 502

ApiLayers/ErrorHandlers/bases.py

@@ -0,0 +1,18 @@
+from ErrorHandlers.base import BaseError
+from ErrorHandlers.statuses import Statuses
+
+
+class BaseErrorModelClass:
+    list_of_statuses = [Statuses, BaseError]
+
+    @classmethod
+    def retrieve_error_by_codes(cls):
+        language_model_status = {}
+        for list_of_language in cls.list_of_statuses:
+            clean_dict = {
+                key: value
+                for key, value in list_of_language.__dict__.items()
+                if "__" not in str(key)[0:3]
+            }
+            language_model_status.update(clean_dict)
+        return language_model_status

ApiLayers/ErrorHandlers/statuses.py

@@ -0,0 +1,58 @@
+class Statuses:
+    HTTP_100_CONTINUE = 100
+    HTTP_101_SWITCHING_PROTOCOLS = 101
+    HTTP_102_PROCESSING = 102
+    HTTP_103_EARLY_HINTS = 103
+    HTTP_200_OK = 200
+    HTTP_201_CREATED = 201
+    HTTP_202_ACCEPTED = 202
+    HTTP_203_NON_AUTHORITATIVE_INFORMATION = 203
+    HTTP_204_NO_CONTENT = 204
+    HTTP_205_RESET_CONTENT = 205
+    HTTP_206_PARTIAL_CONTENT = 206
+    HTTP_207_MULTI_STATUS = 207
+    HTTP_208_ALREADY_REPORTED = 208
+    HTTP_226_IM_USED = 226
+    HTTP_300_MULTIPLE_CHOICES = 300
+    HTTP_301_MOVED_PERMANENTLY = 301
+    HTTP_302_FOUND = 302
+    HTTP_303_SEE_OTHER = 303
+    HTTP_304_NOT_MODIFIED = 304
+    HTTP_305_USE_PROXY = 305
+    HTTP_306_RESERVED = 306
+    HTTP_307_TEMPORARY_REDIRECT = 307
+    HTTP_308_PERMANENT_REDIRECT = 308
+    HTTP_400_BAD_REQUEST = 400
+    HTTP_401_UNAUTHORIZED = 401
+    HTTP_402_PAYMENT_REQUIRED = 402
+    HTTP_403_FORBIDDEN = 403
+    HTTP_404_NOT_FOUND = 404
+    HTTP_405_METHOD_NOT_ALLOWED = 405
+    HTTP_406_NOT_ACCEPTABLE = 406
+    HTTP_407_PROXY_AUTHENTICATION_REQUIRED = 407
+    HTTP_408_REQUEST_TIMEOUT = 408
+    HTTP_409_CONFLICT = 409
+    HTTP_410_GONE = 410
+    HTTP_411_LENGTH_REQUIRED = 411
+    HTTP_412_PRECONDITION_FAILED = 412
+    HTTP_413_REQUEST_ENTITY_TOO_LARGE = 413
+    HTTP_414_REQUEST_URI_TOO_LONG = 414
+    HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
+    HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    HTTP_417_EXPECTATION_FAILED = 417
+    HTTP_418_IM_A_TEAPOT = 418
+    HTTP_421_MISDIRECTED_REQUEST = 421
+    HTTP_422_UNPROCESSABLE_ENTITY = 422
+    HTTP_423_LOCKED = 423
+    HTTP_424_FAILED_DEPENDENCY = 424
+    HTTP_426_UPGRADE_REQUIRED = 426
+    HTTP_428_PRECONDITION_REQUIRED = 428
+    HTTP_429_TOO_MANY_REQUESTS = 429
+    HTTP_431_REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    HTTP_451_UNAVAILABLE_FOR_LEGAL_REASONS = 451
+    HTTP_500_INTERNAL_SERVER_ERROR = 500
+    HTTP_502_BAD_GATEWAY = 502
+
+    @classmethod
+    def retrieve_error_by_code(cls, error_code: str):
+        return getattr(cls, error_code, 502)

ApiLayers/LanguageModels/Database/Mixins/crud_mixin.py

@@ -0,0 +1,42 @@
+CrudCollectionLanguageModel = dict(
+    tr={
+        "id": "ID",
+        "uu_id": "UUID",
+        "ref_id": "Referans ID",
+        "created_at": "Oluşturulma Tarihi",
+        "updated_at": "Güncellenme Tarihi",
+        "cryp_uu_id": "Şifreli ID",
+        "created_by": "Oluşturan",
+        "created_by_id": "Oluşturan ID",
+        "updated_by": "Güncelleyen",
+        "updated_by_id": "Güncelleyen ID",
+        "confirmed_by": "Onaylayan",
+        "confirmed_by_id": "Onaylayan ID",
+        "is_confirmed": "Onay Durumu",
+        "replication_id": "Replikasyon ID",
+        "deleted": "Silindi",
+        "active": "Aktif",
+        "is_notification_send": "Bildirim Gönderildi",
+        "is_email_send": "E-posta Gönderildi",
+    },
+    en={
+        "id": "Identity",
+        "uu_id": "UUID",
+        "ref_id": "Reference Identity",
+        "created_at": "Created At",
+        "updated_at": "Updated At",
+        "cryp_uu_id": "Encrypted Identity",
+        "created_by": "Created By",
+        "created_by_id": "Created By Identity",
+        "updated_by": "Updated By",
+        "updated_by_id": "Updated By Identity",
+        "confirmed_by": "Confirmed By",
+        "confirmed_by_id": "Confirmed By Identity",
+        "is_confirmed": "Confirmation Status",
+        "replication_id": "Replication Identity",
+        "deleted": "Deleted",
+        "active": "Active",
+        "is_notification_send": "Notification Sent",
+        "is_email_send": "Email Sent",
+    },
+)

ApiLayers/LanguageModels/Database/account/account.py

@@ -0,0 +1,388 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+AccountBooksLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "country": "Ülke",
+        "branch_type": "Şube Türü",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UU ID",
+        "branch_id": "Şube ID",
+        "branch_uu_id": "Şube UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "country": "Country",
+        "branch_type": "Branch Type",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UU ID",
+        "branch_id": "Branch ID",
+        "branch_uu_id": "Branch UU ID",
+    },
+)
+
+AccountCodesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "account_code": "Hesap Kodu",
+        "comment_line": "Yorum Satırı",
+        "is_receive_or_debit": "Alacak veya Borç",
+        "product_id": "Ürün ID",
+        "nvi_id": "Nvi ID",
+        "status_id": "Durum ID",
+        "account_code_seperator": "Hesap Kodu Ayırıcı",
+        "system_id": "Sistem ID",
+        "locked": "Kilitli",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UU ID",
+        "customer_id": "Müşteri ID",
+        "customer_uu_id": "Müşteri UU ID",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "account_code": "Account Code",
+        "comment_line": "Comment Line",
+        "is_receive_or_debit": "Is Receive or Debit",
+        "product_id": "Product ID",
+        "nvi_id": "Nvi ID",
+        "status_id": "Status ID",
+        "account_code_seperator": "Account Code Seperator",
+        "system_id": "System ID",
+        "locked": "Locked",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UU ID",
+        "customer_id": "Customer ID",
+        "customer_uu_id": "Customer UU ID",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UU ID",
+    },
+)
+
+AccountCodeParserLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "account_code_1": "Hesap Kodu 1",
+        "account_code_2": "Hesap Kodu 2",
+        "account_code_3": "Hesap Kodu 3",
+        "account_code_4": "Hesap Kodu 4",
+        "account_code_5": "Hesap Kodu 5",
+        "account_code_6": "Hesap Kodu 6",
+        "account_code_id": "Hesap Kodu ID",
+        "account_code_uu_id": "Hesap Kodu UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "account_code_1": "Account Code 1",
+        "account_code_2": "Account Code 2",
+        "account_code_3": "Account Code 3",
+        "account_code_4": "Account Code 4",
+        "account_code_5": "Account Code 5",
+        "account_code_6": "Account Code 6",
+        "account_code_id": "Account Code ID",
+        "account_code_uu_id": "Account Code UU ID",
+    },
+)
+
+AccountMasterLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "doc_date": "Belge Tarihi",
+        "plug_type": "Fiş Türü",
+        "plug_number": "Fiş Numarası",
+        "special_code": "Özel Kod",
+        "authorization_code": "Yetki Kodu",
+        "doc_code": "Belge Kodu",
+        "doc_type": "Belge Türü",
+        "comment_line1": "Yorum Satırı 1",
+        "comment_line2": "Yorum Satırı 2",
+        "comment_line3": "Yorum Satırı 3",
+        "comment_line4": "Yorum Satırı 4",
+        "comment_line5": "Yorum Satırı 5",
+        "comment_line6": "Yorum Satırı 6",
+        "project_code": "Proje Kodu",
+        "module_no": "Modül No",
+        "journal_no": "Defter No",
+        "status_id": "Durum ID",
+        "canceled": "İptal Edildi",
+        "print_count": "Yazdırma Sayısı",
+        "total_active": "Toplam Aktif",
+        "total_passive": "Toplam Pasif",
+        "total_active_1": "Toplam Aktif 1",
+        "total_passive_1": "Toplam Pasif 1",
+        "total_active_2": "Toplam Aktif 2",
+        "total_passive_2": "Toplam Pasif 2",
+        "total_active_3": "Toplam Aktif 3",
+        "total_passive_3": "Toplam Pasif 3",
+        "total_active_4": "Toplam Aktif 4",
+        "total_passive_4": "Toplam Pasif 4",
+        "cross_ref": "Çapraz Referans",
+        "data_center_id": "Veri Merkezi ID",
+        "data_center_rec_num": "Veri Merkezi Kayıt Numarası",
+        "account_header_id": "Hesap Başlığı ID",
+        "account_header_uu_id": "Hesap Başlığı UU ID",
+        "project_item_id": "Proje Öğesi ID",
+        "project_item_uu_id": "Proje Öğesi UU ID",
+        "department_id": "Departman ID",
+        "department_uu_id": "Departman UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "doc_date": "Document Date",
+        "plug_type": "Plug Type",
+        "plug_number": "Plug Number",
+        "special_code": "Special Code",
+        "authorization_code": "Authorization Code",
+        "doc_code": "Document Code",
+        "doc_type": "Document Type",
+        "comment_line1": "Comment Line 1",
+        "comment_line2": "Comment Line 2",
+        "comment_line3": "Comment Line 3",
+        "comment_line4": "Comment Line 4",
+        "comment_line5": "Comment Line 5",
+        "comment_line6": "Comment Line 6",
+        "project_code": "Project Code",
+        "module_no": "Module No",
+        "journal_no": "Journal No",
+        "status_id": "Status ID",
+        "canceled": "Canceled",
+        "print_count": "Print Count",
+        "total_active": "Total Active",
+        "total_passive": "Total Passive",
+        "total_active_1": "Total Active 1",
+        "total_passive_1": "Total Passive 1",
+        "total_active_2": "Total Active 2",
+        "total_passive_2": "Total Passive 2",
+        "total_active_3": "Total Active 3",
+        "total_passive_3": "Total Passive 3",
+        "total_active_4": "Total Active 4",
+        "total_passive_4": "Total Passive 4",
+        "cross_ref": "Cross Reference",
+        "data_center_id": "Data Center ID",
+        "data_center_rec_num": "Data Center Record Number",
+        "account_header_id": "Account Header ID",
+        "account_header_uu_id": "Account Header UU ID",
+        "project_item_id": "Project Item ID",
+        "project_item_uu_id": "Project Item UU ID",
+        "department_id": "Department ID",
+        "department_uu_id": "Department UU ID",
+    },
+)
+
+AccountDetailLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "doc_date": "Belge Tarihi",
+        "plug_type": "Fiş Türü",
+        "plug_number": "Fiş Numarası",
+        "special_code": "Özel Kod",
+        "authorization_code": "Yetki Kodu",
+        "doc_code": "Belge Kodu",
+        "doc_type": "Belge Türü",
+        "comment_line1": "Yorum Satırı 1",
+        "comment_line2": "Yorum Satırı 2",
+        "comment_line3": "Yorum Satırı 3",
+        "comment_line4": "Yorum Satırı 4",
+        "comment_line5": "Yorum Satırı 5",
+        "comment_line6": "Yorum Satırı 6",
+        "project_code": "Proje Kodu",
+        "module_no": "Modül No",
+        "journal_no": "Defter No",
+        "status_id": "Durum ID",
+        "canceled": "İptal Edildi",
+        "print_count": "Yazdırma Sayısı",
+        "total_active": "Toplam Aktif",
+        "total_passive": "Toplam Pasif",
+        "total_active_1": "Toplam Aktif 1",
+        "total_passive_1": "Toplam Pasif 1",
+        "total_active_2": "Toplam Aktif 2",
+        "total_passive_2": "Toplam Pasif 2",
+        "total_active_3": "Toplam Aktif 3",
+        "total_passive_3": "Toplam Pasif 3",
+        "total_active_4": "Toplam Aktif 4",
+        "total_passive_4": "Toplam Pasif 4",
+        "cross_ref": "Çapraz Referans",
+        "data_center_id": "Veri Merkezi ID",
+        "data_center_rec_num": "Veri Merkezi Kayıt Numarası",
+        "account_header_id": "Hesap Başlığı ID",
+        "account_header_uu_id": "Hesap Başlığı UU ID",
+        "project_item_id": "Proje Öğesi ID",
+        "project_item_uu_id": "Proje Öğesi UU ID",
+        "department_id": "Departman ID",
+        "department_uu_id": "Departman UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "doc_date": "Document Date",
+        "plug_type": "Plug Type",
+        "plug_number": "Plug Number",
+        "special_code": "Special Code",
+        "authorization_code": "Authorization Code",
+        "doc_code": "Document Code",
+        "doc_type": "Document Type",
+        "comment_line1": "Comment Line 1",
+        "comment_line2": "Comment Line 2",
+        "comment_line3": "Comment Line 3",
+        "comment_line4": "Comment Line 4",
+        "comment_line5": "Comment Line 5",
+        "comment_line6": "Comment Line 6",
+        "project_code": "Project Code",
+        "module_no": "Module No",
+        "journal_no": "Journal No",
+        "status_id": "Status ID",
+        "canceled": "Canceled",
+        "print_count": "Print Count",
+        "total_active": "Total Active",
+        "total_passive": "Total Passive",
+        "total_active_1": "Total Active 1",
+        "total_passive_1": "Total Passive 1",
+        "total_active_2": "Total Active 2",
+        "total_passive_2": "Total Passive 2",
+        "total_active_3": "Total Active 3",
+        "total_passive_3": "Total Passive 3",
+        "total_active_4": "Total Active 4",
+        "total_passive_4": "Total Passive 4",
+        "cross_ref": "Cross Reference",
+        "data_center_id": "Data Center ID",
+        "data_center_rec_num": "Data Center Record Number",
+        "account_header_id": "Account Header ID",
+        "account_header_uu_id": "Account Header UU ID",
+        "project_item_id": "Project Item ID",
+        "project_item_uu_id": "Project Item UU ID",
+        "department_id": "Department ID",
+        "department_uu_id": "Department UU ID",
+    },
+)
+
+AccountRecordsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "iban": "IBAN",
+        "bank_date": "Banka Tarihi",
+        "currency_value": "Döviz Değeri",
+        "bank_balance": "Banka Bakiyesi",
+        "currency": "Döviz",
+        "additional_balance": "Ek Bakiye",
+        "channel_branch": "Kanal Şubesi",
+        "process_name": "İşlem Türü Adı",
+        "process_type": "İşlem Türü",
+        "process_comment": "İşlem Kayıt Yorumu",
+        "process_garbage": "İşlem Kayıt Çöpü",
+        "bank_reference_code": "Banka Referans Kodu",
+        "add_comment_note": "Yorum Not Ekle",
+        "is_receipt_mail_send": "Alındı Mail Gönderildi",
+        "found_from": "Bulunduğu",
+        "similarity": "Benzerlik",
+        "remainder_balance": "Kalan Bakiye",
+        "bank_date_y": "Banka Tarihi Yıl",
+        "bank_date_m": "Banka Tarihi Ay",
+        "bank_date_w": "Banka Tarihi Hafta",
+        "bank_date_d": "Banka Tarihi Gün",
+        "approving_accounting_record": "Onaylayan Muhasebe Kaydı",
+        "accounting_receipt_date": "Muhasebe Alındı Tarihi",
+        "accounting_receipt_number": "Muhasebe Alındı Numarası",
+        "status_id": "Durum ID",
+        "approved_record": "Onaylanmış Kayıt",
+        "import_file_name": "İçe Aktarım Dosya Adı",
+        "receive_debit": "Alacak Borç",
+        "receive_debit_uu_id": "Alacak Borç UU ID",
+        "budget_type": "Bütçe Türü",
+        "budget_type_uu_id": "Bütçe Türü UU ID",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UU ID",
+        "send_company_id": "Gönderen Şirket ID",
+        "send_company_uu_id": "Gönderen Şirket UU ID",
+        "send_person_id": "Gönderen Kişi ID",
+        "send_person_uu_id": "Gönderen Kişi UU ID",
+        "approving_accounting_person": "Onaylayan Muhasebe Kişi",
+        "approving_accounting_person_uu_id": "Onaylayan Muhasebe Kişi UU ID",
+        "living_space_id": "Yaşam Alanı ID",
+        "living_space_uu_id": "Yaşam Alanı UU ID",
+        "customer_id": "Müşteri ID",
+        "customer_uu_id": "Müşteri UU ID",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UU ID",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UU ID",
+        "build_decision_book_id": "Bina Karar Defteri ID",
+        "build_decision_book_uu_id": "Bina Karar Defteri UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "iban": "IBAN",
+        "bank_date": "Bank Date",
+        "currency_value": "Currency Value",
+        "bank_balance": "Bank Balance",
+        "currency": "Currency",
+        "additional_balance": "Additional Balance",
+        "channel_branch": "Channel Branch",
+        "process_name": "Process Type Name",
+        "process_type": "Process Type",
+        "process_comment": "Process Record Comment",
+        "process_garbage": "Process Record Garbage",
+        "bank_reference_code": "Bank Reference Code",
+        "add_comment_note": "Add Comment Note",
+        "is_receipt_mail_send": "Is Receipt Mail Send",
+        "found_from": "Found From",
+        "similarity": "Similarity",
+        "remainder_balance": "Remainder Balance",
+        "bank_date_y": "Bank Date Year",
+        "bank_date_m": "Bank Date Month",
+        "bank_date_w": "Bank Date Week",
+        "bank_date_d": "Bank Date Day",
+        "approving_accounting_record": "Approving Accounting Record",
+        "accounting_receipt_date": "Accounting Receipt Date",
+        "accounting_receipt_number": "Accounting Receipt Number",
+        "status_id": "Status ID",
+        "approved_record": "Approved Record",
+        "import_file_name": "Import File Name",
+        "receive_debit": "Receive Debit",
+        "receive_debit_uu_id": "Receive Debit UU ID",
+        "budget_type": "Budget Type",
+        "budget_type_uu_id": "Budget Type UU ID",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UU ID",
+        "send_company_id": "Send Company ID",
+        "send_company_uu_id": "Send Company UU ID",
+        "send_person_id": "Send Person ID",
+        "send_person_uu_id": "Send Person UU ID",
+        "approving_accounting_person": "Approving Accounting Person",
+        "approving_accounting_person_uu_id": "Approving Accounting Person UU ID",
+        "living_space_id": "Living Space ID",
+        "living_space_uu_id": "Living Space UU ID",
+        "customer_id": "Customer ID",
+        "customer_uu_id": "Customer UU ID",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UU ID",
+        "build_parts_id": "Build Parts ID",
+        "build_parts_uu_id": "Build Parts UU ID",
+        "build_decision_book_id": "Build Decision Book ID",
+        "build_decision_book_uu_id": "Build Decision Book UU ID",
+    },
+)
+
+AccountRecordExchangesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "are_currency": "Para Birimi",
+        "are_exchange_rate": "Döviz Kuru",
+        "usd_exchange_rate_value": "USD Döviz Kuru Değeri",
+        "eur_exchange_rate_value": "EUR Döviz Kuru Değeri",
+        "gbp_exchange_rate_value": "GBP Döviz Kuru Değeri",
+        "cny_exchange_rate_value": "CNY Döviz Kuru Değeri",
+        "account_records_id": "Hesap Kayıt ID",
+        "account_records_uu_id": "Hesap Kayıt UU ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "are_currency": "Currency",
+        "are_exchange_rate": "Exchange Rate",
+        "usd_exchange_rate_value": "USD Exchange Rate Value",
+        "eur_exchange_rate_value": "EUR Exchange Rate Value",
+        "gbp_exchange_rate_value": "GBP Exchange Rate Value",
+        "cny_exchange_rate_value": "CNY Exchange Rate Value",
+        "account_records_id": "Account Record ID",
+        "account_records_uu_id": "Account Record UU ID",
+    },
+)

ApiLayers/LanguageModels/Database/account/iban.py

@@ -0,0 +1,52 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+BuildIbansLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "iban": "IBAN Numarası",
+        "start_date": "Banka İşlem Başlangıç Tarihi",
+        "stop_date": "Banka İşlem Bitiş Tarihi",
+        "bank_code": "Banka Kodu",
+        "xcomment": "Yorum",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "iban": "IBAN Number",
+        "start_date": "Bank Transaction Start Date",
+        "stop_date": "Bank Transaction End Date",
+        "bank_code": "Bank Code",
+        "xcomment": "Comment",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+    },
+)
+
+
+BuildIbanDescriptionLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "iban": "IBAN Numarası",
+        "group_id": "Grup ID",
+        "search_word": "Arama Kelimesi",
+        "customer_id": "Müşteri ID",
+        "customer_uu_id": "Müşteri UUID",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "iban": "IBAN Number",
+        "group_id": "Group ID",
+        "search_word": "Search Word",
+        "customer_id": "Customer ID",
+        "customer_uu_id": "Customer UUID",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+        "build_parts_id": "Build Parts ID",
+        "build_parts_uu_id": "Build Parts UUID",
+    },
+)

ApiLayers/LanguageModels/Database/building/budget.py

@@ -0,0 +1,101 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+DecisionBookBudgetBooksLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "country": "Ülke",
+        "branch_type": "Şube Tipi",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+        "branch_id": "Şube ID",
+        "branch_uu_id": "Şube UUID",
+        "build_decision_book_id": "Karar Defteri ID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "country": "Country",
+        "branch_type": "Branch Type",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+        "branch_id": "Branch ID",
+        "branch_uu_id": "Branch UUID",
+        "build_decision_book_id": "Build Decision Book ID",
+        "build_decision_book_uu_id": "Build Decision Book UUID",
+    },
+)
+
+DecisionBookBudgetCodesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "budget_code": "Bütçe Kodu",
+        "comment_line": "Yorum Satırı",
+        "build_decision_book_id": "Karar Defteri ID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UUID",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "budget_code": "Budget Code",
+        "comment_line": "Comment Line",
+        "build_decision_book_id": "Build Decision Book ID",
+        "build_decision_book_uu_id": "Build Decision Book UUID",
+        "build_parts_id": "Build Parts ID",
+        "build_parts_uu_id": "Build Parts UUID",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+    },
+)
+
+DecisionBookBudgetMasterLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "budget_type": "Bütçe Tipi",
+        "currency": "Para Birimi",
+        "total_budget": "Toplam Bütçe",
+        "tracking_period_id": "Takip Dönemi ID",
+        "tracking_period_uu_id": "Takip Dönemi UUID",
+        "budget_books_id": "Bütçe Kitapları ID",
+        "budget_books_uu_id": "Bütçe Kitapları UUID",
+        "department_id": "Departman ID",
+        "department_uu_id": "Departman UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "budget_type": "Budget Type",
+        "currency": "Currency",
+        "total_budget": "Total Budget",
+        "tracking_period_id": "Tracking Period ID",
+        "tracking_period_uu_id": "Tracking Period UUID",
+        "budget_books_id": "Budget Books ID",
+        "budget_books_uu_id": "Budget Books UUID",
+        "department_id": "Department ID",
+        "department_uu_id": "Department UUID",
+    },
+)
+
+DecisionBookBudgetsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "process_date": "İşlem Tarihi",
+        "budget_codes_id": "Bütçe Kodları ID",
+        "total_budget": "Toplam Bütçe",
+        "used_budget": "Kullanılan Bütçe",
+        "remaining_budget": "Kalan Bütçe",
+        "decision_book_budget_master_id": "Karar Defteri Bütçesi ID",
+        "decision_book_budget_master_uu_id": "Karar Defteri Bütçesi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "process_date": "Process Date",
+        "budget_codes_id": "Budget Codes ID",
+        "total_budget": "Total Budget",
+        "used_budget": "Used Budget",
+        "remaining_budget": "Remaining Budget",
+        "decision_book_budget_master_id": "Decision Book Budget Master ID",
+        "decision_book_budget_master_uu_id": "Decision Book Budget Master UUID",
+    },
+)

ApiLayers/LanguageModels/Database/building/build.py

@@ -0,0 +1,301 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+BuildTypesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "function_code": "Fonksiyon Kodu",
+        "type_code": "Yapı Tipi Kodu",
+        "lang": "Dil",
+        "type_name": "Tip Adı",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "function_code": "Function Code",
+        "type_code": "Type Code",
+        "lang": "Language",
+        "type_name": "Type Name",
+    },
+)
+
+Part2EmployeeLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_id": "Bina ID",
+        "part_id": "Bina Parça ID",
+        "employee_id": "Çalışan ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_id": "Build ID",
+        "part_id": "Build Part ID",
+        "employee_id": "Employee ID",
+    },
+)
+
+RelationshipEmployee2BuildLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "company_id": "Şirket ID",
+        "employee_id": "Çalışan ID",
+        "member_id": "Üye ID",
+        "relationship_type": "İlişki Tipi",
+        "show_only": "Sadece Göster",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "company_id": "Company ID",
+        "employee_id": "Employee ID",
+        "member_id": "Member ID",
+        "relationship_type": "Relationship Type",
+        "show_only": "Show Only",
+    },
+)
+
+BuildLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "gov_address_code": "Adres Kodu",
+        "build_name": "Bina Adı",
+        "build_no": "Bina No",
+        "max_floor": "Max Kat",
+        "underground_floor": "Zemin Kat",
+        "build_date": "Bina Tarihi",
+        "decision_period_date": "Karar Dönemi Tarihi",
+        "tax_no": "Vergi No",
+        "lift_count": "Asansör Sayısı",
+        "heating_system": "Isıtma Sistemi",
+        "cooling_system": "Soğutma Sistemi",
+        "hot_water_system": "Sıcak Su Sistemi",
+        "block_service_man_count": "Blok Hizmet Görevlisi Sayısı",
+        "security_service_man_count": "Güvenlik Görevlisi Sayısı",
+        "garage_count": "Garaj Sayısı",
+        "management_room_id": "Yönetim Odası ID",
+        "site_id": "Site ID",
+        "site_uu_id": "Site UUID",
+        "address_id": "Adres ID",
+        "address_uu_id": "Adres UUID",
+        "build_types_id": "Bina Tipi ID",
+        "build_types_uu_id": "Bina Tipi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "gov_address_code": "Address Code",
+        "build_name": "Building Name",
+        "build_no": "Building Number",
+        "max_floor": "Max Floor",
+        "underground_floor": "Underground Floor",
+        "build_date": "Building Date",
+        "decision_period_date": "Decision Period Date",
+        "tax_no": "Tax No",
+        "lift_count": "Lift Count",
+        "heating_system": "Heating System",
+        "cooling_system": "Cooling System",
+        "hot_water_system": "Hot Water System",
+        "block_service_man_count": "Block Service Man Count",
+        "security_service_man_count": "Security Service Man Count",
+        "garage_count": "Garage Count",
+        "management_room_id": "Management Room ID",
+        "site_id": "Site ID",
+        "site_uu_id": "Site UUID",
+        "address_id": "Address ID",
+        "address_uu_id": "Address UUID",
+        "build_types_id": "Build Types ID",
+        "build_types_uu_id": "Build Types UUID",
+    },
+)
+
+BuildPartsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "address_gov_code": "Adres Kodu",
+        "part_no": "Bina Parça No",
+        "part_level": "Bina Parça Katı",
+        "part_code": "Bina Parça Kodu",
+        "part_gross_size": "Bina Parça Brüt Alanı",
+        "part_net_size": "Bina Parça Net Alanı",
+        "default_accessory": "Varsayılan Aksesuar",
+        "human_livable": "İnsan Yaşam Alanı",
+        "due_part_key": "Ödeme Grubu",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "part_direction_id": "Bina Parça Yönü ID",
+        "part_direction_uu_id": "Bina Parça Yönü UUID",
+        "part_type_id": "Bina Parça Tipi ID",
+        "part_type_uu_id": "Bina Parça Tipi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "address_gov_code": "Address Code",
+        "part_no": "Part Number",
+        "part_level": "Part Level",
+        "part_code": "Part Code",
+        "part_gross_size": "Part Gross Size",
+        "part_net_size": "Part Net Size",
+        "default_accessory": "Default Accessory",
+        "human_livable": "Human Livable",
+        "due_part_key": "Due Part Key",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "part_direction_id": "Part Direction ID",
+        "part_direction_uu_id": "Part Direction UUID",
+        "part_type_id": "Part Type ID",
+        "part_type_uu_id": "Part Type UUID",
+    },
+)
+
+
+BuildLivingSpaceLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "fix_value": "Düz Değer",
+        "fix_percent": "Düz Yüzde",
+        "agreement_no": "Anlaşma No",
+        "marketing_process": "Pazarlama İşlemi",
+        "marketing_layer": "Pazarlama Katmanı",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UUID",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UUID",
+        "occupant_type": "Sakin Tipi",
+        "occupant_type_uu_id": "Sakin Tipi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "fix_value": "Fixed Value",
+        "fix_percent": "Fixed Percent",
+        "agreement_no": "Agreement No",
+        "marketing_process": "Marketing Process",
+        "marketing_layer": "Marketing Layer",
+        "build_parts_id": "Build Part ID",
+        "build_parts_uu_id": "Build Part UUID",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UUID",
+        "occupant_type": "Occupant Type",
+        "occupant_type_uu_id": "Occupant Type UUID",
+    },
+)
+
+BuildManagementLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "discounted_percentage": "İndirim Yüzdesi",
+        "discounted_price": "İndirimli Fiyat",
+        "calculated_price": "Hesaplanan Fiyat",
+        "occupant_type": "Sakin Tipi",
+        "occupant_type_uu_id": "Sakin Tipi UUID",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "discounted_percentage": "Discounted Percentage",
+        "discounted_price": "Discounted Price",
+        "calculated_price": "Calculated Price",
+        "occupant_type": "Occupant Type",
+        "occupant_type_uu_id": "Occupant Type UUID",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "build_parts_id": "Build Part ID",
+        "build_parts_uu_id": "Build Part UUID",
+    },
+)
+
+BuildAreaLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "area_name": "Alan Adı",
+        "area_code": "Alan Kodu",
+        "area_type": "Alan Tipi",
+        "area_direction": "Alan Yönü",
+        "area_gross_size": "Alan Brüt Alanı",
+        "area_net_size": "Alan Net Alanı",
+        "width": "En",
+        "size": "Boyut",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "part_type_id": "Bina Parça Tipi ID",
+        "part_type_uu_id": "Bina Parça Tipi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "area_name": "Area Name",
+        "area_code": "Area Code",
+        "area_type": "Area Type",
+        "area_direction": "Area Direction",
+        "area_gross_size": "Area Gross Size",
+        "area_net_size": "Area Net Size",
+        "width": "Width",
+        "size": "Size",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "part_type_id": "Part Type ID",
+        "part_type_uu_id": "Part Type UUID",
+    },
+)
+
+
+BuildSitesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "site_name": "Site Adı",
+        "site_no": "Site No",
+        "address_id": "Adres ID",
+        "address_uu_id": "Adres UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "site_name": "Site Name",
+        "site_no": "Site No",
+        "address_id": "Address ID",
+        "address_uu_id": "Address UUID",
+    },
+)
+
+BuildCompaniesProvidingLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+        "provide_id": "Sağlayıcı ID",
+        "provide_uu_id": "Sağlayıcı UUID",
+        "contract_id": "Sözleşme ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+        "provide_id": "Provide ID",
+        "provide_uu_id": "Provide UUID",
+        "contract_id": "Contract ID",
+    },
+)
+
+
+BuildPersonProvidingLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "people_id": "Kişi ID",
+        "people_uu_id": "Kişi UUID",
+        "provide_id": "Sağlayıcı ID",
+        "provide_uu_id": "Sağlayıcı UUID",
+        "contract_id": "Sözleşme ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "people_id": "People ID",
+        "people_uu_id": "People UUID",
+        "provide_id": "Provide ID",
+        "provide_uu_id": "Provide UUID",
+        "contract_id": "Contract ID",
+    },
+)

ApiLayers/LanguageModels/Database/building/decision_book.py

@@ -0,0 +1,398 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+BuildDecisionBookLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "decision_book_pdf_path": "Karar Defteri PDF Yolu",
+        "resp_company_fix_wage": "Firma Sabit Ücreti",
+        "is_out_sourced": "Dış Kaynak Kullanımı",
+        "meeting_date": "Toplantı Tarihi",
+        "decision_type": "Karar Türü",
+        "meeting_is_completed": "Toplantı Tamamlandı",
+        "meeting_completed_date": "Toplantı Tamamlanma Tarihi",
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "resp_company_id": "Sorumlu Firma ID",
+        "resp_company_uu_id": "Sorumlu Firma UUID",
+        "contact_id": "İletişim ID",
+        "contact_uu_id": "İletişim UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "decision_book_pdf_path": "Decision Book PDF Path",
+        "resp_company_fix_wage": "Resp Company Fix Wage",
+        "is_out_sourced": "Is Out Sourced",
+        "meeting_date": "Meeting Date",
+        "decision_type": "Decision Type",
+        "meeting_is_completed": "Meeting Is Completed",
+        "meeting_completed_date": "Meeting Completed Date",
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "resp_company_id": "Resp Company ID",
+        "resp_company_uu_id": "Resp Company UUID",
+        "contact_id": "Contact ID",
+        "contact_uu_id": "Contact UUID",
+    },
+)
+
+BuildDecisionBookInvitationsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_id": "Bina ID",
+        "build_uu_id": "Bina UUID",
+        "decision_book_id": "Karar Defteri ID",
+        "decision_book_uu_id": "Karar Defteri UUID",
+        "invitation_type": "Davet Türü",
+        "invitation_attempt": "Davet Denemesi",
+        "living_part_count": "Yaşam Bölüm Sayısı",
+        "living_part_percentage": "Yaşam Bölüm Yüzdesi",
+        "message": "Davet Mesajı",
+        "planned_date": "Planlanan Tarih",
+        "planned_date_expires": "Planlanan Tarih Bitiş",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_id": "Build ID",
+        "build_uu_id": "Build UUID",
+        "decision_book_id": "Decision Book ID",
+        "decision_book_uu_id": "Decision Book UUID",
+        "invitation_type": "Invitation Type",
+        "invitation_attempt": "Invitation Attempt",
+        "living_part_count": "Living Part Count",
+        "living_part_percentage": "Living Part Percentage",
+        "message": "Message",
+        "planned_date": "Planned Date",
+        "planned_date_expires": "Planned Date Expires",
+    },
+)
+
+BuildDecisionBookPersonLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "dues_percent_discount": "Aidat İndirim Oranı",
+        "dues_fix_discount": "Aidat Sabit İndirim",
+        "dues_discount_approval_date": "İndirim Onay Tarihi",
+        "send_date": "Gönderme Tarihi",
+        "is_attending": "Katılıyor",
+        "confirmed_date": "Onay Tarihi",
+        "token": "Token",
+        "vicarious_person_id": "Vekil Kişi ID",
+        "vicarious_person_uu_id": "Vekil Kişi UUID",
+        "invite_id": "Davet ID",
+        "invite_uu_id": "Davet UUID",
+        "build_decision_book_id": "Karar Defteri ID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+        "build_living_space_id": "Yaşam Alanı ID",
+        "build_living_space_uu_id": "Yaşam Alanı UUID",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "dues_percent_discount": "Dues Percent Discount",
+        "dues_fix_discount": "Dues Fix Discount",
+        "dues_discount_approval_date": "Dues Discount Approval Date",
+        "send_date": "Send Date",
+        "is_attending": "Is Attending",
+        "confirmed_date": "Confirmed Date",
+        "token": "Token",
+        "vicarious_person_id": "Vicarious Person ID",
+        "vicarious_person_uu_id": "Vicarious Person UUID",
+        "invite_id": "Invite ID",
+        "invite_uu_id": "Invite UUID",
+        "build_decision_book_id": "Decision Book ID",
+        "build_decision_book_uu_id": "Decision Book UUID",
+        "build_living_space_id": "Living Space ID",
+        "build_living_space_uu_id": "Living Space UUID",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UUID",
+    },
+)
+
+BuildDecisionBookPersonOccupantsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_decision_book_person_id": "Karar Defteri Kişi ID",
+        "build_decision_book_person_uu_id": "Karar Defter Kişi UUID",
+        "invite_id": "Davet ID",
+        "invite_uu_id": "Davet UUID",
+        "occupant_type_id": "Kişi Tür ID",
+        "occupant_type_uu_id": "Kişi Tür UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_decision_book_person_id": "Build Decision Book Person ID",
+        "build_decision_book_person_uu_id": "Build Decision Book Person UUID",
+        "invite_id": "Invite ID",
+        "invite_uu_id": "Invite UUID",
+        "occupant_type_id": "Occupant Type ID",
+        "occupant_type_uu_id": "Occupant Type UUID",
+    },
+)
+
+BuildDecisionBookItemsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "item_order": "Madde Sırası",
+        "item_comment": "Madde Yorumu",
+        "item_objection": "Madde İtirazı",
+        "info_is_completed": "Bilgi Tamamlandı",
+        "is_payment_created": "Ödeme Yapıldı",
+        "info_type_id": "Bilgi Türü ID",
+        "info_type_uu_id": "Bilgi Türü UUID",
+        "build_decision_book_id": "Karar Defteri ID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+        "item_short_comment": "Kısa Yorum",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "item_order": "Item Order",
+        "item_comment": "Item Comment",
+        "item_objection": "Item Objection",
+        "info_is_completed": "Info Is Completed",
+        "is_payment_created": "Is Payment Created",
+        "info_type_id": "Info Type ID",
+        "info_type_uu_id": "Info Type UUID",
+        "build_decision_book_id": "Build Decision Book ID",
+        "build_decision_book_uu_id": "Build Decision Book UUID",
+        "item_short_comment": "Item Short Comment",
+    },
+)
+
+BuildDecisionBookItemsUnapprovedLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "item_objection": "Madde İtirazı",
+        "item_order": "Madde Sırası",
+        "decision_book_item_id": "Karar Defteri Madde ID",
+        "decision_book_item_uu_id": "Karar Defteri Madde UUID",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UUID",
+        "build_decision_book_item": "Karar Defteri Madde ID",
+        "build_decision_book_item_uu_id": "Karar Defteri Madde UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "item_objection": "Item Objection",
+        "item_order": "Item Order",
+        "decision_book_item_id": "Decision Book Item ID",
+        "decision_book_item_uu_id": "Decision Book Item UUID",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UUID",
+        "build_decision_book_item": "Build Decision Book Item ID",
+        "build_decision_book_item_uu_id": "Build Decision Book Item UUID",
+    },
+)
+
+BuildDecisionBookPaymentsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "payment_plan_time_periods": "Ödeme Planı Zaman Periyodu",
+        "process_date": "Ödeme Tarihi",
+        "payment_amount": "Ödeme Miktarı",
+        "currency": "Para Birimi",
+        "payment_types_id": "Ödeme Türü ID",
+        "payment_types_uu_id": "Ödeme Türü UUID",
+        "period_time": "Dönem Zamanı",
+        "process_date_y": "Tarih Yılı",
+        "process_date_m": "Tarih Ayı",
+        "build_decision_book_item_id": "Karar Defteri Madde ID",
+        "build_decision_book_item_uu_id": "Karar Defteri Madde UUID",
+        "build_parts_id": "Bina Parça ID",
+        "build_parts_uu_id": "Bina Parça UUID",
+        "decision_book_project_id": "Karar Defteri Proje ID",
+        "decision_book_project_uu_id": "Karar Defteri Proje UUID",
+        "account_records_id": "Hesap Kayıtları ID",
+        "account_records_uu_id": "Hesap Kayıtları UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "payment_plan_time_periods": "Payment Plan Time Periods",
+        "process_date": "Process Date",
+        "payment_amount": "Payment Amount",
+        "currency": "Currency",
+        "payment_types_id": "Payment Types ID",
+        "payment_types_uu_id": "Payment Types UUID",
+        "period_time": "Period Time",
+        "process_date_y": "Process Date Year",
+        "process_date_m": "Process Date Month",
+        "build_decision_book_item_id": "Build Decision Book Item ID",
+        "build_decision_book_item_uu_id": "Build Decision Book Item UUID",
+        "build_parts_id": "Build Parts ID",
+        "build_parts_uu_id": "Build Parts UUID",
+        "decision_book_project_id": "Decision Book Project ID",
+        "decision_book_project_uu_id": "Decision Book Project UUID",
+        "account_records_id": "Account Records ID",
+        "account_records_uu_id": "Account Records UUID",
+    },
+)
+
+BuildDecisionBookLegalLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "period_start_date": "Dönem Başlangıç Tarihi",
+        "lawsuits_decision_number": "Dava Karar Numarası",
+        "lawsuits_decision_date": "Dava Karar Tarihi",
+        "period_stop_date": "Dönem Bitiş Tarihi",
+        "decision_book_pdf_path": "Karar Defteri PDF Yolu",
+        "resp_company_total_wage": "Firma Toplam Ücreti",
+        "contact_agreement_path": "İletişim Anlaşma Yolu",
+        "contact_agreement_date": "İletişim Anlaşma Tarihi",
+        "meeting_date": "Toplantı Tarihi",
+        "lawsuits_type": "Dava Türü",
+        "lawsuits_name": "Dava Adı",
+        "lawsuits_note": "Dava Notu",
+        "lawyer_cost": "Avukat Ücreti",
+        "mediator_lawyer_cost": "Arabulucu Avukat Ücreti",
+        "other_cost": "Diğer Ücret",
+        "legal_cost": "Yasal Ücret",
+        "approved_cost": "Onaylanan Ücret",
+        "total_price": "Toplam Ücret",
+        "build_db_item_id": "Karar Defteri Madde ID",
+        "build_db_item_uu_id": "Karar Defteri Madde UUID",
+        "resp_attorney_id": "Sorumlu Avukat ID",
+        "resp_attorney_uu_id": "Sorumlu Avukat UUID",
+        "resp_attorney_company_id": "Sorumlu Avukat Firma ID",
+        "resp_attorney_company_uu_id": "Sorumlu Avukat Firma UUID",
+        "mediator_lawyer_person_id": "Arabulucu Avukat Kişi ID",
+        "mediator_lawyer_person_uu_id": "Arabulucu Avukat Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "period_start_date": "Period Start Date",
+        "lawsuits_decision_number": "Lawsuits Decision Number",
+        "lawsuits_decision_date": "Lawsuits Decision Date",
+        "period_stop_date": "Period Stop Date",
+        "decision_book_pdf_path": "Decision Book PDF Path",
+        "resp_company_total_wage": "Resp Company Total Wage",
+        "contact_agreement_path": "Contact Agreement Path",
+        "contact_agreement_date": "Contact Agreement Date",
+        "meeting_date": "Meeting Date",
+        "lawsuits_type": "Lawsuits Type",
+        "lawsuits_name": "Lawsuits Name",
+        "lawsuits_note": "Lawsuits Note",
+        "lawyer_cost": "Lawyer Cost",
+        "mediator_lawyer_cost": "Mediator Lawyer Cost",
+        "other_cost": "Other Cost",
+        "legal_cost": "Legal Cost",
+        "approved_cost": "Approved Cost",
+        "total_price": "Total Price",
+        "build_db_item_id": "Build Decision Book Item ID",
+        "build_db_item_uu_id": "Build Decision Book Item UUID",
+        "resp_attorney_id": "Resp Attorney ID",
+        "resp_attorney_uu_id": "Resp Attorney UUID",
+        "resp_attorney_company_id": "Resp Attorney Company ID",
+        "resp_attorney_company_uu_id": "Resp Attorney Company UUID",
+        "mediator_lawyer_person_id": "Mediator Lawyer Person ID",
+        "mediator_lawyer_person_uu_id": "Mediator Lawyer Person UUID",
+    },
+)
+
+BuildDecisionBookProjectsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "project_no": "Proje No",
+        "project_name": "Proje Adı",
+        "project_start_date": "Proje Başlangıç Tarihi",
+        "project_stop_date": "Proje Bitiş Tarihi",
+        "project_type": "Proje Türü",
+        "project_note": "Proje Notu",
+        "decision_book_pdf_path": "Karar Defteri PDF Yolu",
+        "is_completed": "Proje Tamamlandı",
+        "status_code": "Durum Kodu",
+        "resp_company_fix_wage": "Firma Sabit Ücreti",
+        "is_out_sourced": "Dış Kaynak Kullanımı",
+        "meeting_date": "Toplantı Tarihi",
+        "currency": "Para Birimi",
+        "bid_price": "Teklif Fiyatı",
+        "approved_price": "Onaylanan Fiyat",
+        "final_price": "Son Fiyat",
+        "contact_id": "İletişim ID",
+        "contact_uu_id": "İletişim UUID",
+        "build_decision_book_id": "Karar Defteri ID",
+        "build_decision_book_uu_id": "Karar Defteri UUID",
+        "build_decision_book_item_id": "Karar Defteri Madde ID",
+        "build_decision_book_item_uu_id": "Karar Defteri Madde UUID",
+        "project_response_living_space_id": "Proje Yanıt Yaşam Alanı ID",
+        "project_response_living_space_uu_id": "Proje Yanıt Yaşam Alanı UUID",
+        "resp_company_id": "Sorumlu Firma ID",
+        "resp_company_uu_id": "Sorumlu Firma UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "project_no": "Project No",
+        "project_name": "Project Name",
+        "project_start_date": "Project Start Date",
+        "project_stop_date": "Project Stop Date",
+        "project_type": "Project Type",
+        "project_note": "Project Note",
+        "decision_book_pdf_path": "Decision Book PDF Path",
+        "is_completed": "Is Completed",
+        "status_code": "Status Code",
+        "resp_company_fix_wage": "Resp Company Fix Wage",
+        "is_out_sourced": "Is Out Sourced",
+        "meeting_date": "Meeting Date",
+        "currency": "Currency",
+        "bid_price": "Bid Price",
+        "approved_price": "Approved Price",
+        "final_price": "Final Price",
+        "contact_id": "Contact ID",
+        "contact_uu_id": "Contact UUID",
+        "build_decision_book_id": "Build Decision Book ID",
+        "build_decision_book_uu_id": "Build Decision Book UUID",
+        "build_decision_book_item_id": "Build Decision Book Item ID",
+        "build_decision_book_item_uu_id": "Build Decision Book Item UUID",
+        "project_response_living_space_id": "Project Response Living Space ID",
+        "project_response_living_space_uu_id": "Project Response Living Space UUID",
+        "resp_company_id": "Resp Company ID",
+        "resp_company_uu_id": "Resp Company UUID",
+    },
+)
+
+BuildDecisionBookProjectPersonLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "dues_percent_discount": "Aidat İndirim Oranı",
+        "job_fix_wage": "İş Sabit Ücreti",
+        "bid_price": "Teklif Fiyatı",
+        "decision_price": "Karar Fiyatı",
+        "build_decision_book_project_id": "Karar Defteri Proje ID",
+        "build_decision_book_project_uu_id": "Karar Defteri Proje UUID",
+        "living_space_id": "Yaşam Alanı ID",
+        "living_space_uu_id": "Yaşam Alanı UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "dues_percent_discount": "Dues Percent Discount",
+        "job_fix_wage": "Job Fix Wage",
+        "bid_price": "Bid Price",
+        "decision_price": "Decision Price",
+        "build_decision_book_project_id": "Build Decision Book Project ID",
+        "build_decision_book_project_uu_id": "Build Decision Book Project UUID",
+        "living_space_id": "Living Space ID",
+        "living_space_uu_id": "Living Space UUID",
+    },
+)
+
+BuildDecisionBookProjectItemsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "item_header": "Madde Başlığı",
+        "item_comment": "Madde Yorumu",
+        "attachment_pdf_path": "Ek PDF Yolu",
+        "item_estimated_cost": "Tahmini Maliyet",
+        "item_short_comment": "Kısa Yorum",
+        "build_decision_book_project_id": "Karar Defteri Proje ID",
+        "build_decision_book_project_uu_id": "Karar Defteri Proje UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "item_header": "Item Header",
+        "item_comment": "Item Comment",
+        "attachment_pdf_path": "Attachment PDF Path",
+        "item_estimated_cost": "Estimated Cost",
+        "item_short_comment": "Item Short Comment",
+        "build_decision_book_project_id": "Build Decision Book Project ID",
+        "build_decision_book_project_uu_id": "Build Decision Book Project UUID",
+    },
+)

ApiLayers/LanguageModels/Database/company/company.py

@@ -0,0 +1,65 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+RelationshipDutyCompanyLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "owner_id": "Sahip ID",
+        "duties_id": "Görev ID",
+        "member_id": "Üye ID",
+        "parent_id": "Üst ID",
+        "relationship_type": "İlişki Tipi",
+        "child_count": "Çocuk Sayısı",
+        "show_only": "Sadece Göster",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "owner_id": "Owner ID",
+        "duties_id": "Duties ID",
+        "member_id": "Member ID",
+        "parent_id": "Parent ID",
+        "relationship_type": "Relationship Type",
+        "child_count": "Child Count",
+        "show_only": "Show Only",
+    },
+)
+
+CompaniesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "formal_name": "Resmi Ad",
+        "company_type": "Şirket Tipi",
+        "commercial_type": "Ticari Tip",
+        "tax_no": "Vergi No",
+        "public_name": "Kamu Adı",
+        "company_tag": "Şirket Etiketi",
+        "default_lang_type": "Varsayılan Dil Tipi",
+        "default_money_type": "Varsayılan Para Tipi",
+        "is_commercial": "Ticari",
+        "is_blacklist": "Kara Liste",
+        "parent_id": "Üst ID",
+        "workplace_no": "İşyeri No",
+        "official_address_id": "Resmi Adres ID",
+        "official_address_uu_id": "Resmi Adres UUID",
+        "top_responsible_company_id": "Üst Sorumlu Şirket ID",
+        "top_responsible_company_uu_id": "Üst Sorumlu Şirket UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "formal_name": "Formal Name",
+        "company_type": "Company Type",
+        "commercial_type": "Commercial Type",
+        "tax_no": "Tax No",
+        "public_name": "Public Name",
+        "company_tag": "Company Tag",
+        "default_lang_type": "Default Language Type",
+        "default_money_type": "Default Money Type",
+        "is_commercial": "Commercial",
+        "is_blacklist": "Blacklist",
+        "parent_id": "Parent ID",
+        "workplace_no": "Workplace No",
+        "official_address_id": "Official Address ID",
+        "official_address_uu_id": "Official Address UUID",
+        "top_responsible_company_id": "Top Responsible Company ID",
+        "top_responsible_company_uu_id": "Top Responsible Company UUID",
+    },
+)

ApiLayers/LanguageModels/Database/company/department.py

@@ -0,0 +1,62 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+DepartmentsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "parent_department_id": "Üst Departman ID",
+        "department_code": "Departman Kodu",
+        "department_name": "Departman Adı",
+        "department_description": "Departman Açıklaması",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "parent_department_id": "Parent Department ID",
+        "department_code": "Department Code",
+        "department_name": "Department Name",
+        "department_description": "Department Description",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+    },
+)
+
+DutiesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "users_default_duty": "Kullanıcılar için Varsayılan Görev",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+        "duties_id": "Görev ID",
+        "duties_uu_id": "Görev UUID",
+        "department_id": "Departman ID",
+        "department_uu_id": "Departman UUID",
+        "management_duty": "Yönetim Görevi",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "users_default_duty": "Default Duty for Users",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+        "duties_id": "Duty ID",
+        "duties_uu_id": "Duty UUID",
+        "department_id": "Department ID",
+        "department_uu_id": "Department UUID",
+        "management_duty": "Management Duty",
+    },
+)
+
+DutyLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "duty_name": "Görev Adı",
+        "duty_code": "Görev Kodu",
+        "duty_description": "Görev Açıklaması",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "duty_name": "Duty Name",
+        "duty_code": "Duty Code",
+        "duty_description": "Duty Description",
+    },
+)

ApiLayers/LanguageModels/Database/company/employee.py

@@ -0,0 +1,71 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+StaffLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "staff_description": "Personel Açıklaması",
+        "staff_name": "Personel Adı",
+        "staff_code": "Personel Kodu",
+        "duties_id": "Görev ID",
+        "duties_uu_id": "Görev UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "staff_description": "Staff Description",
+        "staff_name": "Staff Name",
+        "staff_code": "Staff Code",
+        "duties_id": "Duty ID",
+        "duties_uu_id": "Duty UUID",
+    },
+)
+
+EmployeesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "staff_id": "Personel ID",
+        "staff_uu_id": "Personel UUID",
+        "people_id": "Kişi ID",
+        "people_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "staff_id": "Staff ID",
+        "staff_uu_id": "Staff UUID",
+        "people_id": "People ID",
+        "people_uu_id": "People UUID",
+    },
+)
+
+EmployeeHistoryLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "staff_id": "Personel ID",
+        "staff_uu_id": "Personel UUID",
+        "people_id": "Kişi ID",
+        "people_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "staff_id": "Staff ID",
+        "staff_uu_id": "Staff UUID",
+        "people_id": "People ID",
+        "people_uu_id": "People UUID",
+    },
+)
+
+EmployeesSalariesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "gross_salary": "Brüt Maaş",
+        "net_salary": "Net Maaş",
+        "people_id": "Kişi ID",
+        "people_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "gross_salary": "Gross Salary",
+        "net_salary": "Net Salary",
+        "people_id": "People ID",
+        "people_uu_id": "People UUID",
+    },
+)

ApiLayers/LanguageModels/Database/event/event.py

@@ -0,0 +1,185 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+
+EventsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "event_type": "Etkinlik Türü",
+        "function_code": "Fonksiyon Kodu",
+        "function_class": "Fonksiyon Sınıfı",
+        "description": "Açıklama",
+        "property_description": "Özellik Açıklaması",
+        "marketing_layer": "Pazarlama Katmanı",
+        "cost": "Maliyet",
+        "unit_price": "Birim Fiyat",
+        "endpoint_id": "Endpoint ID",
+        "endpoint_uu_id": "Endpoint UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "event_type": "Event Type",
+        "function_code": "Function Code",
+        "function_class": "Function Class",
+        "description": "Description",
+        "property_description": "Property Description",
+        "marketing_layer": "Marketing Layer",
+        "cost": "Cost",
+        "unit_price": "Unit Price",
+        "endpoint_id": "Endpoint ID",
+        "endpoint_uu_id": "Endpoint UUID",
+    },
+)
+
+ModulesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "module_name": "Modül Adı",
+        "module_description": "Modül Açıklaması",
+        "module_code": "Modül Kodu",
+        "module_layer": "Modül Katmanı",
+        "is_default_module": "Varsayılan Modül",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "module_name": "Module Name",
+        "module_description": "Module Description",
+        "module_code": "Module Code",
+        "module_layer": "Module Layer",
+        "is_default_module": "Default Module",
+    },
+)
+
+ServicesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "module_id": "Modül ID",
+        "module_uu_id": "Modül UUID",
+        "service_name": "Servis Adı",
+        "service_description": "Servis Açıklaması",
+        "service_code": "Servis Kodu",
+        "related_responsibility": "İlgili Sorumluluk",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "module_id": "Module ID",
+        "module_uu_id": "Module UUID",
+        "service_name": "Service Name",
+        "service_description": "Service Description",
+        "service_code": "Service Code",
+        "related_responsibility": "Related Responsibility",
+    },
+)
+
+Service2EventsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "service_id": "Servis ID",
+        "service_uu_id": "Servis UUID",
+        "event_id": "Etkinlik ID",
+        "event_uu_id": "Etkinlik UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "service_id": "Service ID",
+        "service_uu_id": "Service UUID",
+        "event_id": "Event ID",
+        "event_uu_id": "Event UUID",
+    },
+)
+
+Event2OccupantExtraLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_living_space_id": "Bina Yaşam Alanı ID",
+        "build_living_space_uu_id": "Bina Yaşam Alanı UUID",
+        "event_id": "Etkinlik ID",
+        "event_uu_id": "Etkinlik UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_living_space_id": "Build Living Space ID",
+        "build_living_space_uu_id": "Build Living Space UUID",
+        "event_id": "Event ID",
+        "event_uu_id": "Event UUID",
+    },
+)
+
+Event2EmployeeExtraLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "employee_id": "Çalışan ID",
+        "employee_uu_id": "Çalışan UUID",
+        "event_id": "Etkinlik ID",
+        "event_uu_id": "Etkinlik UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "employee_id": "Employee ID",
+        "employee_uu_id": "Employee UUID",
+        "event_id": "Event ID",
+        "event_uu_id": "Event UUID",
+    },
+)
+
+Event2EmployeeLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "employee_id": "Çalışan ID",
+        "employee_uu_id": "Çalışan UUID",
+        "event_service_id": "Etkinlik Servis ID",
+        "event_service_uu_id": "Etkinlik Servis UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "employee_id": "Employee ID",
+        "employee_uu_id": "Employee UUID",
+        "event_service_id": "Event Service ID",
+        "event_service_uu_id": "Event Service UUID",
+    },
+)
+
+Event2OccupantLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_living_space_id": "Bina Yaşam Alanı ID",
+        "build_living_space_uu_id": "Bina Yaşam Alanı UUID",
+        "event_service_id": "Etkinlik Servis ID",
+        "event_service_uu_id": "Etkinlik Servis UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_living_space_id": "Build Living Space ID",
+        "build_living_space_uu_id": "Build Living Space UUID",
+        "event_service_id": "Event Service ID",
+        "event_service_uu_id": "Event Service UUID",
+    },
+)
+
+ModulePriceLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "campaign_code": "Kampanya Kodu",
+        "module_id": "Modül ID",
+        "module_uu_id": "Modül UUID",
+        "service_id": "Servis ID",
+        "service_uu_id": "Servis UUID",
+        "event_id": "Etkinlik ID",
+        "event_uu_id": "Etkinlik UUID",
+        "is_counted_percentage": "İndirim Oranı",
+        "discounted_price": "İndirimli Fiyat",
+        "calculated_price": "Hesaplanan Fiyat",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "campaign_code": "Campaign Code",
+        "module_id": "Module ID",
+        "module_uu_id": "Module UUID",
+        "service_id": "Service ID",
+        "service_uu_id": "Service UUID",
+        "event_id": "Event ID",
+        "event_uu_id": "Event UUID",
+        "is_counted_percentage": "Discount Rate",
+        "discounted_price": "Discounted Price",
+        "calculated_price": "Calculated Price",
+    },
+)

ApiLayers/LanguageModels/Database/identity/identity.py

@@ -0,0 +1,424 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+UsersTokensLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "user_id": "Kullanıcı ID",
+        "token_type": "Token Türü",
+        "token": "Token",
+        "domain": "Domain",
+        "expires_at": "Bitiş Tarihi",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "user_id": "User ID",
+        "token_type": "Token Type",
+        "token": "Token",
+        "domain": "Domain",
+        "expires_at": "Expires At",
+    },
+)
+
+UsersLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "user_tag": "Kullanıcı Etiketi",
+        "email": "E-posta",
+        "phone_number": "Telefon Numarası",
+        "via": "Via",
+        "avatar": "Avatar",
+        "hash_password": "Şifre",
+        "password_token": "Şifre Token",
+        "remember_me": "Beni Hatırla",
+        "password_expires_day": "Şifre Son Kullanma Günü",
+        "password_expiry_begins": "Şifre Son Kullanma Başlangıç",
+        "related_company": "İlgili Şirket",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "user_tag": "User Tag",
+        "email": "Email",
+        "phone_number": "Phone Number",
+        "via": "Via",
+        "avatar": "Avatar",
+        "hash_password": "Password",
+        "password_token": "Password Token",
+        "remember_me": "Remember Me",
+        "password_expires_day": "Password Expires Day",
+        "password_expiry_begins": "Password Expiry Begins",
+        "related_company": "Related Company",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UUID",
+    },
+)
+
+RelationshipDutyPeopleLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "company_id": "Şirket ID",
+        "duties_id": "Görev ID",
+        "member_id": "Üye ID",
+        "relationship_type": "İlişki Türü",
+        "show_only": "Sadece Göster",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "company_id": "Company ID",
+        "duties_id": "Duty ID",
+        "member_id": "Member ID",
+        "relationship_type": "Relationship Type",
+        "show_only": "Show Only",
+    },
+)
+
+PeopleLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "firstname": "Ad",
+        "surname": "Soyad",
+        "middle_name": "Orta Ad",
+        "sex_code": "Cinsiyet Kodu",
+        "person_ref": "Kişi Referansı",
+        "person_tag": "Kişi Etiketi",
+        "father_name": "Baba Adı",
+        "mother_name": "Anne Adı",
+        "country_code": "Ülke Kodu",
+        "national_identity_id": "Kimlik Numarası",
+        "birth_place": "Doğum Yeri",
+        "birth_date": "Doğum Tarihi",
+        "tax_no": "Vergi Numarası",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "firstname": "First Name",
+        "surname": "Last Name",
+        "middle_name": "Middle Name",
+        "sex_code": "Gender",
+        "person_ref": "Person Reference",
+        "person_tag": "Person Tag",
+        "father_name": "Father Name",
+        "mother_name": "Mother Name",
+        "country_code": "Country Code",
+        "national_identity_id": "National Identity ID",
+        "birth_place": "Birth Place",
+        "birth_date": "Birth Date",
+        "tax_no": "Tax No",
+    },
+)
+
+RelationshipEmployee2PostCodeLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "company_id": "Şirket ID",
+        "employee_id": "Çalışan ID",
+        "member_id": "Üye ID",
+        "relationship_type": "İlişki Türü",
+        "show_only": "Sadece Göster",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "company_id": "Company ID",
+        "employee_id": "Employee ID",
+        "member_id": "Member ID",
+        "relationship_type": "Relationship Type",
+        "show_only": "Show Only",
+    },
+)
+
+AddressPostcodeLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "street_id": "Sokak ID",
+        "street_uu_id": "Sokak UUID",
+        "postcode": "Posta Kodu",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "street_id": "Street ID",
+        "street_uu_id": "Street UUID",
+        "postcode": "Postcode",
+    },
+)
+
+AddressesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "build_number": "Bina Numarası",
+        "door_number": "Kapı Numarası",
+        "floor_number": "Kat Numarası",
+        "comment_address": "Adres",
+        "letter_address": "Adres",
+        "short_letter_address": "Adres",
+        "latitude": "Enlem",
+        "longitude": "Boylam",
+        "street_id": "Sokak ID",
+        "street_uu_id": "Sokak UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "build_number": "Build Number",
+        "door_number": "Door Number",
+        "floor_number": "Floor Number",
+        "comment_address": "Address",
+        "letter_address": "Address",
+        "short_letter_address": "Address",
+        "latitude": "Latitude",
+        "longitude": "Longitude",
+        "street_id": "Street ID",
+        "street_uu_id": "Street UUID",
+    },
+)
+
+AddressGeographicLocationsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "geo_table": "Tablo Adı",
+        "geo_id": "ID",
+        "geo_name": "Ad",
+        "geo_latitude": "Enlem",
+        "geo_longitude": "Boylam",
+        "geo_altitude": "Yükseklik",
+        "geo_description": "Açıklama",
+        "geo_area_size": "Alan",
+        "geo_population": "Nüfus",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "geo_table": "Table Name",
+        "geo_id": "ID",
+        "geo_name": "Name",
+        "geo_latitude": "Latitude",
+        "geo_longitude": "Longitude",
+        "geo_altitude": "Altitude",
+        "geo_description": "Description",
+        "geo_area_size": "Area",
+        "geo_population": "Population",
+    },
+)
+
+AddressCountryLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "country_code": "Ülke Kodu",
+        "country_name": "Ülke Adı",
+        "money_code": "Para Kodu",
+        "language": "Dil Kodu",
+        "address_geographic_id": "Adres Coğrafi ID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "country_code": "Country Code",
+        "country_name": "Country Name",
+        "money_code": "Money Code",
+        "language": "Language Code",
+        "address_geographic_id": "Address Geographic ID",
+    },
+)
+
+AddressStateLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "state_code": "Eyalet Kodu",
+        "state_name": "Eyalet Adı",
+        "licence_plate": "Plaka Kodu",
+        "phone_code": "Telefon Kodu",
+        "gov_code": "Hükümet Kodu",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "country_id": "Ülke ID",
+        "country_uu_id": "Ülke UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "state_code": "State Code",
+        "state_name": "State Name",
+        "licence_plate": "Licence Plate",
+        "phone_code": "Phone Code",
+        "gov_code": "Government Code",
+        "address_geographic_id": "Address Geographic ID",
+        "country_id": "Country ID",
+        "country_uu_id": "Country UUID",
+    },
+)
+
+AddressCityLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "city_code": "Şehir Kodu",
+        "city_name": "Şehir Adı",
+        "licence_plate": "Plaka Kodu",
+        "phone_code": "Telefon Kodu",
+        "gov_code": "Hükümet Kodu",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "state_id": "Eyalet ID",
+        "state_uu_id": "Eyalet UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "city_code": "City Code",
+        "city_name": "City Name",
+        "licence_plate": "Licence Plate",
+        "phone_code": "Phone Code",
+        "gov_code": "Government Code",
+        "address_geographic_id": "Address Geographic ID",
+        "state_id": "State ID",
+        "state_uu_id": "State UUID",
+    },
+)
+
+AddressDistrictLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "district_code": "İlçe Kodu",
+        "district_name": "İlçe Adı",
+        "phone_code": "Telefon Kodu",
+        "gov_code": "Hükümet Kodu",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "city_id": "Şehir ID",
+        "city_uu_id": "Şehir UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "district_code": "District Code",
+        "district_name": "District Name",
+        "phone_code": "Phone Code",
+        "gov_code": "Government Code",
+        "address_geographic_id": "Address Geographic ID",
+        "city_id": "City ID",
+        "city_uu_id": "City UUID",
+    },
+)
+
+AddressLocalityLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "locality_code": "Mahalle Kodu",
+        "locality_name": "Mahalle Adı",
+        "type_code": "Tip Kodu",
+        "type_description": "Tip Açıklaması",
+        "gov_code": "Hükümet Kodu",
+        "address_show": "Adres Göster",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "district_id": "İlçe ID",
+        "district_uu_id": "İlçe UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "locality_code": "Locality Code",
+        "locality_name": "Locality Name",
+        "type_code": "Type Code",
+        "type_description": "Type Description",
+        "gov_code": "Government Code",
+        "address_show": "Address Show",
+        "address_geographic_id": "Address Geographic ID",
+        "district_id": "District ID",
+        "district_uu_id": "District UUID",
+    },
+)
+
+AddressNeighborhoodLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "neighborhood_code": "Mahalle Kodu",
+        "neighborhood_name": "Mahalle Adı",
+        "type_code": "Tip Kodu",
+        "type_description": "Tip Açıklaması",
+        "gov_code": "Hükümet Kodu",
+        "address_show": "Adres Göster",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "district_id": "İlçe ID",
+        "district_uu_id": "İlçe UUID",
+        "locality_id": "Mahalle ID",
+        "locality_uu_id": "Mahalle UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "neighborhood_code": "Neighborhood Code",
+        "neighborhood_name": "Neighborhood Name",
+        "type_code": "Type Code",
+        "type_description": "Type Description",
+        "gov_code": "Government Code",
+        "address_show": "Address Show",
+        "address_geographic_id": "Address Geographic ID",
+        "district_id": "District ID",
+        "district_uu_id": "District UUID",
+        "locality_id": "Locality ID",
+        "locality_uu_id": "Locality UUID",
+    },
+)
+
+AddressStreetLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "street_code": "Sokak Kodu",
+        "street_name": "Sokak Adı",
+        "type_code": "Tip Kodu",
+        "type_description": "Tip Açıklaması",
+        "gov_code": "Hükümet Kodu",
+        "address_geographic_id": "Adres Coğrafi ID",
+        "neighborhood_id": "Mahalle ID",
+        "neighborhood_uu_id": "Mahalle UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "street_code": "Street Code",
+        "street_name": "Street Name",
+        "type_code": "Type Code",
+        "type_description": "Type Description",
+        "gov_code": "Government Code",
+        "address_geographic_id": "Address Geographic ID",
+        "neighborhood_id": "Neighborhood ID",
+        "neighborhood_uu_id": "Neighborhood UUID",
+    },
+)
+
+OccupantTypesLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "occupant_type": "Kişi Türü",
+        "occupant_description": "Kişi Açıklaması",
+        "occupant_code": "Kişi Kodu",
+        "occupant_category": "Kişi Kategori",
+        "occupant_category_type": "Kişi Kategori Türü",
+        "occupant_is_unique": "Kişi Benzersiz",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "occupant_type": "Occupant Type",
+        "occupant_description": "Occupant Description",
+        "occupant_code": "Occupant Code",
+        "occupant_category": "Occupant Category",
+        "occupant_category_type": "Occupant Category Type",
+        "occupant_is_unique": "Occupant Unique",
+    },
+)
+
+ContractsLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "contract_type": "Sözleşme Türü",
+        "contract_title": "Sözleşme Başlığı",
+        "contract_details": "Sözleşme Detayları",
+        "contract_terms": "Sözleşme Şartları",
+        "contract_code": "Sözleşme Kodu",
+        "contract_date": "Sözleşme Tarihi",
+        "company_id": "Şirket ID",
+        "company_uu_id": "Şirket UUID",
+        "person_id": "Kişi ID",
+        "person_uu_id": "Kişi UUID",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "contract_type": "Contract Type",
+        "contract_title": "Contract Title",
+        "contract_details": "Contract Details",
+        "contract_terms": "Contract Terms",
+        "contract_code": "Contract Code",
+        "contract_date": "Contract Date",
+        "company_id": "Company ID",
+        "company_uu_id": "Company UUID",
+        "person_id": "Person ID",
+        "person_uu_id": "Person UUID",
+    },
+)

ApiLayers/LanguageModels/Database/rules/rules.py

@@ -0,0 +1,20 @@
+from LanguageModels.Database.Mixins.crud_mixin import CrudCollectionLanguageModel
+
+EndpointRestrictionLanguageModel = dict(
+    tr={
+        **CrudCollectionLanguageModel["tr"],
+        "endpoint_function": "API Fonksiyonu",
+        "endpoint_name": "API Adı",
+        "endpoint_method": "API Metodu",
+        "endpoint_desc": "API Açıklaması",
+        "endpoint_code": "API Kodu",
+    },
+    en={
+        **CrudCollectionLanguageModel["en"],
+        "endpoint_function": "API Function",
+        "endpoint_name": "API Name",
+        "endpoint_method": "API Method",
+        "endpoint_desc": "API Description",
+        "endpoint_code": "API Code",
+    },
+)

ApiLayers/LanguageModels/Errors/__init__.py

@@ -0,0 +1,3 @@
+from .merge_all_error_languages import MergedErrorLanguageModels
+
+__all__ = ["MergedErrorLanguageModels"]

ApiLayers/LanguageModels/Errors/base_languages.py

@@ -0,0 +1,35 @@
+class BaseErrorLanguageModelTurkish:
+
+    NOT_CREATED: str = "Kayıt oluşturulamadı."
+    NOT_DELETED: str = "Kayıt silinemedi."
+    NOT_UPDATED: str = "Kayıt güncellenemedi."
+    NOT_LISTED: str = "Kayıt listelenemedi."
+    NOT_FOUND: str = "Kayıt bulunamadı."
+    ALREADY_EXISTS: str = "Kayıt zaten mevcut."
+    IS_NOT_CONFIRMED: str = "Kayıt onaylanmadı."
+    NOT_AUTHORIZED: str = "Yetkisiz kullanıcı."
+    NOT_VALID: str = "Gecersiz veri."
+    NOT_ACCEPTABLE: str = "Gecersiz veri."
+    INVALID_DATA: str = "Gecersiz veri."
+    UNKNOWN_ERROR: str = "Bilinmeyen bir hata oluştu."
+
+
+class BaseErrorLanguageModelEnglish:
+
+    NOT_CREATED: str = "Not Created."
+    NOT_DELETED: str = "Not Deleted."
+    NOT_UPDATED: str = "Not Updated."
+    NOT_LISTED: str = "Not Listed."
+    NOT_FOUND: str = "Not Found."
+    ALREADY_EXISTS: str = "Already Exists."
+    IS_NOT_CONFIRMED: str = "Not Confirmed."
+    NOT_AUTHORIZED: str = "Not Authorized."
+    NOT_VALID: str = "Not Valid."
+    NOT_ACCEPTABLE: str = "Not Acceptable."
+    INVALID_DATA: str = "Invalid Data."
+    UNKNOWN_ERROR: str = "Unknown Error occured."
+
+
+class BaseErrorLanguageModels:
+    tr: BaseErrorLanguageModelTurkish = BaseErrorLanguageModelTurkish
+    en: BaseErrorLanguageModelEnglish = BaseErrorLanguageModelEnglish

ApiLayers/LanguageModels/Errors/merge_all_error_languages.py

@@ -0,0 +1,18 @@
+from LanguageModels.Errors.base_languages import BaseErrorLanguageModels
+
+
+class MergedErrorLanguageModels:
+    list_of_languages = [BaseErrorLanguageModels]
+
+    @classmethod
+    def get_language_models(cls, language: str):
+        language_model_keys = {}
+        for list_of_language in cls.list_of_languages:
+            language_model_class = getattr(list_of_language, language, None)
+            clean_dict = {
+                key: value
+                for key, value in language_model_class.__dict__.items()
+                if "__" not in str(key)[0:3]
+            }
+            language_model_keys.update(clean_dict)
+        return language_model_keys

ApiLayers/Schemas/__init__.py

@@ -0,0 +1,179 @@
+# SQL Models
+from .account.account import (
+    AccountBooks,
+    AccountCodeParser,
+    AccountRecords,
+    AccountCodes,
+    AccountDetail,
+    AccountMaster,
+    AccountRecordExchanges,
+)
+from .building.budget import (
+    DecisionBookBudgetBooks,
+    DecisionBookBudgetCodes,
+    DecisionBookBudgetMaster,
+    DecisionBookBudgets,
+)
+from .account.iban import (
+    BuildIbans,
+    BuildIbanDescription,
+)
+from .api.encrypter import CrypterEngine
+from .building.build import (
+    Build,
+    BuildTypes,
+    BuildParts,
+    BuildArea,
+    BuildSites,
+    BuildLivingSpace,
+    BuildPersonProviding,
+    BuildCompaniesProviding,
+    RelationshipEmployee2Build,
+)
+from .building.decision_book import (
+    BuildDecisionBook,
+    BuildDecisionBookItems,
+    BuildDecisionBookPerson,
+    BuildDecisionBookLegal,
+    BuildDecisionBookItemsUnapproved,
+    BuildDecisionBookInvitations,
+    BuildDecisionBookPayments,
+    BuildDecisionBookProjects,
+    BuildDecisionBookProjectPerson,
+    BuildDecisionBookPersonOccupants,
+    BuildDecisionBookProjectItems,
+)
+from .company.company import (
+    Companies,
+    RelationshipDutyCompany,
+)
+from .company.employee import (
+    Employees,
+    EmployeesSalaries,
+    EmployeeHistory,
+    Staff,
+)
+from .company.department import (
+    Duty,
+    Duties,
+    Departments,
+)
+from .event.event import (
+    Modules,
+    Services,
+    Service2Events,
+    Events,
+    Event2Occupant,
+    Event2Employee,
+    Event2OccupantExtra,
+    Event2EmployeeExtra,
+)
+from .identity.identity import (
+    Addresses,
+    AddressCity,
+    AddressStreet,
+    AddressLocality,
+    AddressDistrict,
+    AddressNeighborhood,
+    AddressState,
+    AddressCountry,
+    AddressPostcode,
+    AddressGeographicLocations,
+    UsersTokens,
+    OccupantTypes,
+    People,
+    Users,
+    RelationshipDutyPeople,
+    RelationshipEmployee2PostCode,
+    Contracts,
+)
+from .others.enums import (
+    ApiEnumDropdown,
+)
+from .rules.rules import (
+    EndpointRestriction,
+)
+
+# # NO-SQL Models
+# from Schemas.no_sql_models.mongo_database import (
+#     MongoQuery,
+# )
+# from Schemas.no_sql_models.identity import (
+#     MongoQueryIdentity,
+# )
+
+__all__ = [
+    "AccountBooks",
+    "AccountCodeParser",
+    "AccountRecords",
+    "AccountCodes",
+    "AccountDetail",
+    "AccountMaster",
+    "AccountRecordExchanges",
+    "BuildIbans",
+    "BuildIbanDescription",
+    "CrypterEngine",
+    "Build",
+    "BuildTypes",
+    "BuildParts",
+    "BuildArea",
+    "BuildSites",
+    "BuildLivingSpace",
+    "BuildPersonProviding",
+    "BuildCompaniesProviding",
+    "BuildDecisionBook",
+    "BuildDecisionBookItems",
+    "BuildDecisionBookPerson",
+    "BuildDecisionBookLegal",
+    "BuildDecisionBookItemsUnapproved",
+    "BuildDecisionBookInvitations",
+    "BuildDecisionBookPayments",
+    "BuildDecisionBookProjects",
+    "BuildDecisionBookProjectPerson",
+    "BuildDecisionBookPersonOccupants",
+    "BuildDecisionBookProjectItems",
+    "DecisionBookBudgetBooks",
+    "DecisionBookBudgetCodes",
+    "DecisionBookBudgetMaster",
+    "DecisionBookBudgets",
+    "Companies",
+    "RelationshipDutyCompany",
+    "Employees",
+    "EmployeesSalaries",
+    "EmployeeHistory",
+    "Staff",
+    "Duty",
+    "Duties",
+    "Departments",
+    "Modules",
+    "Services",
+    "Service2Events",
+    "Events",
+    "Event2Occupant",
+    "Event2Employee",
+    "Event2OccupantExtra",
+    "Event2EmployeeExtra",
+    "Addresses",
+    "AddressCity",
+    "AddressStreet",
+    "AddressLocality",
+    "AddressDistrict",
+    "AddressNeighborhood",
+    "AddressState",
+    "AddressCountry",
+    "AddressPostcode",
+    "AddressGeographicLocations",
+    "UsersTokens",
+    "OccupantTypes",
+    "People",
+    "Users",
+    "RelationshipDutyPeople",
+    "RelationshipEmployee2PostCode",
+    "Contracts",
+    "ApiEnumDropdown",
+    "EndpointRestriction",
+    "RelationshipEmployee2Build",
+    # ------------------------------------------------
+    "MongoQuery",
+    "MongoQueryIdentity",
+]

ApiLayers/Schemas/account/account.py

@@ -0,0 +1,641 @@
+from sqlalchemy.orm import mapped_column, Mapped
+from sqlalchemy import (
+    String,
+    Integer,
+    Boolean,
+    ForeignKey,
+    Index,
+    TIMESTAMP,
+    Numeric,
+    SmallInteger,
+)
+
+from Services.PostgresDb import CrudCollection
+from LanguageModels.Database.account.account import (
+    AccountBooksLanguageModel,
+    AccountCodesLanguageModel,
+    AccountRecordsLanguageModel,
+    AccountRecordExchangesLanguageModel,
+    AccountDetailLanguageModel,
+    AccountCodeParserLanguageModel,
+    AccountMasterLanguageModel,
+)
+
+
+class AccountBooks(CrudCollection):
+
+    __tablename__ = "account_books"
+    __exclude__fields__ = []
+    __language_model__ = AccountBooksLanguageModel
+
+    country: Mapped[str] = mapped_column(String, nullable=False)
+    branch_type: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=False)
+    company_uu_id: Mapped[str] = mapped_column(String, nullable=False)
+    branch_id: Mapped[int] = mapped_column(ForeignKey("companies.id"))
+    branch_uu_id: Mapped[str] = mapped_column(String, comment="Branch UU ID")
+
+    __table_args__ = (
+        Index("account_companies_book_ndx_00", company_id, "expiry_starts"),
+        {"comment": "Account Book Information"},
+    )
+
+
+class AccountCodes(CrudCollection):
+
+    __tablename__ = "account_codes"
+    __exclude__fields__ = []
+    __language_model__ = AccountCodesLanguageModel
+
+    account_code: Mapped[str] = mapped_column(
+        String(48), nullable=False, comment="Account Code"
+    )
+    comment_line: Mapped[str] = mapped_column(
+        String(128), nullable=False, comment="Comment Line"
+    )
+
+    is_receive_or_debit: Mapped[bool] = mapped_column(Boolean)
+    product_id: Mapped[int] = mapped_column(Integer, server_default="0")
+    nvi_id: Mapped[str] = mapped_column(String(48), server_default="")
+    status_id: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    account_code_seperator: Mapped[str] = mapped_column(String(1), server_default=".")
+
+    system_id: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    locked: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"))
+    company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Company UU ID"
+    )
+    customer_id: Mapped[int] = mapped_column(ForeignKey("companies.id"))
+    customer_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Customer UU ID"
+    )
+    person_id: Mapped[int] = mapped_column(ForeignKey("people.id"))
+    person_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Person UU ID"
+    )
+
+    __table_args__ = ({"comment": "Account Code Information"},)
+
+
+class AccountCodeParser(CrudCollection):
+
+    __tablename__ = "account_code_parser"
+    __exclude__fields__ = []
+    __language_model__ = AccountCodesLanguageModel
+
+    account_code_1: Mapped[str] = mapped_column(String, nullable=False, comment="Order")
+    account_code_2: Mapped[str] = mapped_column(String, nullable=False, comment="Order")
+    account_code_3: Mapped[str] = mapped_column(String, nullable=False, comment="Order")
+    account_code_4: Mapped[str] = mapped_column(String, server_default="")
+    account_code_5: Mapped[str] = mapped_column(String, server_default="")
+    account_code_6: Mapped[str] = mapped_column(String, server_default="")
+
+    account_code_id: Mapped[int] = mapped_column(
+        ForeignKey("account_codes.id"), nullable=False
+    )
+    account_code_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Account Code UU ID"
+    )
+
+    __table_args__ = (
+        Index("_account_code_parser_ndx_00", account_code_id),
+        {"comment": "Account Code Parser Information"},
+    )
+
+    @property
+    def get_account_code(self):
+        return f"{self.account_codes.account_code_seperator}".join(
+            [
+                getattr(self, f"account_code_{i}")
+                for i in range(1, 7)
+                if getattr(self, f"account_code_{i}")
+            ]
+        )
+
+
+class AccountMaster(CrudCollection):
+    """
+    AccountCodes class based on declarative_base and CrudCollection via session
+    """
+
+    __tablename__ = "account_master"
+    __exclude__fields__ = []
+    __language_model__ = AccountMasterLanguageModel
+
+    doc_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), nullable=False, comment="Document Date"
+    )
+    plug_type: Mapped[str] = mapped_column(String, nullable=False, comment="Plug Type")
+    plug_number: Mapped[int] = mapped_column(
+        Integer, nullable=False, comment="Plug Number"
+    )
+
+    special_code: Mapped[str] = mapped_column(String(12), server_default="")
+    authorization_code: Mapped[str] = mapped_column(String(12), server_default="")
+
+    doc_code: Mapped[str] = mapped_column(String(12), server_default="")
+    doc_type: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    comment_line1: Mapped[str] = mapped_column(String, server_default="")
+    comment_line2: Mapped[str] = mapped_column(String, server_default="")
+    comment_line3: Mapped[str] = mapped_column(String, server_default="")
+    comment_line4: Mapped[str] = mapped_column(String, server_default="")
+    comment_line5: Mapped[str] = mapped_column(String, server_default="")
+    comment_line6: Mapped[str] = mapped_column(String, server_default="")
+    project_code: Mapped[str] = mapped_column(String(12), server_default="")
+    module_no: Mapped[str] = mapped_column(String, server_default="")
+    journal_no: Mapped[int] = mapped_column(Integer, server_default="0")
+
+    status_id: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    canceled: Mapped[bool] = mapped_column(Boolean, server_default="0")
+    print_count: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    total_active: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_passive: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_active_1: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_passive_1: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_active_2: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_passive_2: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_active_3: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_passive_3: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_active_4: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    total_passive_4: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    cross_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    data_center_id: Mapped[str] = mapped_column(String, server_default="")
+    data_center_rec_num: Mapped[int] = mapped_column(Integer, server_default="0")
+
+    account_header_id: Mapped[int] = mapped_column(
+        ForeignKey("account_books.id"), nullable=False
+    )
+    account_header_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Account Header UU ID"
+    )
+    project_item_id: Mapped[int] = mapped_column(
+        ForeignKey("build_decision_book_projects.id")
+    )
+    project_item_uu_id: Mapped[str] = mapped_column(
+        String, comment="Project Item UU ID"
+    )
+    department_id: Mapped[int] = mapped_column(ForeignKey("departments.id"))
+    department_uu_id: Mapped[str] = mapped_column(String, comment="Department UU ID")
+
+    __table_args__ = (
+        Index("_account_master_ndx_00", doc_date, account_header_id),
+        {"comment": "Account Master Information"},
+    )
+
+
+class AccountDetail(CrudCollection):
+    """
+    AccountCodes class based on declarative_base and CrudCollection via session
+    """
+
+    __tablename__ = "account_detail"
+    __exclude__fields__ = []
+    __enum_list__ = [("plug_type", "AccountingReceiptTypes", "M")]
+    __language_model__ = AccountDetailLanguageModel
+
+    doc_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), nullable=False, comment="Document Date"
+    )
+    line_no: Mapped[int] = mapped_column(
+        SmallInteger, nullable=False, comment="Line Number"
+    )
+    receive_debit: Mapped[str] = mapped_column(
+        String(1), nullable=False, comment="Receive Debit"
+    )
+    debit: Mapped[float] = mapped_column(
+        Numeric(20, 6), nullable=False, comment="Debit"
+    )
+
+    department: Mapped[str] = mapped_column(String(24), server_default="")
+    special_code: Mapped[str] = mapped_column(String(12), server_default="")
+    account_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    account_fiche_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    center_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    general_code: Mapped[str] = mapped_column(String(32), server_default="")
+    credit: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    currency_type: Mapped[str] = mapped_column(String(4), server_default="TL")
+    exchange_rate: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    debit_cur: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    credit_cur: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    discount_cur: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    amount: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    cross_account_code: Mapped[float] = mapped_column(String(32), server_default="")
+    inf_index: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    not_inflated: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    not_calculated: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    comment_line1: Mapped[str] = mapped_column(String(64), server_default="")
+    comment_line2: Mapped[str] = mapped_column(String(64), server_default="")
+    comment_line3: Mapped[str] = mapped_column(String(64), server_default="")
+    comment_line4: Mapped[str] = mapped_column(String(64), server_default="")
+    comment_line5: Mapped[str] = mapped_column(String(64), server_default="")
+    comment_line6: Mapped[str] = mapped_column(String(64), server_default="")
+    owner_acc_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    from_where: Mapped[int] = mapped_column(Integer, server_default="0")
+    orj_eid: Mapped[int] = mapped_column(Integer, server_default="0")
+    canceled: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+    cross_ref: Mapped[int] = mapped_column(Integer, server_default="0")
+    data_center_id: Mapped[str] = mapped_column(String, server_default="")
+    data_center_rec_num: Mapped[int] = mapped_column(Integer, server_default="0")
+    status_id: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    plug_type_id: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    plug_type_uu_id = mapped_column(String, nullable=False, comment="Plug Type UU ID")
+    account_header_id: Mapped[int] = mapped_column(
+        ForeignKey("account_books.id"), nullable=False
+    )
+    account_header_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Account Header UU ID"
+    )
+    account_code_id: Mapped[int] = mapped_column(
+        ForeignKey("account_codes.id"), nullable=False
+    )
+    account_code_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Account Code UU ID"
+    )
+    account_master_id: Mapped[int] = mapped_column(
+        ForeignKey("account_master.id"), nullable=False
+    )
+    account_master_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Account Master UU ID"
+    )
+    project_id: Mapped[int] = mapped_column(
+        ForeignKey("build_decision_book_projects.id")
+    )
+    project_uu_id: Mapped[str] = mapped_column(String, comment="Project UU ID")
+
+    __table_args__ = (
+        Index(
+            "_account_detail_ndx_00",
+            account_master_id,
+            doc_date,
+            line_no,
+            account_header_id,
+            unique=True,
+        ),
+        {"comment": "Account Detail Information"},
+    )
+
+
+class AccountRecords(CrudCollection):
+    """
+    build_decision_book_id = kaydın sorumlu olduğu karar defteri
+    send_company_id = kaydı gönderen firma, send_person_id = gönderen kişi
+    customer_id = sorumlu kullanıcı bilgisi, company_id = sorumlu firma
+    """
+
+    __tablename__ = "account_records"
+    __exclude__fields__ = []
+    __enum_list__ = [
+        ("receive_debit", "DebitTypes", "D"),
+        ("budget_type", "BudgetType", "B"),
+    ]
+    __language_model__ = AccountRecordsLanguageModel
+
+    iban: Mapped[str] = mapped_column(
+        String(64), nullable=False, comment="IBAN Number of Bank"
+    )
+    bank_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), nullable=False, comment="Bank Transaction Date"
+    )
+
+    currency_value: Mapped[float] = mapped_column(
+        Numeric(20, 6), nullable=False, comment="Currency Value"
+    )
+    bank_balance: Mapped[float] = mapped_column(
+        Numeric(20, 6), nullable=False, comment="Bank Balance"
+    )
+    currency: Mapped[str] = mapped_column(
+        String(5), nullable=False, comment="Unit of Currency"
+    )
+    additional_balance: Mapped[float] = mapped_column(
+        Numeric(20, 6), nullable=False, comment="Additional Balance"
+    )
+    channel_branch: Mapped[str] = mapped_column(
+        String(120), nullable=False, comment="Branch Bank"
+    )
+    process_name: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Bank Process Type Name"
+    )
+    process_type: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Bank Process Type"
+    )
+    process_comment: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Transaction Record Comment"
+    )
+    process_garbage: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Transaction Record Garbage"
+    )
+    bank_reference_code: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Bank Reference Code"
+    )
+
+    add_comment_note: Mapped[str] = mapped_column(String, server_default="")
+    is_receipt_mail_send: Mapped[bool] = mapped_column(Boolean, server_default="0")
+    found_from = mapped_column(String, server_default="")
+    similarity: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    remainder_balance: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+
+    bank_date_y: Mapped[int] = mapped_column(Integer)
+    bank_date_m: Mapped[int] = mapped_column(SmallInteger)
+    bank_date_w: Mapped[int] = mapped_column(SmallInteger)
+    bank_date_d: Mapped[int] = mapped_column(SmallInteger)
+
+    approving_accounting_record: Mapped[bool] = mapped_column(
+        Boolean, server_default="0"
+    )
+    accounting_receipt_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), server_default="1900-01-01 00:00:00"
+    )
+    accounting_receipt_number: Mapped[int] = mapped_column(Integer, server_default="0")
+    status_id: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    approved_record: Mapped[bool] = mapped_column(Boolean, server_default="0")
+    import_file_name: Mapped[str] = mapped_column(
+        String, nullable=True, comment="XLS Key"
+    )
+
+    receive_debit: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    receive_debit_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Debit UU ID"
+    )
+    budget_type: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    budget_type_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Budget Type UU ID"
+    )
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=True)
+    company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Company UU ID"
+    )
+    send_company_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=True
+    )
+    send_company_uu_id = mapped_column(
+        String, nullable=True, comment="Send Company UU ID"
+    )
+
+    send_person_id: Mapped[int] = mapped_column(ForeignKey("people.id"), nullable=True)
+    send_person_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Send Person UU ID"
+    )
+    approving_accounting_person: Mapped[int] = mapped_column(
+        ForeignKey("people.id"), nullable=True
+    )
+    approving_accounting_person_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Approving Accounting Person UU ID"
+    )
+
+    living_space_id: Mapped[int] = mapped_column(
+        ForeignKey("build_living_space.id"), nullable=True
+    )
+    living_space_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Living Space UU ID"
+    )
+    customer_id: Mapped[int] = mapped_column(ForeignKey("people.id"), nullable=True)
+    customer_uu_id = mapped_column(String, nullable=True, comment="Customer UU ID")
+
+    build_id: Mapped[int] = mapped_column(ForeignKey("build.id"), nullable=True)
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build UU ID"
+    )
+    build_parts_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"), nullable=True
+    )
+    build_parts_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Parts UU ID"
+    )
+    build_decision_book_id: Mapped[int] = mapped_column(
+        ForeignKey("build_decision_book.id"), nullable=True
+    )
+    build_decision_book_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Decision Book UU ID"
+    )
+
+    __table_args__ = (
+        Index("_budget_records_ndx_00", is_receipt_mail_send, bank_date),
+        Index(
+            "_budget_records_ndx_01",
+            iban,
+            bank_date,
+            bank_reference_code,
+            bank_balance,
+            unique=True,
+        ),
+        Index("_budget_records_ndx_02", status_id, bank_date),
+        {
+            "comment": "Bank Records that are related to building and financial transactions"
+        },
+    )
+
+    # def payment_budget_record_close(self):
+    #     from database_sql_models import (
+    #         DecisionBookProjectPaymentsMaster,
+    #         ApiEnumDropdown,
+    #         BuildDecisionBook,
+    #         BuildDecisionBookPaymentsMaster,
+    #     )
+    #
+    #     budget_record = self
+    #     if self.receive_debit == ApiEnumDropdown.uuid_of_enum(
+    #         enum_class="DebitTypes", key="R"
+    #     ):
+    #         print(
+    #             "This record is not debit. Debit:",
+    #             self.receive_debit,
+    #             "DebitTypes.R.name",
+    #             # str(DebitTypes.R.name),
+    #         )
+    #         return
+    #     if abs(budget_record.currency_value + budget_record.remainder_balance) > 0:
+    #         payment_dict = {
+    #             "budget_records_id": self.id,
+    #             "build_decision_book_id": budget_record.build_decision_book_id,
+    #             "build_parts_id": budget_record.build_parts_id,
+    #             "start_date": budget_record.bank_date,
+    #             "paid_value": budget_record.currency_value
+    #             - budget_record.remainder_balance,
+    #             "is_all": False,
+    #         }
+    #         (paid_value, start_paid_value, balance) = (
+    #             float(budget_record.currency_value - budget_record.remainder_balance),
+    #             float(budget_record.currency_value - budget_record.remainder_balance),
+    #             float(budget_record.remainder_balance),
+    #         )
+    #         print(
+    #             "self.id",
+    #             self.id,
+    #             "paid_value",
+    #             paid_value,
+    #             "start_paid_value",
+    #             start_paid_value,
+    #             "balance",
+    #             balance,
+    #             self.receive_debit,
+    #         )
+    #
+    #         if not BuildDecisionBook.find_one(
+    #             id=payment_dict["build_decision_book_id"]
+    #         ):
+    #             return paid_value
+    #
+    #         if budget_record.replication_id == 55:
+    #             if paid_value > 0:
+    #                 payment_dict["dues_type"] = ApiEnumDropdown.uuid_of_enum(
+    #                     enum_class="BuildDuesTypes", key="L"
+    #                 )
+    #                 paid_value = (
+    #                     DecisionBookProjectPaymentsMaster.pay_law_and_ren_of_build_part(
+    #                         **payment_dict
+    #                     )
+    #                 )
+    #                 print("dues_type", payment_dict["dues_type"], paid_value)
+    #             if paid_value > 0:
+    #                 payment_dict.pop("dues_type", None)
+    #                 paid_value = BuildDecisionBookPaymentsMaster.pay_dues_of_build_part(
+    #                     **payment_dict
+    #                 )
+    #                 print("dues_type", None, paid_value)
+    #             if paid_value > 0:
+    #                 payment_dict["dues_type"] = ApiEnumDropdown.uuid_of_enum(
+    #                     enum_class="BuildDuesTypes", key="R"
+    #                 )
+    #                 paid_value = (
+    #                     DecisionBookProjectPaymentsMaster.pay_law_and_ren_of_build_part(
+    #                         **payment_dict
+    #                     )
+    #                 )
+    #                 print("dues_type", payment_dict["dues_type"], paid_value)
+    #             payment_dict["is_all"] = True
+    #             if paid_value > 0:
+    #                 payment_dict["dues_type"] = ApiEnumDropdown.uuid_of_enum(
+    #                     enum_class="BuildDuesTypes", key="L"
+    #                 )
+    #                 paid_value = (
+    #                     DecisionBookProjectPaymentsMaster.pay_law_and_ren_of_build_part(
+    #                         **payment_dict
+    #                     )
+    #                 )
+    #                 print("is all dues_type", payment_dict["dues_type"], paid_value)
+    #             if paid_value > 0:
+    #                 payment_dict.pop("dues_type", None)
+    #                 paid_value = BuildDecisionBookPaymentsMaster.pay_dues_of_build_part(
+    #                     **payment_dict
+    #                 )
+    #                 print("is all dues_type", None, paid_value)
+    #             if paid_value > 0:
+    #                 payment_dict["dues_type"] = ApiEnumDropdown.uuid_of_enum(
+    #                     enum_class="BuildDuesTypes", key="R"
+    #                 )
+    #                 paid_value = (
+    #                     DecisionBookProjectPaymentsMaster.pay_law_and_ren_of_build_part(
+    #                         **payment_dict
+    #                     )
+    #                 )
+    #                 print("is all dues_type", payment_dict["dues_type"], paid_value)
+
+
+# class AccountRecordDecisionPaymentClosed(CrudCollection):
+#
+#     __tablename__ = "account_record_decision_payment_closed"
+#     __exclude__fields__ = []
+#
+#     arc_currency: Mapped[str] = mapped_column(
+#         String(5), nullable=False, comment="Unit of Currency"
+#     )
+#     arc_processing_time: Mapped[TIMESTAMP] = mapped_column(
+#         TIMESTAMP(timezone=True), nullable=False, comment="Processing Time"
+#     )
+#     arc_currency_value: Mapped[float] = mapped_column(
+#         Numeric(20, 6), nullable=False, comment="Currency Value"
+#     )
+#
+#     decision_book_budgets_id: Mapped[int] = mapped_column(
+#         ForeignKey("decision_book_budgets.id"), nullable=True
+#     )
+#     decision_book_budgets_uu_id: Mapped[str] = mapped_column(
+#         String, nullable=True, comment="Budget UUID"
+#     )
+#
+#     build_decision_book_payment_id: Mapped[int] = mapped_column(
+#         ForeignKey("build_decision_book_payments.id")
+#     )
+#     build_decision_book_payment_uu_id: Mapped[str] = mapped_column(
+#         String, nullable=True, comment="Build Decision Book Payment UU ID"
+#     )
+#     account_records_id: Mapped[int] = mapped_column(ForeignKey("account_records.id"))
+#     account_records_uu_id: Mapped[str] = mapped_column(
+#         String, nullable=True, comment="Account Record UU ID"
+#     )
+#
+#     __table_args__ = (
+#         Index(
+#             "_account_record_decision_payment_closed_ndx_00",
+#             account_records_id,
+#             build_decision_book_payment_id,
+#             arc_processing_time,
+#         ),
+#         Index(
+#             "_account_record_decision_payment_closed_ndx_01",
+#             build_decision_book_payment_id,
+#             account_records_id,
+#             arc_processing_time,
+#         ),
+#         {"comment": "Account Record Decision Payment Closed Information"},
+#     )
+
+
+class AccountRecordExchanges(CrudCollection):
+
+    __tablename__ = "account_record_exchanges"
+    __exclude__fields__ = []
+    __language_model__ = AccountRecordExchangesLanguageModel
+
+    are_currency: Mapped[str] = mapped_column(
+        String(5), nullable=False, comment="Unit of Currency"
+    )
+    are_exchange_rate: Mapped[float] = mapped_column(
+        Numeric(18, 6), nullable=False, server_default="1"
+    )
+    usd_exchange_rate_value: Mapped[float] = mapped_column(
+        Numeric(18, 6),
+        nullable=True,
+        server_default="0",
+        comment="It will be written by multiplying the usd exchange rate with the current value result.",
+    )
+    eur_exchange_rate_value: Mapped[float] = mapped_column(
+        Numeric(18, 6),
+        nullable=True,
+        server_default="0",
+        comment="It will be written by multiplying the eur exchange rate with the current value result.",
+    )
+    gbp_exchange_rate_value: Mapped[float] = mapped_column(
+        Numeric(18, 6),
+        nullable=True,
+        server_default="0",
+        comment="It will be written by multiplying the gpd exchange rate with the current value result.",
+    )
+    cny_exchange_rate_value: Mapped[float] = mapped_column(
+        Numeric(18, 6),
+        nullable=True,
+        server_default="0",
+        comment="It will be written by multiplying the cny exchange rate with the current value result.",
+    )
+
+    account_records_id: Mapped[int] = mapped_column(ForeignKey("account_records.id"))
+    account_records_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Account Record UU ID"
+    )
+
+    __table_args__ = (
+        Index("_account_record_exchanges_ndx_00", account_records_id),
+        {"comment": "Account Record Exchanges Information"},
+    )

ApiLayers/Schemas/account/iban.py

@@ -0,0 +1,103 @@
+from sqlalchemy import String, ForeignKey, Index, TIMESTAMP, SmallInteger, Identity
+from sqlalchemy.orm import mapped_column, Mapped
+
+from Services.PostgresDb import CrudCollection
+
+
+class BuildIbans(CrudCollection):
+    """
+    BuildParts class based on declarative_base and BaseMixin via session
+    """
+
+    __tablename__ = "build_ibans"
+    __exclude__fields__ = []
+
+    iban: Mapped[str] = mapped_column(
+        String(40), server_default="", nullable=False, comment="IBAN number"
+    )
+    start_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), nullable=False, comment="Bank Transaction Start Date"
+    )
+
+    stop_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), server_default="2900-01-01 00:00:00"
+    )
+    bank_code: Mapped[str] = mapped_column(String(24), server_default="TR0000000000000")
+    xcomment: Mapped[str] = mapped_column(String(64), server_default="????")
+
+    build_id: Mapped[int] = mapped_column(
+        ForeignKey("build.id"), nullable=True, comment="Building ID"
+    )
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Building UUID", index=True
+    )
+    # building: Mapped["Build"] = relationship(
+    #     "Build", back_populates="build_ibans", foreign_keys=[build_id]
+    # )
+
+    __table_args__ = (
+        Index("_build_ibans_ndx_01", iban, start_date, unique=True),
+        {"comment": "IBANs related to money transactions due to building objects"},
+    )
+
+
+class BuildIbanDescription(CrudCollection):
+    """
+    SearchComments class based on declarative_base and CrudCollection via session
+    """
+
+    __tablename__ = "build_iban_description"
+    __exclude__fields__ = []
+
+    iban: Mapped[str] = mapped_column(String, nullable=False, comment="IBAN Number")
+    group_id: Mapped[int] = mapped_column(
+        SmallInteger, nullable=False, comment="Group ID"
+    )
+    search_word: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Search Word", index=True
+    )
+
+    # decision_book_project_id: Mapped[int] = mapped_column(
+    #     ForeignKey("build_decision_book_projects.id")
+    # )
+    # decision_book_project_uu_id: Mapped[str] = mapped_column(
+    #     String, nullable=False, comment="Decision Book Project UUID"
+    # )
+    customer_id: Mapped[int] = mapped_column(ForeignKey("people.id"), nullable=True)
+    customer_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Customer UUID"
+    )
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=True)
+    company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Company UUID"
+    )
+    build_parts_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"), nullable=True
+    )
+    build_parts_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Parts UUID"
+    )
+
+    # decision_book_project: Mapped["BuildDecisionBookProjects"] = relationship(
+    #     "BuildDecisionBookProjects",
+    #     back_populates="search_iban_description",
+    #     foreign_keys=[decision_book_project_id],
+    # )
+    # customer: Mapped["People"] = relationship(
+    #     "People", back_populates="search_iban_description", foreign_keys=[customer_id]
+    # )
+    # company: Mapped["Companies"] = relationship(
+    #     "Company", back_populates="search_iban_description", foreign_keys=[company_id]
+    # )
+    # parts: Mapped["BuildParts"] = relationship(
+    #     "BuildParts",
+    #     back_populates="search_iban_description",
+    #     foreign_keys=[build_parts_id],
+    # )
+
+    __table_args__ = (
+        Index(
+            "_search_iban_description_ndx_00", iban, search_word, group_id, unique=True
+        ),
+        {"comment": "Search Iban Description Information"},
+    )

ApiLayers/Schemas/api/encrypter.py

@@ -0,0 +1,124 @@
+import random
+
+from datetime import datetime, timedelta
+
+from sqlalchemy import String
+from sqlalchemy.orm import mapped_column, Mapped
+
+from cryptography.fernet import Fernet, MultiFernet
+from Services.PostgresDb import CrudCollection
+
+
+class CrypterEngine(CrudCollection):
+
+    __tablename__ = "crypter_engine"
+    __table_args__ = ()
+    encrypt_list = []
+    decrypt_list = []
+    keys_error = "Unable to retrieve encrypt keys"
+    alchemy_error = "Alchemy object is empty"
+
+    key_first: Mapped[str] = mapped_column(String, nullable=False)
+    key_second: Mapped[str] = mapped_column(String, nullable=False)
+
+    @classmethod
+    def get_valid_keys(cls, row=None):
+        cls.encrypt_list, cls.decrypt_list = [], []
+        if not cls.filter_all(cls.created_at > datetime.now() - timedelta(days=29)).get(
+            1
+        ):
+            cls.create_encrypt_keys(count=100)
+        if decrypt_identifier := getattr(row, "cryp_uu_id", None):
+            if decrypt_row := cls.find_one(uu_id=str(decrypt_identifier)):
+                return (
+                    decrypt_row.key_first.decode(),
+                    decrypt_row.key_second.decode(),
+                    decrypt_row.uu_id,
+                )
+        if encrypt_rows := cls.filter_all(
+            cls.created_at > datetime.now() - timedelta(days=29)
+        ).data:
+            encrypt_row = random.choice(encrypt_rows)
+            return (
+                encrypt_row.key_first.encode(),
+                encrypt_row.key_second.encode(),
+                encrypt_rows.uu_id,
+            )
+        return None, None, None
+
+    @classmethod
+    def create_encrypt_keys(cls, count: int):
+        for _ in range(count):
+            key_first = Fernet.generate_key()
+            key_second = Fernet.generate_key()
+            cls.find_or_create(
+                key_first=key_first.decode(), key_second=key_second.decode()
+            )
+
+    @classmethod
+    def raise_exception(cls, message=None):
+        raise Exception(message if message else cls.keys_error)
+
+    @classmethod
+    def encrypt_given_alchemy_list(cls, alchemy_object_list: list):
+        for alchemy_object in alchemy_object_list:
+            key_first, key_second, cryp_uu_id = cls.get_valid_keys()
+            fernet_keys = MultiFernet([Fernet(key_first), Fernet(key_second)])
+            if not key_first or not key_second:
+                cls.raise_exception()
+            alchemy_dict = alchemy_object.get_dict() if alchemy_object else None
+            if not alchemy_dict:
+                cls.raise_exception(cls.alchemy_error)
+            for key, plain_row in alchemy_dict.items():
+                if key in alchemy_object.__encrypt_list__:
+                    alchemy_dict[key] = fernet_keys.encrypt(plain_row).decode()
+            alchemy_dict["cryp_uu_id"] = cryp_uu_id
+            cls.encrypt_list.append(alchemy_object.update(**alchemy_dict))
+        return cls.encrypt_list
+
+    @classmethod
+    def encrypt_given_alchemy_object(cls, alchemy_object_object):
+        key_first, key_second, cryp_uu_id = cls.get_valid_keys()
+        fernet_keys = MultiFernet([Fernet(key_first), Fernet(key_second)])
+        if not key_first or not key_second:
+            cls.raise_exception()
+        alchemy_dict = (
+            alchemy_object_object.get_dict() if alchemy_object_object else None
+        )
+        if not alchemy_dict:
+            cls.raise_exception(cls.alchemy_error)
+        for key, plain_row in alchemy_dict.items():
+            if key in alchemy_object_object.__encrypt_list__:
+                alchemy_dict[key] = fernet_keys.encrypt(plain_row).decode()
+        alchemy_dict["cryp_uu_id"] = cryp_uu_id
+        return alchemy_object_object.update(**alchemy_dict)
+
+    @classmethod
+    def decrypt_given_alchemy(cls, alchemy_object_list: list):
+        for alchemy_object in alchemy_object_list:
+            key_first, key_second, cryp_uu_id = cls.get_valid_keys(row=alchemy_object)
+            fernet_keys = MultiFernet([Fernet(key_first), Fernet(key_second)])
+            if not key_first or not key_second:
+                cls.raise_exception()
+            alchemy_dict = alchemy_object.get_dict() if alchemy_object else None
+            if not alchemy_dict:
+                cls.raise_exception(cls.alchemy_error)
+            for key, plain_row in alchemy_dict.items():
+                if key in alchemy_object.__encrypt_list__:
+                    alchemy_dict[key] = fernet_keys.decrypt(plain_row).decode()
+            cls.decrypt_list.append(alchemy_dict)
+        return cls.decrypt_list
+
+    @classmethod
+    def decrypt_given_alchemy_object(cls, alchemy_object):
+        key_first, key_second, cryp_uu_id = cls.get_valid_keys(row=alchemy_object)
+        fernet_keys = MultiFernet([Fernet(key_first), Fernet(key_second)])
+        if not key_first or not key_second:
+            cls.raise_exception()
+        alchemy_dict = alchemy_object.get_dict() if alchemy_object else None
+        if not alchemy_dict:
+            cls.raise_exception(cls.alchemy_error)
+        for key, plain_row in alchemy_dict.items():
+            if key in alchemy_object.__encrypt_list__:
+                alchemy_dict[key] = fernet_keys.decrypt(plain_row).decode()
+        return alchemy_dict

ApiLayers/Schemas/building/budget.py

@@ -0,0 +1,156 @@
+from sqlalchemy import (
+    String,
+    ForeignKey,
+    Index,
+    SmallInteger,
+    TIMESTAMP,
+    Text,
+    Numeric,
+    Integer,
+)
+from sqlalchemy.orm import mapped_column, Mapped
+from Services.PostgresDb import CrudCollection
+
+
+class DecisionBookBudgetBooks(CrudCollection):
+
+    __tablename__ = "decision_book_budget_books"
+    __exclude__fields__ = []
+
+    country: Mapped[str] = mapped_column(String, nullable=False)
+    branch_type: Mapped[int] = mapped_column(SmallInteger, server_default="0")
+
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=False)
+    company_uu_id: Mapped[str] = mapped_column(String, nullable=False)
+    branch_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=True)
+    branch_uu_id: Mapped[str] = mapped_column(
+        String, comment="Branch UU ID", nullable=True
+    )
+    build_decision_book_id: Mapped[int] = mapped_column(
+        ForeignKey("build_decision_book.id"), nullable=False
+    )
+    build_decision_book_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Decision Book UU ID"
+    )
+
+    __table_args__ = (
+        Index(
+            "_decision_book_budget_companies_book_ndx_00",
+            company_id,
+            "created_at",
+        ),
+        {"comment": "budget Book Information"},
+    )
+
+
+class DecisionBookBudgetCodes(CrudCollection):
+
+    __tablename__ = "decision_book_budget_codes"
+    __exclude__fields__ = []
+
+    budget_code: Mapped[str] = mapped_column(
+        String(48), nullable=False, comment="budget Code"
+    )
+    comment_line: Mapped[str] = mapped_column(
+        Text, nullable=False, comment="Comment Line"
+    )
+
+    build_decision_book_id: Mapped[int] = mapped_column(
+        ForeignKey("build_decision_book.id"), nullable=True
+    )
+    build_decision_book_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Decision Book UU ID"
+    )
+
+    build_parts_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"), nullable=True
+    )
+    build_parts_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Build Parts UU ID"
+    )
+
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"), nullable=True)
+    company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Company UU ID"
+    )
+
+    __table_args__ = (
+        Index("_decision_book_budget_codes_ndx_00", budget_code, "created_at"),
+        Index("_decision_book_budget_codes_ndx_01", company_id, "created_at"),
+        {"comment": "budget Book Information"},
+    )
+
+
+class DecisionBookBudgetMaster(CrudCollection):
+
+    __tablename__ = "decision_book_budget_master"
+    __exclude__fields__ = []
+
+    budget_type: Mapped[str] = mapped_column(
+        String(50), nullable=False
+    )  # Bütçe tipi (örneğin: Operasyonel, Yatırım)
+    currency: Mapped[str] = mapped_column(
+        String(8), server_default="TRY"
+    )  # Bütçe para birimi
+    total_budget: Mapped[float] = mapped_column(
+        Numeric(10, 2), nullable=False
+    )  # Toplam bütçe
+
+    tracking_period_id: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    tracking_period_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Part Direction UUID"
+    )
+    budget_books_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("decision_book_budget_books.id"), nullable=False
+    )
+    budget_books_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Budget Books UU ID"
+    )
+    department_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("departments.id"), nullable=False
+    )  # Departman ile ilişki
+    department_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Department UU ID"
+    )
+
+    __table_args__ = ({"comment": "budget Book Information"},)
+
+
+class DecisionBookBudgets(CrudCollection):
+
+    __tablename__ = "decision_book_budgets"
+    __exclude__fields__ = []
+
+    process_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), nullable=False
+    )  # Başlangıç tarihi
+    budget_codes_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("decision_book_budget_codes.id"), nullable=False
+    )
+    total_budget: Mapped[float] = mapped_column(
+        Numeric(10, 2), nullable=False
+    )  # Toplam bütçe
+    used_budget: Mapped[float] = mapped_column(
+        Numeric(10, 2), nullable=False, default=0.0
+    )  # Kullanılan bütçe
+    remaining_budget: Mapped[float] = mapped_column(
+        Numeric(10, 2), nullable=False, default=0.0
+    )  # Kullanılan bütçe
+
+    decision_book_budget_master_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("decision_book_budget_master.id"), nullable=False
+    )
+    decision_book_budget_master_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Decision Book Budget Master UU ID"
+    )
+
+    __table_args__ = (
+        Index(
+            "_decision_book_budgets_ndx_00",
+            decision_book_budget_master_uu_id,
+            process_date,
+        ),
+        {"comment": "budget Book Information"},
+    )

ApiLayers/Schemas/building/build.py

@@ -0,0 +1,803 @@
+from datetime import timedelta
+from typing import List, Union
+
+from fastapi import HTTPException, status
+from sqlalchemy.orm import mapped_column, relationship, Mapped
+from sqlalchemy import (
+    String,
+    Integer,
+    Boolean,
+    ForeignKey,
+    Index,
+    TIMESTAMP,
+    Text,
+    Numeric,
+    or_,
+)
+
+from ApiLibrary import system_arrow, SelectActionWithEmployee
+from Services.PostgresDb import CrudCollection
+from ApiValidations.Request import (
+    InsertBuild,
+    InsertBuildParts,
+    InsertBuildLivingSpace,
+    UpdateBuild,
+)
+
+from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
+from LanguageModels.Database.building.build import (
+    BuildTypesLanguageModel,
+    Part2EmployeeLanguageModel,
+    BuildPartsLanguageModel,
+    BuildSitesLanguageModel,
+    RelationshipEmployee2BuildLanguageModel,
+    BuildLanguageModel,
+    BuildPartsLanguageModel,
+    BuildLivingSpaceLanguageModel,
+    BuildManagementLanguageModel,
+    BuildAreaLanguageModel,
+    BuildCompaniesProvidingLanguageModel,
+    BuildPersonProvidingLanguageModel,
+)
+
+
+class BuildTypes(CrudCollection):
+    """
+    BuildTypes class based on declarative_base and BaseMixin via session
+
+    """
+
+    __tablename__ = "build_types"
+    __exclude__fields__ = []
+    __language_model__ = BuildTypesLanguageModel
+    __include__fields__ = []
+
+    function_code: Mapped[str] = mapped_column(
+        String(12), server_default="", nullable=False, comment="Function Code"
+    )
+    type_code: Mapped[str] = mapped_column(
+        String(12), server_default="", nullable=False, comment="Structure Type Code"
+    )
+    lang: Mapped[str] = mapped_column(
+        String(4), server_default="TR", nullable=False, comment="Language"
+    )
+    type_name: Mapped[str] = mapped_column(
+        String(48), server_default="", nullable=False, comment="Type Name"
+    )
+
+    __table_args__ = (
+        Index("_build_types_ndx_00", type_code, function_code, lang, unique=True),
+        {"comment": "Function group of building types with their language information"},
+    )
+
+
+class Part2Employee(CrudCollection):
+    """
+    Employee2Parts class based on declarative_base and BaseMixin via session
+    In between start and end date, a part can be assigned to only one employee
+    """
+
+    __tablename__ = "part2employee"
+    __exclude__fields__ = []
+    __language_model__ = Part2EmployeeLanguageModel
+    __include__fields__ = []
+
+    build_id: Mapped[int] = mapped_column(Integer, comment="Building ID")
+    part_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"), nullable=False, comment="Part ID"
+    )
+    employee_id: Mapped[int] = mapped_column(
+        ForeignKey("employees.id"), nullable=False, comment="Employee ID"
+    )
+
+    __table_args__ = (
+        Index("_part2employee_ndx_00", employee_id, part_id, unique=True),
+        {"comment": "Employee2Parts Information"},
+    )
+
+
+class RelationshipEmployee2Build(CrudCollection):
+    """
+    CompanyRelationship class based on declarative_base and CrudCollection via session
+    Company -> Sub Company -> Sub-Sub Company
+
+    """
+
+    __tablename__ = "relationship_employee2build"
+    __exclude__fields__ = []
+    __language_model__ = RelationshipEmployee2BuildLanguageModel
+
+    company_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=False
+    )  # 1, 2, 3
+    employee_id: Mapped[int] = mapped_column(
+        ForeignKey("employees.id"), nullable=False
+    )  # employee -> (n)person Evyos LTD
+    member_id: Mapped[int] = mapped_column(
+        ForeignKey("build.id"), nullable=False
+    )  # 2, 3, 4
+
+    relationship_type: Mapped[str] = mapped_column(
+        String, nullable=True, server_default="Employee"
+    )  # Commercial
+    show_only: Mapped[bool] = mapped_column(Boolean, server_default="False")
+
+    __table_args__ = (
+        Index(
+            "relationship_build_employee_ndx_00",
+            company_id,
+            employee_id,
+            member_id,
+            relationship_type,
+            unique=True,
+        ),
+        {"comment": "Build & Employee Relationship Information"},
+    )
+
+
+class Build(CrudCollection, SelectActionWithEmployee):
+    """
+    Builds class based on declarative_base and BaseMixin via session
+    """
+
+    __tablename__ = "build"
+    __exclude__fields__ = []
+    __language_model__ = BuildLanguageModel
+    __include__fields__ = []
+    __access_by__ = []
+    __many__table__ = RelationshipEmployee2Build
+    # __explain__ = AbstractBuild()
+
+    gov_address_code: Mapped[str] = mapped_column(
+        String, server_default="", unique=True
+    )
+    build_name: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Building Name"
+    )
+    build_no: Mapped[str] = mapped_column(
+        String(8), nullable=False, comment="Building Number"
+    )
+
+    max_floor: Mapped[int] = mapped_column(
+        Integer, server_default="1", nullable=False, comment="Max Floor"
+    )
+    underground_floor: Mapped[int] = mapped_column(
+        Integer, server_default="0", nullable=False, comment="Underground Floor"
+    )
+    build_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True), server_default="1900-01-01"
+    )
+    decision_period_date: Mapped[TIMESTAMP] = mapped_column(
+        TIMESTAMP(timezone=True),
+        server_default="1900-01-01",
+        comment="Building annual ordinary meeting period",
+    )
+    tax_no: Mapped[str] = mapped_column(String(24), server_default="")
+    lift_count: Mapped[int] = mapped_column(Integer, server_default="0")
+    heating_system: Mapped[bool] = mapped_column(Boolean, server_default="True")
+    cooling_system: Mapped[bool] = mapped_column(Boolean, server_default="False")
+    hot_water_system: Mapped[bool] = mapped_column(Boolean, server_default="False")
+    block_service_man_count: Mapped[int] = mapped_column(Integer, server_default="0")
+    security_service_man_count: Mapped[int] = mapped_column(Integer, server_default="0")
+    garage_count: Mapped[int] = mapped_column(
+        Integer, server_default="0", comment="Garage Count"
+    )
+    management_room_id: Mapped[int] = mapped_column(
+        Integer, nullable=True, comment="Management Room ID"
+    )
+
+    site_id: Mapped[int] = mapped_column(ForeignKey("build_sites.id"), nullable=True)
+    site_uu_id: Mapped[str] = mapped_column(String, comment="Site UUID", nullable=True)
+    address_id: Mapped[int] = mapped_column(ForeignKey("addresses.id"), nullable=False)
+    address_uu_id: Mapped[str] = mapped_column(
+        String, comment="Address UUID", nullable=False
+    )
+    build_types_id: Mapped[int] = mapped_column(
+        ForeignKey("build_types.id"), nullable=False, comment="Building Type"
+    )
+    build_types_uu_id: Mapped[str] = mapped_column(String, comment="Building Type UUID")
+
+    parts: Mapped[List["BuildParts"]] = relationship(
+        "BuildParts", back_populates="buildings", foreign_keys="BuildParts.build_id"
+    )
+    decision_books: Mapped[List["BuildDecisionBook"]] = relationship(
+        "BuildDecisionBook",
+        back_populates="buildings",
+        foreign_keys="BuildDecisionBook.build_id",
+    )
+
+    # build_ibans: Mapped["BuildIbans"] = relationship(
+    #     "BuildIbans", back_populates="building", foreign_keys="BuildIbans.build_id"
+    # )
+    # areas: Mapped["BuildArea"] = relationship(
+    #     "BuildArea", back_populates="buildings", foreign_keys="BuildArea.build_id"
+    # )
+    # response_companies: Mapped["Companies"] = relationship(
+    #     "Companies",
+    #     back_populates="response_buildings",
+    #     foreign_keys=[response_company_id],
+    # )
+    # addresses: Mapped[List["Address"]] = relationship(
+    #     "Address", back_populates="buildings", foreign_keys=[address_id]
+    # )
+    # peoples: Mapped["People"] = relationship(
+    #     "People", back_populates="buildings", foreign_keys=[people_id]
+    # )
+    # sites: Mapped["BuildSites"] = relationship(
+    #     "BuildSites", back_populates="buildings", foreign_keys=[site_id]
+    # )
+
+    __table_args__ = (
+        Index("_builds_ndx_00", gov_address_code),
+        Index("_builds_ndx_01", build_name, build_no),
+        {
+            "comment": "Build objects are building that are created for living and store purposes"
+        },
+    )
+
+    @property
+    def management_room(self):
+        if management_room := BuildParts.filter_by_one(
+            system=True, id=self.management_room_id, build_id=self.id
+        ).data:
+            return management_room
+        return None
+
+    @classmethod
+    def create_action(cls, data: InsertBuild, token):
+        from Schemas import Addresses
+
+        data_dict = data.excluded_dump()
+        data_dict["address_id"] = None
+        if data.address_uu_id:
+            official_address = Addresses.filter_one(
+                Addresses.uu_id == data.address_uu_id,
+            ).data
+            data_dict["address_id"] = official_address.id
+            data_dict["build_no"] = str(official_address.build_number)
+        if not data_dict["address_id"]:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Address is not found in database. Re-enter address record then try again.",
+            )
+        build_type = BuildTypes.filter_by_one(
+            system=True, uu_id=str(data.build_types_uu_id)
+        ).data
+        data_dict["build_types_id"] = build_type.id
+        build_created = cls.find_or_create(**data_dict)
+        created_build_relation = cls.__many__table__.find_or_create(
+            company_id=token.selected_company.company_id,
+            employee_id=token.selected_company.employee_id,
+            member_id=build_created.id,
+        )
+        build_created.save()
+        build_created.update(is_confirmed=True)
+        build_created.save()
+        created_build_relation.update(is_confirmed=True)
+        created_build_relation.save()
+        return build_created
+
+    @classmethod
+    def update_action(cls, data: UpdateBuild, build_uu_id: str, token):
+        from Schemas import Addresses
+
+        data_dict = data.excluded_dump()
+        db = Addresses.new_session()
+        if data.address_uu_id:
+            official_address = Addresses.filter_one(
+                Addresses.uu_id == data.address_uu_id, db=db
+            ).first
+            data_dict["address_id"] = official_address.id if official_address else None
+        if build_to_update := cls.filter_one(cls.uu_id == build_uu_id, db=db).first:
+            updated_build = build_to_update.update(**data_dict)
+            updated_build.save()
+            return updated_build
+
+    @property
+    def top_flat(self):
+        max_flat_no = 0
+        for part in self.parts:
+            if part.part_no > self.max_floor:
+                max_flat_no = part.part_no
+        return max_flat_no
+
+    @property
+    def bottom_flat(self):
+        min_flat_no = 0
+        for part in self.parts:
+            if part.part_no < self.max_floor:
+                min_flat_no = part.part_no
+        return min_flat_no
+
+    @property
+    def human_livable_parts(self) -> tuple:
+        parts = list(part for part in self.parts if part.human_livable)
+        return parts, len(parts)
+
+    @property
+    def livable_part_count(self):
+        livable_parts = BuildParts.filter_all(
+            BuildParts.build_id == self.id,
+            BuildParts.human_livable == True,
+        )
+        if not livable_parts.data:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="There is no livable part in this building.",
+            )
+        return livable_parts.count
+
+    @property
+    def part_type_count(self):
+        building_types = None
+        for part in self.parts:
+            building_types = {}
+            build_type = BuildTypes.filter_by_one(
+                system=True, id=part.build_part_type_id
+            ).data
+            if build_type.type_code in building_types:
+                building_types[build_type.type_code]["list"].append(part.part_no)
+            else:
+                building_types[build_type.type_code] = {"list": [part.part_no]}
+
+            # for key, val in building_types.items():
+            #     list_parts = val["list"]
+            #     building_types[key] = {
+            #         "list": list_parts,
+            #         "min": min(list_parts),
+            #         "max": max(list_parts),
+            #         "count": len(list_parts),
+            #     }
+        return building_types
+
+
+class BuildParts(CrudCollection):
+    """
+    BuildParts class based on declarative_base and BaseMixin via session
+    Attentions: Part_no is unique for each building and Every building must have a management section.!!! default no 0
+    """
+
+    __tablename__ = "build_parts"
+    __exclude__fields__ = []
+    __language_model__ = BuildPartsLanguageModel
+    __include__fields__ = []
+    __enum_list__ = [("part_direction", "Directions", "NN")]
+
+    # https://adres.nvi.gov.tr/VatandasIslemleri/AdresSorgu
+    address_gov_code: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Goverment Door Code"
+    )
+    # part_name: Mapped[str] = mapped_column(String(24), server_default="", nullable=False, comment="Part Name")
+    part_no: Mapped[int] = mapped_column(
+        Integer, server_default="0", nullable=False, comment="Part Number"
+    )
+    part_level: Mapped[int] = mapped_column(
+        Integer, server_default="0", comment="Building Part Level"
+    )
+    part_code: Mapped[str] = mapped_column(
+        String, server_default="", nullable=False, comment="Part Code"
+    )
+    part_gross_size: Mapped[int] = mapped_column(
+        Integer, server_default="0", comment="Part Gross Size"
+    )
+    part_net_size: Mapped[int] = mapped_column(
+        Integer, server_default="0", comment="Part Net Size"
+    )
+    default_accessory: Mapped[str] = mapped_column(
+        Text, server_default="0", comment="Default Accessory"
+    )
+    human_livable: Mapped[bool] = mapped_column(
+        Boolean, server_default="1", comment="Human Livable"
+    )
+    due_part_key: Mapped[str] = mapped_column(
+        String, server_default="", nullable=False, comment="Constant Payment Group"
+    )
+
+    build_id: Mapped[int] = mapped_column(
+        ForeignKey("build.id"), nullable=False, comment="Building ID"
+    )
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Building UUID"
+    )
+    part_direction_id: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    part_direction_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Part Direction UUID"
+    )
+    part_type_id: Mapped[int] = mapped_column(
+        ForeignKey("build_types.id"), nullable=False, comment="Building Part Type"
+    )
+    part_type_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Building Part Type UUID"
+    )
+
+    buildings: Mapped["Build"] = relationship(
+        "Build", back_populates="parts", foreign_keys=[build_id]
+    )
+
+    __table_args__ = (
+        Index("build_parts_ndx_01", build_id, part_no, unique=True),
+        {"comment": "Part objects that are belong to building objects"},
+    )
+
+    @classmethod
+    def create_action(cls, data: InsertBuildParts, token):
+        from Schemas import ApiEnumDropdown
+
+        data_dict = data.dump()
+        build_from_duty = Build.select_action(
+            employee_id=token.selected_company.employee_id,
+            filter_expr=[Build.uu_id == data.build_uu_id],
+        )
+        building = build_from_duty.first()
+        if not building:
+            raise HTTPException(
+                status_code=status.HTTP_406_NOT_ACCEPTABLE,
+                detail="This Employee can not reach this building or building uu-id not found in database. "
+                "Check with your supervisor.",
+            )
+
+        if build_types := BuildTypes.filter_one(
+            BuildTypes.uu_id == data.build_part_type_uu_id,
+        ).data:
+            part_direction = ApiEnumDropdown.get_by_uuid(
+                uuid=str(data.part_direction_uu_id)
+            )
+
+            data_dict["part_gross_size"] = data.part_gross_size
+            data_dict["part_net_size"] = data.part_net_size
+            data_dict["part_type_id"] = build_types.id
+            data_dict["part_level"] = data.part_level
+            data_dict["build_id"] = building.id
+            data_dict["part_no"] = data.part_no
+            data_dict["part_code"] = (
+                f"{build_types.type_code}:{str(data_dict['part_no']).zfill(2)}"
+            )
+            data_dict["address_gov_code"] = data.address_gov_code
+            data_dict["default_accessory"] = data.default_accessory
+            data_dict["human_livable"] = bool(data.human_livable)
+
+            data_dict["build_uu_id"] = str(data.build_uu_id)
+            data_dict["part_type_id"] = build_types.id
+            data_dict["part_type_uu_id"] = str(build_types.uu_id)
+            data_dict["part_direction_id"] = part_direction.id
+            data_dict["part_direction_uu_id"] = str(part_direction.uu_id)
+            # data_dict["part_direction"] = str(data.part_direction_uu_id)
+
+            if not data_dict["part_gross_size"]:
+                raise HTTPException(
+                    status_code=status.HTTP_406_NOT_ACCEPTABLE,
+                    detail="Part Gross Size can not be empty.",
+                )
+
+            if not data_dict["part_net_size"]:
+                raise HTTPException(
+                    status_code=status.HTTP_406_NOT_ACCEPTABLE,
+                    detail="Part Net Size can not be empty.",
+                )
+            pt = int(data_dict["part_net_size"])
+            data_dict["due_part_key"] = str(pt + (5 - (pt % 5))) + "M2"
+            del data_dict["build_part_type_uu_id"]
+            return cls.find_or_create(**data_dict)
+
+        raise HTTPException(
+            status_code=status.HTTP_418_IM_A_TEAPOT,
+            detail="Build Part can not be created.",
+        )
+
+    @property
+    def part_name(self):
+        if build_type := BuildTypes.filter_by_one(
+            system=True, id=self.part_type_id
+        ).data:
+            return f"{str(build_type.type_name).upper()} : {str(self.part_no).upper()}"
+        return f"Undefined:{str(build_type.type_name).upper()}"
+
+
+class BuildLivingSpace(CrudCollection):
+    """
+    LivingSpace class based on declarative_base and BaseMixin via session
+    Owner or live person = Occupant of the build part
+    + Query OR(owner_person_id == person_id, life_person_id == person_id) AND (now(date))
+    """
+
+    __tablename__ = "build_living_space"
+    __exclude__fields__ = []
+    __language_model__ = BuildLivingSpaceLanguageModel
+    __include__fields__ = []
+
+    fix_value: Mapped[float] = mapped_column(
+        Numeric(20, 6),
+        server_default="0",
+        comment="Fixed value is deducted from debit.",
+    )
+    fix_percent: Mapped[float] = mapped_column(
+        Numeric(6, 2),
+        server_default="0",
+        comment="Fixed percent is deducted from debit.",
+    )
+
+    agreement_no: Mapped[str] = mapped_column(
+        String, server_default="", comment="Agreement No"
+    )
+    marketing_process: Mapped[bool] = mapped_column(Boolean, server_default="False")
+    marketing_layer: Mapped[int] = mapped_column(Integer, server_default="0")
+
+    build_parts_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"),
+        nullable=False,
+        index=True,
+        comment="Build Part ID",
+    )
+    build_parts_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Build Part UUID"
+    )
+    person_id: Mapped[int] = mapped_column(
+        ForeignKey("people.id"),
+        nullable=False,
+        index=True,
+        comment="Responsible People ID",
+    )
+    person_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Responsible People UUID"
+    )
+    occupant_type: Mapped[int] = mapped_column(
+        ForeignKey("occupant_types.id"),
+        nullable=False,
+        comment="Occupant Type",
+    )
+    occupant_type_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Occupant Type UUID"
+    )
+
+    __table_args__ = (
+        {"comment": "Living Space inside building parts that are related to people"},
+    )
+
+    @classmethod
+    def create_action(
+        cls,
+        data: dict,
+        token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
+    ):
+        from Schemas import Services, OccupantTypes
+        from api_events.events.events.events_bind_modules import (
+            ModulesBindOccupantEventMethods,
+        )
+
+        if data.get("expiry_starts"):
+            data["expiry_starts"] = str(system_arrow.get(data["expiry_starts"]))
+        if data.get("expiry_ends"):
+            data["expiry_ends"] = str(system_arrow.get(data["expiry_ends"]))
+        created_living_space = BuildLivingSpace.find_or_create(**data)
+        occupant_type = OccupantTypes.filter_by_one(
+            system=True, uu_id=created_living_space.occupant_type_uu_id
+        ).data
+        related_service = Services.filter_by_one(
+            related_responsibility=occupant_type.occupant_code,
+        ).data
+        if not related_service:
+            raise HTTPException(
+                status_code=status.HTTP_418_IM_A_TEAPOT,
+                detail="Service is not found in database. Re-enter service record then try again.",
+            )
+        ModulesBindOccupantEventMethods.bind_default_module_for_first_init_occupant(
+            build_living_space_id=created_living_space.id,
+        )
+        created_living_space.save_and_confirm()
+        return created_living_space
+
+    @classmethod
+    def find_living_from_customer_id(
+        cls, customer_id, process_date, add_days: int = 32
+    ):
+        from ApiLibrary.date_time_actions.date_functions import system_arrow
+
+        formatted_date = system_arrow.get(str(process_date))
+        living_spaces = cls.filter_all(
+            or_(
+                cls.owner_person_id == customer_id,
+                cls.life_person_id == customer_id,
+            ),
+            cls.start_date < formatted_date - timedelta(days=add_days),
+            cls.stop_date > formatted_date + timedelta(days=add_days),
+        )
+        return living_spaces.data, living_spaces.count
+
+
+class BuildManagement(CrudCollection):
+
+    __tablename__ = "build_management"
+    __exclude__fields__ = []
+    __language_model__ = BuildManagementLanguageModel
+
+    discounted_percentage: Mapped[float] = mapped_column(
+        Numeric(6, 2), server_default="0.00"
+    )  # %22
+    discounted_price: Mapped[float] = mapped_column(
+        Numeric(20, 2), server_default="0.00"
+    )  # Normal: 78.00 TL
+    calculated_price: Mapped[float] = mapped_column(
+        Numeric(20, 2), server_default="0.00"
+    )  # sana düz 75.00 TL yapar
+
+    occupant_type: Mapped[int] = mapped_column(
+        ForeignKey("occupant_types.id"),
+        nullable=False,
+        comment="Occupant Type",
+    )
+    occupant_type_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Occupant Type UUID"
+    )
+    build_id: Mapped[int] = mapped_column(
+        ForeignKey("build.id"), nullable=False, comment="Building ID"
+    )
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Building UUID"
+    )
+    build_parts_id: Mapped[int] = mapped_column(
+        ForeignKey("build_parts.id"),
+        nullable=False,
+        index=True,
+        comment="Build Part ID",
+    )
+    build_parts_uu_id: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Build Part UUID"
+    )
+
+    __table_args__ = (
+        Index(
+            "build_management_ndx_00",
+            build_parts_id,
+            occupant_type,
+            "expiry_starts",
+            unique=True,
+        ),
+        {"comment": "Management of the building parts that are related to people"},
+    )
+
+
+class BuildArea(CrudCollection):
+    """
+    Builds class based on declarative_base and BaseMixin via session
+    """
+
+    __tablename__ = "build_area"
+    __exclude__fields__ = []
+    __language_model__ = BuildAreaLanguageModel
+
+    area_name: Mapped[str] = mapped_column(String, server_default="")
+    area_code: Mapped[str] = mapped_column(String, server_default="")
+    area_type: Mapped[str] = mapped_column(String, server_default="GREEN")
+    area_direction: Mapped[str] = mapped_column(String(2), server_default="NN")
+    area_gross_size: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    area_net_size: Mapped[float] = mapped_column(Numeric(20, 6), server_default="0")
+    width = mapped_column(Integer, server_default="0")
+    size = mapped_column(Integer, server_default="0")
+
+    build_id: Mapped[int] = mapped_column(ForeignKey("build.id"))
+    build_uu_id: Mapped[str] = mapped_column(String, comment="Building UUID")
+    part_type_id: Mapped[int] = mapped_column(
+        ForeignKey("build_types.id"), nullable=True, comment="Building Part Type"
+    )
+    part_type_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Building Part Type UUID"
+    )
+
+    # buildings: Mapped["Build"] = relationship(
+    #     "Build", back_populates="areas", foreign_keys=[build_id]
+    # )
+
+    _table_args_ = (
+        Index("_edm_build_parts_area_ndx_00", build_id, area_code, unique=True),
+    )
+
+
+class BuildSites(CrudCollection):
+    """
+    Builds class based on declarative_base and BaseMixin via session
+    """
+
+    __tablename__ = "build_sites"
+    __exclude__fields__ = []
+    __language_model__ = BuildSitesLanguageModel
+    __include__fields__ = []
+
+    site_name: Mapped[str] = mapped_column(String(24), nullable=False)
+    site_no: Mapped[str] = mapped_column(String(8), nullable=False)
+
+    address_id: Mapped[int] = mapped_column(ForeignKey("addresses.id"))
+    address_uu_id: Mapped[str] = mapped_column(String, comment="Address UUID")
+
+    # addresses: Mapped["Address"] = relationship(
+    #     "Address", back_populates="site", foreign_keys=[address_id]
+    # )
+    # buildings: Mapped["Build"] = relationship(
+    #     "Build", back_populates="sites", foreign_keys="Build.site_id"
+    # )
+
+    __table_args__ = (
+        Index("_sites_ndx_01", site_no, site_name),
+        {"comment": "Sites that groups building objets"},
+    )
+
+
+class BuildCompaniesProviding(CrudCollection):
+    """ """
+
+    __tablename__ = "build_companies_providing"
+    __exclude__fields__ = []
+    __language_model__ = BuildCompaniesProvidingLanguageModel
+    __include__fields__ = []
+
+    build_id = mapped_column(
+        ForeignKey("build.id"), nullable=False, comment="Building ID"
+    )
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Providing UUID"
+    )
+    company_id: Mapped[int] = mapped_column(ForeignKey("companies.id"))
+    company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Providing UUID"
+    )
+    provide_id: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    provide_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Providing UUID"
+    )
+    contract_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("companies.id"), nullable=True
+    )
+
+    __table_args__ = (
+        Index(
+            "_build_companies_providing_ndx_00",
+            build_id,
+            company_id,
+            provide_id,
+            unique=True,
+        ),
+        {"comment": "Companies providing services for building"},
+    )
+
+
+class BuildPersonProviding(CrudCollection):
+    """ """
+
+    __tablename__ = "build_person_providing"
+    __exclude__fields__ = []
+    __language_model__ = BuildPersonProvidingLanguageModel
+    __include__fields__ = []
+
+    build_id = mapped_column(
+        ForeignKey("build.id"), nullable=False, comment="Building ID"
+    )
+    build_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Providing UUID"
+    )
+    people_id: Mapped[int] = mapped_column(ForeignKey("people.id"))
+    people_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="People UUID"
+    )
+    provide_id: Mapped[int] = mapped_column(
+        ForeignKey("api_enum_dropdown.id"), nullable=True
+    )
+    provide_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Providing UUID"
+    )
+    contract_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("companies.id"), nullable=True
+    )
+
+    __table_args__ = (
+        Index(
+            "_build_person_providing_ndx_00",
+            build_id,
+            people_id,
+            provide_id,
+            unique=True,
+        ),
+        {"comment": "People providing services for building"},
+    )

ApiLayers/Schemas/company/company.py

@@ -0,0 +1,581 @@
+from fastapi.exceptions import HTTPException
+from sqlalchemy import (
+    String,
+    Integer,
+    Boolean,
+    ForeignKey,
+    Index,
+    Identity,
+    TIMESTAMP,
+    func,
+)
+from sqlalchemy.orm import mapped_column, relationship, Mapped
+
+from ApiLibrary.extensions.select import SelectAction
+from ApiValidations.Custom.token_objects import EmployeeTokenObject
+from ApiValidations.Request import (
+    InsertCompany,
+    UpdateCompany,
+    MatchCompany2Company,
+)
+from LanguageModels.Database.company.company import (
+    RelationshipDutyCompanyLanguageModel,
+    CompaniesLanguageModel,
+    # CompanyDutiesLanguageModel,
+)
+from Services.PostgresDb import CrudCollection
+
+
+class RelationshipDutyCompany(CrudCollection):
+    """
+    CompanyRelationship class based on declarative_base and CrudCollection via session
+    Company -> Sub Company -> Sub-Sub Company
+
+    if owner_id == parent_id: can manipulate data of any record
+    else: Read-Only
+    duty_id = if relationship_type == base An organization / not operational / no responsible person
+
+    relationship = company_id filter -> Action filter(company_id) relationship_type = Organization
+    relationship = company_id filter -> Action filter(company_id) relationship_type = Commercial
+    """
+
+    __tablename__ = "relationship_duty_company"
+    __exclude__fields__ = []
+    __language_model__ = RelationshipDutyCompanyLanguageModel
+
+    owner_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=False
+    )  # 1
+    duties_id: Mapped[int] = mapped_column(
+        ForeignKey("duties.id"), nullable=False
+    )  # duty -> (n)employee Evyos LTD
+
+    member_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=False
+    )  # 2, 3, 4
+    parent_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=True
+    )  # None
+
+    relationship_type: Mapped[str] = mapped_column(
+        String, nullable=True, server_default="Commercial"
+    )  # Commercial, Organization # Bulk
+    child_count: Mapped[int] = mapped_column(Integer)  # 0
+    show_only: Mapped[bool] = mapped_column(Boolean, server_default="0")
+
+    # related_company: Mapped[List["Companies"]] = relationship(
+    #     "Companies",
+    #     back_populates="related_companies",
+    #     foreign_keys=[related_company_id],
+    # )
+
+    @classmethod
+    def match_company_to_company_commercial(cls, data: MatchCompany2Company, token):
+        from Schemas import (
+            Duties,
+        )
+
+        token_duties_id, token_company_id = token.get("duty_id"), token.get(
+            "company_id"
+        )
+        list_match_company_id = []
+        send_duties = Duties.filter_one(
+            Duties.uu_id == data.duty_uu_id,
+        )
+        send_user_duties = Duties.filter_one(
+            Duties.duties_id == send_duties.id,
+            Duties.company_id == token_duties_id,
+        )
+        if not send_user_duties:
+            raise Exception(
+                "Send Duty is not found in company. Please check duty uuid and try again."
+            )
+
+        for company_uu_id in list(data.match_company_uu_id):
+            company = Companies.filter_one(
+                Companies.uu_id == company_uu_id,
+            )
+            bulk_company = RelationshipDutyCompany.filter_one(
+                RelationshipDutyCompany.owner_id == token_company_id,
+                RelationshipDutyCompany.relationship_type == "Bulk",
+                RelationshipDutyCompany.member_id == company.id,
+            )
+            if not bulk_company:
+                raise Exception(
+                    f"Bulk Company is not found in company. "
+                    f"Please check company uuid {bulk_company.uu_id} and try again."
+                )
+            list_match_company_id.append(bulk_company)
+
+        for match_company_id in list_match_company_id:
+            RelationshipDutyCompany.find_or_create(
+                owner_id=token_company_id,
+                duties_id=send_user_duties.id,
+                member_id=match_company_id.id,
+                parent_id=match_company_id.parent_id,
+                relationship_type="Commercial",
+                show_only=False,
+            )
+
+    @classmethod
+    def match_company_to_company_organization(cls, data: MatchCompany2Company, token):
+        from Schemas import (
+            Duties,
+        )
+
+        token_duties_id, token_company_id = token.get("duty_id"), token.get(
+            "company_id"
+        )
+        list_match_company_id = []
+        send_duties = Duties.filter_one(
+            Duties.uu_id == data.duty_uu_id,
+        )
+        send_user_duties = Duties.filter_one(
+            Duties.duties_id == send_duties.id,
+            Duties.company_id == token_duties_id,
+        )
+        if not send_user_duties:
+            raise Exception(
+                "Send Duty is not found in company. Please check duty uuid and try again."
+            )
+
+        for company_uu_id in list(data.match_company_uu_id):
+            company = Companies.filter_one(
+                Companies.uu_id == company_uu_id,
+            )
+            bulk_company = RelationshipDutyCompany.filter_one(
+                RelationshipDutyCompany.owner_id == token_company_id,
+                RelationshipDutyCompany.relationship_type == "Bulk",
+                RelationshipDutyCompany.member_id == company.id,
+            )
+            if not bulk_company:
+                raise Exception(
+                    f"Bulk Company is not found in company. "
+                    f"Please check company uuid {bulk_company.uu_id} and try again."
+                )
+            list_match_company_id.append(bulk_company)
+
+        for match_company_id in list_match_company_id:
+            Duties.init_a_company_default_duties(
+                company_id=match_company_id.id,
+                company_uu_id=str(match_company_id.uu_id),
+            )
+            RelationshipDutyCompany.find_or_create(
+                owner_id=token_company_id,
+                duties_id=send_user_duties.id,
+                member_id=match_company_id.id,
+                parent_id=match_company_id.parent_id,
+                relationship_type="Organization",
+                show_only=False,
+            )
+
+    __table_args__ = (
+        Index(
+            "_company_relationship_ndx_01",
+            duties_id,
+            owner_id,
+            member_id,
+            relationship_type,
+            unique=True,
+        ),
+        {"comment": "Company Relationship Information"},
+    )
+
+
+class Companies(CrudCollection, SelectAction):
+    """
+    Company class based on declarative_base and CrudCollection via session
+    formal_name = Government register name by offical
+    public_name = Public registered name by User
+    nick_name = Search by nickname, commercial_type = Tüzel veya birey
+    """
+
+    __tablename__ = "companies"
+
+    __exclude__fields__ = ["is_blacklist", "is_commercial"]
+    __access_by__ = []
+    __many__table__ = RelationshipDutyCompany
+    __language_model__ = CompaniesLanguageModel
+    # __explain__ = AbstractCompany()
+
+    formal_name: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Formal Name"
+    )
+    company_type: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Company Type"
+    )
+    commercial_type: Mapped[str] = mapped_column(
+        String, nullable=False, comment="Commercial Type"
+    )
+    tax_no: Mapped[str] = mapped_column(
+        String, index=True, unique=True, nullable=False, comment="Tax No"
+    )
+
+    public_name: Mapped[str] = mapped_column(String, comment="Public Name of a company")
+    company_tag: Mapped[str] = mapped_column(String, comment="Company Tag")
+    default_lang_type: Mapped[str] = mapped_column(String, server_default="TR")
+    default_money_type: Mapped[str] = mapped_column(String, server_default="TL")
+    is_commercial: Mapped[bool] = mapped_column(Boolean, server_default="False")
+    is_blacklist: Mapped[bool] = mapped_column(Boolean, server_default="False")
+    parent_id = mapped_column(Integer, nullable=True)
+    workplace_no: Mapped[str] = mapped_column(String, nullable=True)
+
+    official_address_id: Mapped[int] = mapped_column(
+        ForeignKey("addresses.id"), nullable=True
+    )
+    official_address_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Official Address UUID"
+    )
+    top_responsible_company_id: Mapped[int] = mapped_column(
+        ForeignKey("companies.id"), nullable=True
+    )
+    top_responsible_company_uu_id: Mapped[str] = mapped_column(
+        String, nullable=True, comment="Top Responsible Company UUID"
+    )
+
+    # buildings: Mapped[List["Build"]] = relationship(
+    #     "Build",
+    #     back_populates="companies",
+    #     foreign_keys="Build.company_id",
+    # )
+
+    __table_args__ = (
+        Index("_company_ndx_01", tax_no, unique=True),
+        Index("_company_ndx_02", formal_name, public_name),
+        {"comment": "Company Information"},
+    )
+
+    @classmethod
+    def create_action(cls, data: InsertCompany, token: EmployeeTokenObject):
+        from Schemas import Addresses, Duties
+
+        data_dict = data.model_dump()
+        if cls.filter_one(cls.tax_no == str(data.tax_no).strip(), system=True).data:
+            raise HTTPException(
+                status_code=400,
+                detail="Company already exists. Please ask supervisor to make company visible for your duty.",
+            )
+
+        official_address = Addresses.filter_one(
+            Addresses.uu_id == data.official_address_uu_id,
+        ).data
+        # if not official_address:
+        #     raise HTTPException(
+        #         status_code=400,
+        #         detail="Official address is not found. Please check address uuid and try again.",
+        #     )
+
+        bulk_duties = Duties.get_bulk_duties_of_a_company(
+            company_id=token.selected_company.company_id
+        )
+
+        if official_address:
+            data_dict["official_address_id"] = official_address.id
+            data_dict["official_address_uu_id"] = str(official_address.uu_id)
+
+        data_dict["parent_id"] = token.selected_company.company_id
+        data_dict["top_responsible_company_id"] = token.selected_company.company_id
+        data_dict["top_responsible_company_uu_id"] = (
+            token.selected_company.company_uu_id
+        )
+        company_created = cls.find_or_create(**data_dict)
+        company_created.save_and_confirm()
+        company_relationship_created = RelationshipDutyCompany.find_or_create(
+            owner_id=token.selected_company.company_id,
+            duties_id=bulk_duties.id,
+            member_id=company_created.id,
+            parent_id=company_created.parent_id,
+            child_count=0,
+            relationship_type="Bulk",
+            show_only=False,
+        )
+        company_relationship_created.save_and_confirm()
+        return company_created
+
+    @classmethod
+    def update_action(cls, data: UpdateCompany, token):
+        from Schemas import (
+            Addresses,
+        )
+
+        data_dict = data.excluded_dump()
+        duty_id = token.get("duty_id")
+        company_id = token.get("company_id")
+        if data.official_address_uu_id:
+            official_address = Addresses.filter_one(
+                Addresses.uu_id == data.official_address_uu_id,
+                *Addresses.valid_record_args(Addresses),
+            ).data
+            data_dict["official_address_id"] = official_address.id
+        del data_dict["official_address_uu_id"], data_dict["company_uu_id"]
+        company_to_update = cls.select_action(
+            duty_id_list=[duty_id],
+            filter_expr=[
+                cls.uu_id == data.company_uu_id,
+                RelationshipDutyCompany.parent_id == company_id,
+            ],
+        )
+        return company_to_update.update(**data_dict)
+
+    # parent_id = mapped_column(ForeignKey("companies.id"))
+    # if data.parent_uu_id:
+    #     company = Companies.find_one(uu_id=data.parent_uu_id)
+    #     data_dict["parent_id"] = company.id
+    # def is_access_valid(self, endpoint_ext: str):
+    #     try:
+    #         if (
+    #             not arrow.get(self.stop_date)
+    #             > arrow.utcnow()
+    #             > arrow.get(self.start_date)
+    #         ):
+    #             message = f"Kullanıcı yetkileri süresi dolmuştur. {self.endpoint_name} için supervisor ile görüşünüz."
+    #             SystemLogs.create_log(
+    #                 log_type="ERROR",
+    #                 log_code="ACCESS_EXPIRED",
+    #                 log_action=self.__tablename__,
+    #                 log_message=message,
+    #             )
+    #             return False
+    #     except Exception as e:
+    #         SystemLogs.create_log(
+    #             log_type="ERROR",
+    #             log_code="ACCESS_EXPIRED",
+    #             log_action=self.__tablename__,
+    #             log_message=e,
+    #         )
+    #         return False
+    #
+    #     access_dict = {
+    #         "LIST": self.access_read,
+    #         "INSERT": self.access_write,
+    #         "UPDATE": self.access_update,
+    #         "DELETE": self.access_delete,
+    #         "ACTIVE": self.access_update,
+    #         "PRINT": self.report_print,
+    #         "EXPORT": self.report_export,
+    #     }
+    #     return access_dict.get(endpoint_ext.upper(), False)
+
+    # official_address: Mapped[List["Address"]] = relationship(
+    #     "Address",
+    #     back_populates="official_companies",
+    #     foreign_keys=[official_address_id],
+    # )
+    #
+    # emails: Mapped[List["UsersEmails"]] = relationship(
+    #     "UsersEmails", back_populates="companies", foreign_keys="UsersEmails.company_id"
+    # )
+    # phones: Mapped[List["UsersPhones"]] = relationship(
+    #     "UsersPhones", back_populates="company", foreign_keys="UsersPhones.company_id"
+    # )
+    # buildings: Mapped[List["Build"]] = relationship(
+    #     "Build",
+    #     back_populates="companies",
+    #     foreign_keys="Build.company_id",
+    # )
+    # response_buildings: Mapped[List["Build"]] = relationship(
+    #     "Build",
+    #     back_populates="response_companies",
+    #     foreign_keys="Build.response_company_id",
+    # )
+    # departments: Mapped[List["CompanyDepartments"]] = relationship(
+    #     "CompanyDepartments",
+    #     back_populates="company",
+    #     foreign_keys="CompanyDepartments.company_id",
+    # )
+    # budget_records: Mapped[List["CompanyBudgetRecords"]] = relationship(
+    #     "CompanyBudgetRecords",
+    #     back_populates="companies",
+    #     foreign_keys="CompanyBudgetRecords.company_id",
+    # )
+    # send_budget_records: Mapped[List["CompanyBudgetRecords"]] = relationship(
+    #     "CompanyBudgetRecords",
+    #     back_populates="send_companies",
+    #     foreign_keys="CompanyBudgetRecords.send_company_id",
+    # )
+    # decision_books: Mapped[List["BuildDecisionBook"]] = relationship(
+    #     "BuildDecisionBook",
+    #     back_populates="companies",
+    #     foreign_keys="BuildDecisionBook.resp_company_id",
+    # )
+    # decision_book_projects: Mapped[List["BuildDecisionBookProjects"]] = relationship(
+    #     "BuildDecisionBookProjects",
+    #     back_populates="companies",
+    #     foreign_keys="BuildDecisionBookProjects.resp_company_id",
+    # )
+    # decision_book_legal: Mapped["BuildDecisionBookLegal"] = relationship(
+    #     "BuildDecisionBookLegal",
+    #     back_populates="attorney_companies",
+    #     foreign_keys="BuildDecisionBookLegal.resp_attorney_company",
+    # )
+    #
+    # company_account_books: Mapped["AccountBooks"] = relationship(
+    #     "AccountBooks",
+    #     back_populates="company",
+    #     foreign_keys="AccountBooks.company_id",
+    # )
+    # branch_account_books: Mapped["AccountBooks"] = relationship(
+    #     "AccountBooks",
+    #     back_populates="branch",
+    #     foreign_keys="AccountBooks.branch_id",
+    # )
+    # account_codes: Mapped["AccountCodes"] = relationship(
+    #     "AccountCodes", back_populates="company", foreign_keys="AccountCodes.company_id"
+    # )
+    # search_iban_description: Mapped["BuildIbanDescription"] = relationship(
+    #     "BuildIbanDescription",
+    #     back_populates="company",
+    #     foreign_keys="BuildIbanDescription.company_id",
+    # )
+    # related_companies: Mapped[List["CompanyRelationship"]] = relationship(
+    #     "CompanyRelationship",
+    #     back_populates="related_company",
+    #     foreign_keys="CompanyRelationship.related_company_id",
+    # )
+
+
+#
+# class AbstractCompany:
+#     """
+#     Abstract and explanation of Company class for end-user guide
+#     """
+#
+#     formal_name = Explanation(
+#         explanation="Devletin resmi kayıtlarında bulunan şirket ünvanıdır.",
+#         usage="Devletin resmi kayıtlarında bulunan şirket adı istendiğinde kullanılır.",
+#         alias="Resmi Ünvan",
+#         example=["X Şirketi LTD", "Y Şirketi A.Ş."],
+#     )
+#     company_type = Explanation(
+#         explanation="Şirketin türüdür.",
+#         usage="Şirketin türü istendiğinde kullanılır.",
+#         alias="Şirket Türü",
+#         example=[
+#             "Şahıs",
+#             "Limited",
+#             "Anonim",
+#             "Kolektif",
+#             "Komandit",
+#             "Kooperatif",
+#             "Serbest Meslek",
+#             "Adi Ortaklık",
+#         ],
+#     )
+#     commercial_type = Explanation(
+#         explanation="Şirketin ticari türüdür.",
+#         usage="Şirketin ticari türü istendiğinde kullanılır.",
+#         alias="Ticari Tür",
+#         example=["Tüzel", "Birey"],
+#     )
+#     tax_no = Explanation(
+#         explanation="Şirketin vergi numarasıdır.",
+#         usage="Şirketin vergi numarası istendiğinde kullanılır.",
+#         alias="Vergi No",
+#         example=["1234567890"],
+#     )
+#     public_name = Explanation(
+#         explanation="Şirketin kamuoyunda bilinen adıdır.",
+#         usage="Şirketin kamuoyunda bilinen adı istendiğinde kullanılır.",
+#         alias="Piyasada Bilinen Adı",
+#         example=["X Şirketi", "Y Şirketi"],
+#     )
+#     company_tag = Explanation(
+#         explanation="Şirketin takma adı veya etiketidir.",
+#         usage="Şirketin yöneticisin karar verdiği takma adı veya etiketi istendiğinde kullanılır.",
+#         alias="Şirket Etiketi veya Takma Adı",
+#         example=["X", "Y"],
+#     )
+#     default_lang_type = Explanation(
+#         explanation="Şirketin varsayılan dil türüdür.",
+#         usage="Şirketin varsayılan dil türü istendiğinde kullanılır.",
+#         alias="Şirketin Dil Türü",
+#         example=["TR", "EN"],
+#     )
+#     default_money_type = Explanation(
+#         explanation="Şirketin varsayılan para birimi türüdür.",
+#         usage="Şirketin varsayılan para birimi türü istendiğinde kullanılır.",
+#         alias="Şirketin Para Birimi Türü",
+#         example=["TL", "USD", "EUR"],
+#     )
+#     is_commercial = Explanation(
+#         explanation="Şirketin ticari olup olmadığını belirtir.",
+#         usage="Şirketin ticari olup olmadığını applikasyonun anlaması için kullanılır.",
+#         condition=lambda commercial_type: True if commercial_type == "Şahıs" else False,
+#         alias="Şirket Ticari mi?",
+#     )
+#     is_blacklist = Explanation(
+#         explanation="Şirketin kara listeye alınıp alınmadığını belirtir.",
+#         usage="Şirketin kara listeye alınıp alınmadığını applikasyonun anlaması için kullanılır.",
+#         alias="Kara Listeye alınsın mı?",
+#         example=[True, False],
+#     )
+#     parent_id = Explanation(
+#         explanation="Şirketin sorumlu olduğu şirketin ID'sidir.",
+#         usage="Şirketin sorumlu olduğu şirketin ID'si istendiğinde kullanılır.",
+#         alias="Sorumlu Şirket",
+#         example=[
+#             "Bir şirketin sorumlu şirketi hangisi olduğunu bulmak için kullanılır.",
+#         ],
+#     )
+#     workplace_no = Explanation(
+#         explanation="Şirketin iş yeri numarasıdır.",
+#         usage="Şirketin iş yeri numarası istendiğinde kullanılır.",
+#         alias="İş Yeri No",
+#         example=["1234567890"],
+#     )
+#     official_address_id = Explanation(
+#         explanation="Şirketin resmi adresidi.",
+#         usage="Şirketin resmi adresinin ne olduğunu bulmak için kullanılır.",
+#         alias="Resmi Adres",
+#         example=[
+#             "Bu şirketin adresi nedir sorusuna cevap vermek için kullanılır.",
+#         ],
+#     )
+#     top_responsible_company_id = Explanation(
+#         explanation="Şirketin en üst sorumlu şirketin ID'sidir.",
+#         usage="Şirketin en üst sorumlu şirketin hangisi olduğunu bulmak için kullanılır.",
+#         alias="Ana Yetkili Şirket",
+#         example=[
+#             "Bölge veya ülke genelinde en üst sorumlu şirketin hangisi olduğunu belirtmek için kullanılır.",
+#         ],
+#     )
+#     buildings = Explanation(
+#         explanation="Şirketin sahip olduğu binaların listesidir.",
+#         usage="Şirketin sahip olduğu binaların listesini bulmak için kullanılır.",
+#         alias="Sorumlu olduğu binalar Binalar",
+#         example=[
+#             "Şirketin sahip olduğu binaların listesini bulmak için kullanılır.",
+#         ],
+#     )
+#
+#     def wag_create_company(self):
+#         """
+#         Er kişiye wag_create_company fonksiyonu = fieldları manipule edebilir?
+#         78 ile oluşturulan bir user için wag_create_company fonksiyonu = fieldları manipule edebilir?
+#         """
+#         return {
+#             "commercial_type": self.commercial_type,
+#             "formal_name": self.formal_name,
+#             "public_name": self.public_name,
+#             "company_type": self.company_type,
+#             "tax_no": self.tax_no,
+#             "workplace_no": self.workplace_no,
+#             "company_tag": self.company_tag,
+#             "default_lang_type": self.default_lang_type,
+#             "default_money_type": self.default_money_type,
+#             "official_address_id": self.official_address_id,
+#         }
+#
+#     def wag_update_company(self):
+#         return {
+#             "commercial_type": self.commercial_type,
+#             "formal_name": self.formal_name,
+#             "public_name": self.public_name,
+#             "company_type": self.company_type,
+#             "tax_no": self.tax_no,
+#             "workplace_no": self.workplace_no,
+#             "company_tag": self.company_tag,
+#             "default_lang_type": self.default_lang_type,
+#             "default_money_type": self.default_money_type,
+#             "official_address_id": self.official_address_id,
+#         }