validation requester updated

api_events/events/abstract_class.py

@@ -43,6 +43,7 @@ class MethodToEvent(ABC, ActionsSchemaFactory):
     event_category: str = ""
 
     __event_keys__: dict = {}
+    __event_validation__: dict = {}
 
     @classmethod
     def call_event_method(cls, method_uu_id: str, *args, **kwargs):

api_events/events/account/account_records.py

@@ -29,6 +29,10 @@ class AccountRecordsListEventMethods(MethodToEvent):
         "7192c2aa-5352-4e36-98b3-dafb7d036a3d": "account_records_list",
         "208e6273-17ef-44f0-814a-8098f816b63a": "account_records_list_flt_res",
     }
+    __event_validation__ = {
+        "7192c2aa-5352-4e36-98b3-dafb7d036a3d": ListOptions,
+        "208e6273-17ef-44f0-814a-8098f816b63a": ListOptions,
+    }
 
     @classmethod
     def account_records_list(
@@ -189,6 +193,9 @@ class AccountRecordsCreateEventMethods(MethodToEvent):
     __event_keys__ = {
         "31f4f32f-0cd4-4995-8a6a-f9f56335848a": "account_records_create",
     }
+    __event_validation__ = {
+        "31f4f32f-0cd4-4995-8a6a-f9f56335848a": InsertAccountRecord,
+    }
 
     @classmethod
     def account_records_create(
@@ -275,6 +282,9 @@ class AccountRecordsUpdateEventMethods(MethodToEvent):
     __event_keys__ = {
         "ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": "account_records_update",
     }
+    __event_validation__ = {
+        "ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": UpdateAccountRecord,
+    }
 
     @classmethod
     def build_area_update(
@@ -304,6 +314,9 @@ class AccountRecordsPatchEventMethods(MethodToEvent):
     __event_keys__ = {
         "34c38937-42a2-45f1-b2ef-a23978650aee": "account_records_patch",
     }
+    __event_validation__ = {
+        "34c38937-42a2-45f1-b2ef-a23978650aee": None,
+    }
 
     @classmethod
     def build_area_patch(

api_events/events/building/building_living_spaces.py

@@ -284,13 +284,9 @@ class BuildingLivingSpacesUpdateEventMethods(MethodToEvent):
 BuildingLivingSpacesListEventMethod = BuildingLivingSpacesListEventMethods(
     action=ActionsSchema(endpoint="/building/living_space/list")
 )
-BuildingLivingSpacesCreateEventMethod = (
+BuildingLivingSpacesCreateEventMethod = BuildingLivingSpacesCreateEventMethods(
-    BuildingLivingSpacesCreateEventMethods(
+    action=ActionsSchema(endpoint="/building/living_space/create")
-        action=ActionsSchema(endpoint="/building/living_space/create")
-    )
 )
-BuildingLivingSpacesUpdateEventMethod = (
+BuildingLivingSpacesUpdateEventMethod = BuildingLivingSpacesUpdateEventMethods(
-    BuildingLivingSpacesUpdateEventMethods(
+    action=ActionsSchema(endpoint="/building/living_space/update")
-        action=ActionsSchema(endpoint="/building/living_space/update")
-    )
 )

api_events/events/events/events_bind_modules.py

@@ -32,11 +32,10 @@ class ModulesBindOccupantEventMethods(MethodToEvent):
     ):
 
         living_space = BuildLivingSpace.filter_one(
-            BuildLivingSpace.id == build_living_space_id,
+            BuildLivingSpace.id == build_living_space_id, system=True
-            system=True
         ).data
         modules = Modules.filter_all(Modules.is_default_module == True).data
-        print('living_space', living_space, 'modules', modules)
+        print("living_space", living_space, "modules", modules)
         if not living_space or not modules:
             print(f"Giving living Space or Modules: Default not found")
             return
@@ -113,7 +112,7 @@ class ModulesBindEmployeeEventMethods(MethodToEvent):
             Employees.id == employee_id,
         ).data
         modules = Modules.filter_all(Modules.is_default_module == True).data
-        print('living_space', employee, 'modules', modules)
+        print("living_space", employee, "modules", modules)
         if not employee or not modules:
             print(f"Giving living Space or Modules: Default not found")
             return

api_services/redis/auth_actions/auth.py

@@ -175,23 +175,6 @@ def save_access_token_to_redis(
                     company_address=company_address,
                 )
             )
-    print(dict(
-        access_token=access_token,
-        model_object=EmployeeTokenObject(
-            domain=domain,
-            user_type=UserType.employee.value,
-            user_uu_id=str(found_user.uu_id),
-            credentials=found_user.credentials(),
-            user_id=found_user.id,
-            person_id=found_user.person_id,
-            person_uu_id=str(found_user.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,
-        ),
-    ))
     save_object_to_redis(
         access_token=access_token,
         model_object=EmployeeTokenObject(

api_validations/validations_request/__init__.py

@@ -1,9 +1,12 @@
 from .core_request_validations import (
     ListOptions,
+    EndpointValidation,
     PydanticBaseModel,
     PatchRecord,
     EndpointPydantic,
     BaseModelRegular,
+    PydanticBaseModelValidation,
+    CrudRecordValidation,
 )
 from .address import (
     InsertAddress,
@@ -142,6 +145,9 @@ from .modules import (
 
 __all__ = [
     "ListOptions",
+    "EndpointValidation",
+    "PydanticBaseModelValidation",
+    "CrudRecordValidation",
     "PydanticBaseModel",
     "PatchRecord",
     "EndpointPydantic",

api_validations/validations_request/account_records.py

@@ -6,7 +6,85 @@ from api_validations.validations_request import (
 from typing import Optional
 
 
-class InsertAccountRecord(BaseModelRegular):
+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
@@ -45,7 +123,8 @@ class InsertAccountRecord(BaseModelRegular):
     build_decision_book_uu_id: Optional[str] = None
 
 
-class UpdateAccountRecord(BaseModelRegular):
+class UpdateAccountRecord(PydanticBaseModel, AccountValidation):
+
     iban: Optional[str] = None
     bank_date: Optional[str] = None
     currency_value: Optional[float] = None

api_validations/validations_request/address.py

@@ -6,22 +6,65 @@ from api_validations.validations_request import (
 from typing import Optional
 
 
-class InsertPostCode(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):
+class UpdatePostCode(PydanticBaseModel, PostCodeValidation):
     street_uu_id: Optional[str] = None
     post_code: Optional[str] = None
 
 
-class SearchAddress(PydanticBaseModel):
+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 InsertStreet(PydanticBaseModel):
+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
@@ -32,7 +75,32 @@ class InsertStreet(PydanticBaseModel):
     address_geographic_uu_id: Optional[str] = None
 
 
-class InsertAddress(BaseModelRegular):
+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
@@ -47,13 +115,16 @@ class InsertAddress(BaseModelRegular):
     longitude: Optional[float] = None
 
 
-class UpdateAddress(PydanticBaseModel):
+class UpdateAddress(PydanticBaseModel, AddressValidation):
-    country_code: Optional[str] = None
+    post_code_uu_id: Optional[str] = None
-    city: Optional[str] = None
+
-    district: Optional[str] = None
+    comment_address: Optional[str] = None
-    b_state: Optional[str] = None
+    letter_address: Optional[str] = None
-    neighborhood: Optional[str] = None
+
-    street: Optional[str] = None
+    build_number: Optional[str] = None
-    postcode: 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

api_validations/validations_request/application.py

@@ -1,22 +1,69 @@
 from api_validations.core_validations 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

api_validations/validations_request/area.py

@@ -6,7 +6,32 @@ from api_validations.validations_request import (
 )
 
 
-class InsertBuildArea(BaseModelRegular):
+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
@@ -18,7 +43,8 @@ class InsertBuildArea(BaseModelRegular):
     size: Optional[int] = None
 
 
-class UpdateBuildArea(PydanticBaseModel):
+class UpdateBuildArea(PydanticBaseModel, BuildAreaValidation):
+
     area_name: Optional[str] = None
     area_code: Optional[str] = None
     area_type: Optional[str] = None
@@ -29,12 +55,23 @@ class UpdateBuildArea(PydanticBaseModel):
     size: Optional[int] = None
 
 
-class InsertBuildSites(BaseModelRegular):
+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):
+class UpdateBuildSites(PydanticBaseModel, BuildSites):
+
     site_name: Optional[str] = None
     site_no: Optional[str] = None

api_validations/validations_request/authentication.py

@@ -7,42 +7,102 @@ from typing import Optional
 from pydantic import BaseModel
 
 
-class ChangePassword(BaseModelRegular):
+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
     new_password: str
 
 
-class CreatePassword(BaseModelRegular):
+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
     password: str
     re_password: str
 
 
-class OccupantSelection(BaseModel):
+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):
     occupant_uu_id: str
     build_part_uu_id: str
 
 
-class EmployeeSelection(BaseModel):
+class EmployeeSelectionValidation:
+
+    tr = {"company_uu_id": "Şirket UU ID"}
+    en = {"company_uu_id": "Company UU ID"}
+
+
+class EmployeeSelection(BaseModel, EmployeeSelectionValidation):
     company_uu_id: str
 
 
-class Login(BaseModelRegular):
+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
     access_key: str
     password: str
     remember_me: Optional[bool] = False
 
 
-class Logout(BaseModelRegular):
+class LogoutValidation:
+    tr = {"domain": "Domain"}
+    en = {"domain": "Domain"}
+
+
+class Logout(BaseModelRegular, LogoutValidation):
     domain: str
 
 
-class Remember(BaseModelRegular):
+class RememberValidation:
+    tr = {"domain": "Domain", "refresh_token": "Yenileme Anahtarı"}
+    en = {"domain": "Domain", "refresh_token": "Refresh Token"}
+
+
+class Remember(BaseModelRegular, RememberValidation):
     domain: str
     refresh_token: str
 
 
-class Forgot(BaseModelRegular):
+class ForgotValidation:
+    tr = {"domain": "Domain", "access_key": "Erişim Anahtarı"}
+    en = {"domain": "Domain", "access_key": "Access Key"}
+
+
+class Forgot(BaseModelRegular, ForgotValidation):
     domain: str
     access_key: str

api_validations/validations_request/build_living_space.py

@@ -2,11 +2,44 @@ from typing import Optional
 from api_validations.core_validations import BaseModelRegular
 from api_validations.validations_request import (
     PydanticBaseModel,
+    PydanticBaseModelValidation,
     ListOptions,
 )
 
 
-class InsertBuildLivingSpace(BaseModelRegular):
+class BuildLivingSpaceValidation:
+    tr = {
+        "person_uu_id": "Kişi UUID'si",
+        "build_parts_uu_id": "Bina UUID'si",
+        "occupant_type_uu_id": "Mülk Sahibi UUID'si",
+        "expiry_starts": "Geçerlilik Başlangıç Tarihi",
+        "expiry_ends": "Geçerlilik Bitiş Tarihi",
+    }
+    en = {
+        "person_uu_id": "Person UUID",
+        "build_parts_uu_id": "Build UUID",
+        "occupant_type_uu_id": "Occupant UUID",
+        "expiry_starts": "Expiry Starts",
+        "expiry_ends": "Expiry Ends",
+    }
+
+
+class PydanticBaseModelValidationUpdate:
+    tr = {
+        **PydanticBaseModelValidation.tr,
+        "is_tenant_live": "Kiracı mı?",
+        "build_parts_uu_id": "Bina UUID'si",
+        "person_uu_id": "Kişi UUID'si",
+    }
+    en = {
+        **PydanticBaseModelValidation.en,
+        "is_tenant_live": "Is Tenant Live?",
+        "build_parts_uu_id": "Build UUID",
+        "person_uu_id": "Person UUID",
+    }
+
+
+class InsertBuildLivingSpace(BaseModelRegular, BuildLivingSpaceValidation):
     person_uu_id: str
     build_parts_uu_id: str
     occupant_type_uu_id: str
@@ -14,7 +47,7 @@ class InsertBuildLivingSpace(BaseModelRegular):
     expiry_ends: Optional[str] = None
 
 
-class UpdateBuildLivingSpace(PydanticBaseModel):
+class UpdateBuildLivingSpace(PydanticBaseModel, BuildLivingSpaceValidation):
     is_tenant_live: Optional[bool] = None
     build_parts_uu_id: Optional[str] = None
     person_uu_id: Optional[str] = None

api_validations/validations_request/build_part.py

@@ -2,21 +2,81 @@ from typing import Optional
 from api_validations.core_validations import BaseModelRegular
 from api_validations.validations_request import (
     PydanticBaseModel,
+    PydanticBaseModelValidation,
     ListOptions,
 )
 
 
-class UpdateBuildTypes(PydanticBaseModel): ...
+class BuildTypesUpdateValidation:
+    tr = {
+        **PydanticBaseModelValidation.tr,
+        "function_code": "Fonksiyon Kodu",
+        "type_code": "Tip Kodu",
+        "lang": "Dil",
+        "type_name": "Tip Adı",
+    }
+    en = {
+        **PydanticBaseModelValidation.en,
+        "function_code": "Function Code",
+        "type_code": "Type Code",
+        "lang": "Language",
+        "type_name": "Type Name",
+    }
 
 
-class InsertBuildTypes(PydanticBaseModel):
+class BuildTypesValidation:
+    tr = {
+        "function_code": "Fonksiyon Kodu",
+        "type_code": "Tip Kodu",
+        "lang": "Dil",
+        "type_name": "Tip Adı",
+    }
+    en = {
+        "function_code": "Function Code",
+        "type_code": "Type Code",
+        "lang": "Language",
+        "type_name": "Type Name",
+    }
+
+
+class InsertBuildTypes(BaseModelRegular, BuildTypesValidation):
     function_code: str
     type_code: str
     lang: str
     type_name: str
 
 
-class InsertBuildParts(PydanticBaseModel):
+class UpdateBuildTypes(PydanticBaseModel, BuildTypesUpdateValidation): ...
+
+
+class BuildPartsValidation:
+    tr = {
+        "address_gov_code": "Adres İl Kodu",
+        "part_no": "Daire No",
+        "part_level": "Daire Seviyesi",
+        "build_part_type_uu_id": "Bina Daire Tipi UUID'si",
+        "part_code": "Daire Kodu",
+        "part_gross_size": "Daire Brüt Alanı",
+        "part_net_size": "Daire Net Alanı",
+        "default_accessory": "Varsayılan Aksesuar",
+        "human_livable": "İnsan Yaşanabilir",
+        "part_direction": "Daire Yönü",
+    }
+    en = {
+        "address_gov_code": "Address Gov Code",
+        "part_no": "Flat No",
+        "part_level": "Flat Level",
+        "build_part_type_uu_id": "Build Flat Type UUID",
+        "part_code": "Flat Code",
+        "part_gross_size": "Flat Gross Size",
+        "part_net_size": "Flat Net Size",
+        "default_accessory": "Default Accessory",
+        "human_livable": "Human Livable",
+        "part_direction": "Flat Direction",
+    }
+
+
+class InsertBuildParts(BaseModelRegular, BuildPartsValidation):
     build_uu_id: str
     address_gov_code: str
     part_no: int
@@ -30,11 +90,41 @@ class InsertBuildParts(PydanticBaseModel):
     part_direction_uu_id: Optional[str] = None
     ref_id: Optional[str] = None
 
-    # current_owner_person_uu_id: Optional[str] = None
+
-    # current_tenant_person_uu_id: Optional[str] = None
+class UpdateBuildPartsValidation:
+    tr = {
+        **PydanticBaseModelValidation.tr,
+        "address_gov_code": "Adres İl Kodu",
+        "part_no": "Daire No",
+        "part_level": "Daire Seviyesi",
+        "build_part_type_uu_id": "Bina Daire Tipi UUID'si",
+        "part_code": "Daire Kodu",
+        "part_gross_size": "Daire Brüt Alanı",
+        "part_net_size": "Daire Net Alanı",
+        "default_accessory": "Varsayılan Aksesuar",
+        "human_livable": "İnsan Yaşanabilir",
+        "part_direction": "Daire Yönü",
+        "current_owner_person_uu_id": "Mevcut Sahip Kişi UUID'si",
+        "current_tenant_person_uu_id": "Mevcut Kiracı Kişi UUID'si",
+    }
+    en = {
+        **PydanticBaseModelValidation.en,
+        "address_gov_code": "Address Gov Code",
+        "part_no": "Flat No",
+        "part_level": "Flat Level",
+        "build_part_type_uu_id": "Build Flat Type UUID",
+        "part_code": "Flat Code",
+        "part_gross_size": "Flat Gross Size",
+        "part_net_size": "Flat Net Size",
+        "default_accessory": "Default Accessory",
+        "human_livable": "Human Livable",
+        "part_direction": "Flat Direction",
+        "current_owner_person_uu_id": "Current Owner Person UUID",
+        "current_tenant_person_uu_id": "Current Tenant Person UUID",
+    }
 
 
-class UpdateBuildParts(PydanticBaseModel):
+class UpdateBuildParts(PydanticBaseModel, UpdateBuildPartsValidation):
     address_gov_code: Optional[str] = None
     part_no: Optional[int] = None
     part_level: Optional[int] = None

api_validations/validations_request/core_request_validations.py

@@ -3,8 +3,26 @@ from typing import Optional
 from api_validations.core_validations import BaseModelRegular
 
 
-class ListOptions(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):
     page: Optional[int] = 1
     size: Optional[int] = 10
     order_field: Optional[str] = "id"
@@ -13,6 +31,54 @@ class ListOptions(BaseModelRegular):
     query: Optional[dict] = {}
 
 
+class CrudRecordValidation:
+    tr = {
+        "uu_id": "UUID",
+        "ref_id": "Ref ID",
+        "created_at": "Oluşturulma Tarihi",
+        "updated_at": "Güncellenme Tarihi",
+        "created_by": "Oluşturan",
+        "updated_by": "Güncelleyen",
+        "confirmed_by": "Onaylayan",
+        "is_confirmed": "Onay",
+        "deleted": "Silinmiş",
+        "active": "Aktif",
+        "is_notification_send": "Bildirim Gönderildi",
+        "is_email_send": "E-posta Gönderildi",
+    }
+    en = {
+        "uu_id": "UUID",
+        "ref_id": "Ref ID",
+        "created_at": "Created At",
+        "updated_at": "Updated At",
+        "created_by": "Created By",
+        "updated_by": "Updated By",
+        "confirmed_by": "Confirmed By",
+        "is_confirmed": "Confirmed",
+        "deleted": "Deleted",
+        "active": "Active",
+        "is_notification_send": "Notification Send",
+        "is_email_send": "Email Send",
+    }
+
+
+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
@@ -23,10 +89,13 @@ class PydanticBaseModel(BaseModelRegular):
 
 
 class EndpointPydantic(BaseModelRegular):
-
     data: Optional[dict] = {}
 
 
+class EndpointValidation(BaseModelRegular):
+    endpoint: Optional[str] = None
+
+
 class PatchRecord(BaseModelRegular):
 
     confirm: Optional[bool] = None

databases/sql_models/account/account.py

@@ -381,47 +381,6 @@ class AccountRecords(CrudCollection):
         ("budget_type", "BudgetType", "B"),
     ]
 
-    language = {
-        "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 UU ID",
-            "budget_type_uu_id": "Bütçe Tipi UU ID",
-            "company_uu_id": "Şirket UU ID",
-            "send_company_uu_id": "Gönderen Şirket UU ID",
-            "customer_id": "Müşteri ID",
-            "customer_uu_id": "Müşteri UU ID",
-            "send_person_uu_id": "Gönderen Kişi UU ID",
-            "approving_accounting_person_uu_id": "Onaylayan Muhasebe Kişi UU ID",
-            "build_parts_uu_id": "Daire UU ID",
-            "build_decision_book_uu_id": "Karar Defteri UU ID",
-        },
-        "en": {},
-    }
-
     iban: Mapped[str] = mapped_column(
         String(64), nullable=False, comment="IBAN Number of Bank"
     )

databases/sql_models/building/build.py

@@ -551,7 +551,9 @@ class BuildLivingSpace(CrudCollection):
         token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
     ):
         from databases import Services, OccupantTypes
-        from api_events.events.events.events_bind_modules import ModulesBindOccupantEventMethods
+        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"]))

databases/sql_models/event/event.py

@@ -109,6 +109,7 @@ class Services(CrudCollection):
     @classmethod
     def retrieve_service_via_occupant_code(cls, occupant_code):
         from databases import OccupantTypes
+
         occupant_type = OccupantTypes.filter_by_one(
             system=True,
             occupant_code=occupant_code,
@@ -122,7 +123,9 @@ class Services(CrudCollection):
                     "occupant_code": occupant_code,
                 },
             )
-        return cls.filter_one(cls.related_responsibility == occupant_type.occupant_code).data
+        return cls.filter_one(
+            cls.related_responsibility == occupant_type.occupant_code
+        ).data
 
     __table_args__ = ({"comment": "Services Information"},)
 

service_account_records/app_accounts.py

@@ -56,7 +56,7 @@ def account_records_find_decision_book():
                     created_ibans.append(account_record.iban)
                 except Exception as e:
                     print("Exception of find_decision_book ln:55", e)
-            if not getattr(found_iban, 'build_id', None):  # It is in database already
+            if not getattr(found_iban, "build_id", None):  # It is in database already
                 iban_build_dict["iban"] = account_record.iban
                 iban_build_dict["build_id"] = None
             else:
@@ -329,11 +329,11 @@ def send_accounts_to_decision_payment():
 
 
 def account_records_service() -> None:
-    print('Account Records Service is running...')
+    print("Account Records Service is running...")
     account_records_find_decision_book()
     account_records_search()
     send_accounts_to_decision_payment()
-    print('Account Records Service is finished...')
+    print("Account Records Service is finished...")
     return
 
 

service_app/routers/__init__.py

@@ -59,7 +59,7 @@ from .decision_book.project_decision_book_items.router import (
 from .decision_book.project_decision_book_person.router import (
     build_decision_book_project_people_route,
 )
-
+from .validations.router import validations_route
 
 __all__ = [
     "account_records_router",
@@ -99,4 +99,5 @@ __all__ = [
     "build_decision_book_project_route",
     "build_decision_book_project_items_route",
     "build_decision_book_project_people_route",
+    "validations_route",
 ]

service_app/routers/validations/router.py

@@ -0,0 +1,109 @@
+from fastapi import status
+from fastapi.routing import APIRouter
+from fastapi.requests import Request
+from fastapi.exceptions import HTTPException
+from api_validations.validations_request import (
+    EndpointValidation,
+)
+from pydantic import BaseModel
+
+
+validations_route = APIRouter(prefix="/validations", tags=["Validations"])
+validations_route.include_router(validations_route, include_in_schema=True)
+
+
+class EndpointValidationResponse(BaseModel):
+    language: str
+    headers: dict
+    validation: dict
+
+
+def retrieve_validation_from_class(selected_event, events):
+    event_function_class = getattr(selected_event, "function_class", None)
+    event_function_code = getattr(selected_event, "function_code", None)
+    function_class = getattr(events, event_function_class, None)
+    return function_class.__event_validation__.get(event_function_code, None)
+
+
+@validations_route.post(path="/endpoint", summary="Retrieve validation of endpoint")
+def user_list(request: Request, validation: EndpointValidation):
+    import api_events.events as events
+    from api_services.redis.functions import get_object_via_access_key
+    from databases import (
+        EndpointRestriction,
+        Events,
+    )
+
+    valid_token = get_object_via_access_key(request=request)
+    if not valid_token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"No valid token found in the request.",
+        )
+    endpoint_active = EndpointRestriction.filter_one(
+        EndpointRestriction.endpoint_name.ilike(f"%{str(validation.endpoint)}%"),
+        system=True,
+    ).data
+    if not endpoint_active:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"This endpoint {str(validation.endpoint)} is not active for this user, please contact your responsible company for further information.",
+        )
+    if valid_token.user_type == 1:
+        if not valid_token.selected_company:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Selected company is not found in the token object.",
+            )
+        selected_event = Events.filter_one(
+            Events.endpoint_id == endpoint_active.id,
+            Events.id.in_(valid_token.selected_company.reachable_event_list_id),
+        ).data
+        if not selected_event:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="This endpoint requires event validation. Please contact your responsible company to use this event.",
+            )
+        active_validation = retrieve_validation_from_class(selected_event, events)
+        if not active_validation:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="This endpoint requires event validation. Please contact your responsible company to use this event.",
+            )
+        headers = getattr(
+            active_validation, str(valid_token.lang).lower(), active_validation.tr
+        )
+        return EndpointValidationResponse(
+            language=valid_token.lang,
+            headers=headers,
+            validation=active_validation.model_json_schema(),
+        )
+    elif valid_token.user_type == 2:
+        if not valid_token.selected_occupant:
+            raise HTTPException(
+                status_code=status.HTTP_418_IM_A_TEAPOT,
+                detail="Selected occupant is not found in the token object.",
+            )
+        selected_event = Events.filter_one(
+            Events.endpoint_id == endpoint_active.id,
+            Events.id.in_(valid_token.selected_occupant.reachable_event_list_id),
+        ).data
+        if not selected_event:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail=f"This endpoint {str(validation.endpoint)} requires event validation. Please contact your responsible company to use this event.",
+            )
+        active_validation = retrieve_validation_from_class(selected_event, events)
+        if not active_validation:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail=f"This endpoint {str(validation.endpoint)} requires event validation. Please contact your responsible company to use this event.",
+            )
+        headers = getattr(
+            active_validation, str(valid_token.lang), active_validation.tr
+        )
+        return EndpointValidationResponse(
+            language=valid_token.lang,
+            headers=headers,
+            validation=active_validation.model_json_schema(),
+        )