evyos-center-server/wag-managment-api-service-version-4
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated docs

Browse Source
This commit is contained in:
berkay
2025-01-22 21:46:11 +03:00
parent 87e5f5ab06
commit 1ba2694a9d
50 changed files with 3342 additions and 401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApiEvents/ValidationServiceApi/__init__.py
View File

@@ -3,4 +3,3 @@
from .route_configs import get_route_configs
__all__ = ["get_route_configs"]

11
ApiEvents/ValidationServiceApi/events/available/endpoints.py
View File

@@ -19,9 +19,7 @@ if TYPE_CHECKING:
prefix = "/available"
async def check_endpoints_available(
request: "Request"
) -> Dict[str, Any]:
async def check_endpoints_available(request: "Request") -> Dict[str, Any]:
"""
Check if endpoints are available.
"""
@@ -52,7 +50,7 @@ async def check_endpoint_available(
print("data", data)
data_dict = data.data
endpoint_asked = data_dict.get("endpoint", None)
if not endpoint_asked:
raise HTTPExceptionApi(
error_code="",
@@ -81,10 +79,7 @@ async def check_endpoint_available(
loc=get_line_number_for_error(),
sys_msg="Endpoint not found",
)
return {
"endpoint": endpoint_asked,
"status": "OK"
}
return {"endpoint": endpoint_asked, "status": "OK"}
AVAILABLE_CONFIG = RouteFactoryConfig(

28
ApiEvents/ValidationServiceApi/events/validation/endpoints.py
View File

@@ -22,13 +22,17 @@ prefix = "/validation"
@TokenEventMiddleware.validation_required
async def validations_validations_select(request: Request, data: EndpointBaseRequestModel) -> Dict[str, Any]:
async def validations_validations_select(
request: Request, data: EndpointBaseRequestModel
) -> Dict[str, Any]:
"""
Select validations.
"""
wrapped_context = getattr(validations_validations_select, "__wrapped__", None)
auth_context = getattr(wrapped_context, "auth", None)
validation_code = getattr(validations_validations_select, "validation_code", {"validation_code": None})
validation_code = getattr(
validations_validations_select, "validation_code", {"validation_code": None}
)
if not validation_code:
raise HTTPExceptionApi(
error_code="",
@@ -41,12 +45,16 @@ async def validations_validations_select(request: Request, data: EndpointBaseReq
reachable_event_code=validation_code.get("reachable_event_code", None),
lang=getattr(auth_context, "lang", None),
)
validations_both = ValidationsBoth.retrieve_both_validations_and_headers(validations_pydantic)
return {"status": "OK", "validation_code": validation_code, **validations_both }
validations_both = ValidationsBoth.retrieve_both_validations_and_headers(
validations_pydantic
)
return {"status": "OK", "validation_code": validation_code, **validations_both}
@TokenEventMiddleware.validation_required
async def validations_headers_select(request: Request, data: EndpointBaseRequestModel) -> Dict[str, Any]:
async def validations_headers_select(
request: Request, data: EndpointBaseRequestModel
) -> Dict[str, Any]:
"""
Select headers.
"""
@@ -57,7 +65,9 @@ async def validations_headers_select(request: Request, data: EndpointBaseRequest
@TokenEventMiddleware.validation_required
async def validations_validations_and_headers_select(request: Request, data: EndpointBaseRequestModel) -> Dict[str, Any]:
async def validations_validations_and_headers_select(
request: Request, data: EndpointBaseRequestModel
) -> Dict[str, Any]:
"""
Select validations and headers.
"""
@@ -67,7 +77,7 @@ async def validations_validations_and_headers_select(request: Request, data: End
}
VALIDATION_CONFIG_MAIN =RouteFactoryConfig(
VALIDATION_CONFIG_MAIN = RouteFactoryConfig(
name="validations",
prefix=prefix,
tags=["Validation"],
@@ -113,4 +123,6 @@ VALIDATION_CONFIG_MAIN =RouteFactoryConfig(
)
VALIDATION_CONFIG = VALIDATION_CONFIG_MAIN.as_dict()
VALIDATION_ENDPOINTS = [endpoint.url_of_endpoint for endpoint in VALIDATION_CONFIG_MAIN.endpoints]
VALIDATION_ENDPOINTS = [
endpoint.url_of_endpoint for endpoint in VALIDATION_CONFIG_MAIN.endpoints
]

1
ApiEvents/ValidationServiceApi/events/validation/models.py
View File

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
ListOptions,
)
class ValidationsPydantic(BaseModel):
class_model: str
reachable_event_code: str

93
ApiEvents/ValidationServiceApi/events/validation/validation.py
View File

@@ -2,26 +2,16 @@
Validation request models.
"""
from typing import TYPE_CHECKING, Dict, Any, Literal, Optional, TypedDict, Union
from pydantic import BaseModel, Field, model_validator, RootModel, ConfigDict
from typing import TYPE_CHECKING, Dict, Any
from ApiEvents.abstract_class import MethodToEvent
from ApiLibrary.common.line_number import get_line_number_for_error
from ApiValidations.Custom.validation_response import ValidationModel, ValidationParser
from ApiEvents.abstract_class import MethodToEvent
from ApiEvents.base_request_model import BaseRequestModel, DictRequestModel
from ApiValidations.Custom.token_objects import EmployeeTokenObject, OccupantTokenObject
from ApiValidations.Request.base_validations import ListOptions
from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
from .models import ValidationsPydantic
if TYPE_CHECKING:
from fastapi import Request
class AllModelsImport:
@classmethod
@@ -46,18 +36,14 @@ class AllModelsImport:
AddressCreateEventMethod=AddressCreateEventMethod,
AddressSearchEventMethod=AddressSearchEventMethod,
)
class ValidationsBoth(MethodToEvent):
@classmethod
def retrieve_both_validations_and_headers(
cls, event: ValidationsPydantic
) -> Dict[str, Any]:
def retrieve_both_validations_and_headers(cls, event: ValidationsPydantic) -> Dict[str, Any]:
EVENT_MODELS = AllModelsImport.import_all_models()
return_single_model = EVENT_MODELS.get(event.class_model, None)
print("return_single_model", return_single_model, type(return_single_model))
# event_class_validation = getattr(return_single_model, "__event_validation__", None)
if not return_single_model:
raise HTTPExceptionApi(
@@ -67,11 +53,17 @@ class ValidationsBoth(MethodToEvent):
sys_msg="Validation code not found",
)
response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
language_model_all = return_single_model.retrieve_language_parameters(function_code=event.reachable_event_code, language=event.lang)
language_model_all = return_single_model.retrieve_language_parameters(
function_code=event.reachable_event_code, language=event.lang
)
language_model = language_model_all.get("language_model", None)
language_models = language_model_all.get("language_models", None)
validation = ValidationModel(response_model, language_model, language_models)
"""
Headers: Headers which is merged with response model && language models of event
Validation: Validation of event which is merged with response model && language models of event
"""
return {
"headers": validation.headers,
"validation": validation.validation,
@@ -82,16 +74,65 @@ class ValidationsBoth(MethodToEvent):
class ValidationsValidations(MethodToEvent):
@classmethod
def retrieve_validations(
cls, event: ValidationsPydantic
) -> Dict[str, Any]:
return {}
def retrieve_validations(cls, event: ValidationsPydantic) -> Dict[str, Any]:
EVENT_MODELS = AllModelsImport.import_all_models()
return_single_model = EVENT_MODELS.get(event.class_model, None)
# event_class_validation = getattr(return_single_model, "__event_validation__", None)
if not return_single_model:
raise HTTPExceptionApi(
error_code="",
lang="en",
loc=get_line_number_for_error(),
sys_msg="Validation code not found",
)
response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
language_model_all = return_single_model.retrieve_language_parameters(
function_code=event.reachable_event_code, language=event.lang
)
language_model = language_model_all.get("language_model", None)
language_models = language_model_all.get("language_models", None)
validation = ValidationModel(response_model, language_model, language_models)
"""
Headers: Headers which is merged with response model && language models of event
Validation: Validation of event which is merged with response model && language models of event
"""
return {
"validation": validation.validation,
# "headers": validation.headers,
# "language_models": language_model_all,
}
class ValidationsHeaders(MethodToEvent):
@classmethod
def retrieve_headers(
cls, event: ValidationsPydantic
) -> Dict[str, Any]:
return {}
def retrieve_headers(cls, event: ValidationsPydantic
) -> Dict[str, Any]:
EVENT_MODELS = AllModelsImport.import_all_models()
return_single_model = EVENT_MODELS.get(event.class_model, None)
# event_class_validation = getattr(return_single_model, "__event_validation__", None)
if not return_single_model:
raise HTTPExceptionApi(
error_code="",
lang="en",
loc=get_line_number_for_error(),
sys_msg="Validation code not found",
)
response_model = return_single_model.retrieve_event_response_model(event.reachable_event_code)
language_model_all = return_single_model.retrieve_language_parameters(
function_code=event.reachable_event_code, language=event.lang
)
language_model = language_model_all.get("language_model", None)
language_models = language_model_all.get("language_models", None)
validation = ValidationModel(response_model, language_model, language_models)
"""
Headers: Headers which is merged with response model && language models of event
Validation: Validation of event which is merged with response model && language models of event
"""
return {
"headers": validation.headers,
# "validation": validation.validation,
# "language_models": language_model_all,
}

158
ApiEvents/ValidationServiceApi/schema_converter.py Normal file
View File

@@ -0,0 +1,158 @@
from typing import Dict, Any, Type, get_type_hints, get_args, get_origin
from pydantic import BaseModel, Field, EmailStr
from enum import Enum
import inspect
from fastapi import APIRouter
from datetime import datetime
class SchemaConverter:
"""Converts Pydantic models to Zod schema definitions"""
TYPE_MAPPINGS = {
str: "string",
int: "number",
float: "number",
bool: "boolean",
list: "array",
dict: "object",
datetime: "date",
EmailStr: "string.email()",
}
def __init__(self):
self.processed_models = set()
def convert_model(self, model: Type[BaseModel]) -> Dict[str, Any]:
"""Convert a Pydantic model to a Zod schema definition"""
if model.__name__ in self.processed_models:
return {"$ref": model.__name__}
self.processed_models.add(model.__name__)
schema = {
"name": model.__name__,
"type": "object",
"fields": {},
"validations": {}
}
for field_name, field in model.__fields__.items():
field_info = self._convert_field(field)
schema["fields"][field_name] = field_info
# Get validations from field
validations = self._get_field_validations(field)
if validations:
schema["validations"][field_name] = validations
return schema
def _convert_field(self, field) -> Dict[str, Any]:
"""Convert a Pydantic field to Zod field definition"""
field_type = field.outer_type_
origin = get_origin(field_type)
if origin is not None:
# Handle generic types (List, Dict, etc)
args = get_args(field_type)
if origin == list:
return {
"type": "array",
"items": self._get_type_name(args[0])
}
elif origin == dict:
return {
"type": "object",
"additionalProperties": self._get_type_name(args[1])
}
if inspect.isclass(field_type) and issubclass(field_type, BaseModel):
# Nested model
return self.convert_model(field_type)
if inspect.isclass(field_type) and issubclass(field_type, Enum):
# Enum type
return {
"type": "enum",
"values": [e.value for e in field_type]
}
return {
"type": self._get_type_name(field_type)
}
def _get_field_validations(self, field) -> Dict[str, Any]:
"""Extract validations from field"""
validations = {}
if field.field_info.min_length is not None:
validations["min_length"] = field.field_info.min_length
if field.field_info.max_length is not None:
validations["max_length"] = field.field_info.max_length
if field.field_info.regex is not None:
validations["pattern"] = field.field_info.regex.pattern
if field.field_info.gt is not None:
validations["gt"] = field.field_info.gt
if field.field_info.lt is not None:
validations["lt"] = field.field_info.lt
return validations
def _get_type_name(self, type_: Type) -> str:
"""Get Zod type name for Python type"""
return self.TYPE_MAPPINGS.get(type_, "any")
# FastAPI router
router = APIRouter(prefix="/api/validation", tags=["Validation"])
converter = SchemaConverter()
@router.get("/schema/{model_name}")
async def get_schema(model_name: str) -> Dict[str, Any]:
"""Get Zod schema for a specific model"""
# This is just an example - you'd need to implement model lookup
models = {
"User": UserModel,
"Product": ProductModel,
# Add your models here
}
if model_name not in models:
raise ValueError(f"Model {model_name} not found")
return converter.convert_model(models[model_name])
# Example usage:
"""
class UserModel(BaseModel):
email: EmailStr
username: str = Field(min_length=3, max_length=50)
age: int = Field(gt=0, lt=150)
is_active: bool = True
roles: List[str] = []
# GET /api/validation/schema/User would return:
{
"name": "User",
"type": "object",
"fields": {
"email": {"type": "string.email()"},
"username": {"type": "string"},
"age": {"type": "number"},
"is_active": {"type": "boolean"},
"roles": {
"type": "array",
"items": "string"
}
},
"validations": {
"username": {
"min_length": 3,
"max_length": 50
},
"age": {
"gt": 0,
"lt": 150
}
}
}
"""