language models and set defaults are updated

ApiLayers/LanguageModels/Errors/all_errors.py

@@ -0,0 +1,4 @@
+from .defualt_error import default_errors
+
+
+all_errors_list = [default_errors]

ApiLayers/LanguageModels/Errors/defualt_error.py

@@ -0,0 +1,98 @@
+default_errors = {
+    "NOT_CREATED": {
+        "tr": {
+            "message": "Kayıt oluşturulamadı. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record could not be created. Please try again.",
+        },
+    },
+    "NOT_DELETED": {
+        "tr": {
+            "message": "Kayıt silinemedi. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record could not be deleted. Please try again.",
+        },
+    },
+    "NOT_UPDATED": {
+        "tr": {
+            "message": "Kayıt güncellenemedi. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record could not be updated. Please try again.",
+        },
+    },
+    "NOT_LISTED": {
+        "tr": {
+            "message": "Kayıt listelenemedi. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record could not be listed. Please try again.",
+        },
+    },
+    "NOT_FOUND": {
+        "tr": {
+            "message": "Kayıt bulunamadı. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record could not be found. Please try again.",
+        },
+    },
+    "ALREADY_EXISTS": {
+        "tr": {
+            "message": "Kayıt zaten mevcut. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record already exists. Please try again.",
+        },
+    },
+    "IS_NOT_CONFIRMED": {
+        "tr": {
+            "message": "Kayıt onaylanmadı. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Record is not confirmed. Please try again.",
+        },
+    },
+    "NOT_AUTHORIZED": {
+        "tr": {
+            "message": "Yetkisiz kullanıcı. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Unauthorized user. Please try again.",
+        },
+    },
+    "NOT_VALID": {
+        "tr": {
+            "message": "Geçersiz veri. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Invalid data. Please try again.",
+        },
+    },
+    "NOT_ACCEPTABLE": {
+        "tr": {
+            "message": "Geçersiz veri. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Invalid data. Please try again.",
+        },
+    },
+    "INVALID_DATA": {
+        "tr": {
+            "message": "Geçersiz veri. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "Invalid data. Please try again.",
+        },
+    },
+    "UNKNOWN_ERROR": {
+        "tr": {
+            "message": "Bilinmeyen bir hata oluştu. Lütfen tekrar deneyiniz.",
+        },
+        "en": {
+            "message": "An unknown error occured. Please try again.",
+        },
+    },
+}

ApiLayers/LanguageModels/Request/Auth/login.py

@@ -0,0 +1,17 @@
+from typing import Dict
+
+
+LoginRequestLanguageModel: Dict[str, Dict[str, str]] = {
+    "tr": {
+        "domain": "Domain",
+        "access_key": "Erişim Anahtarı",
+        "password": "Parola",
+        "remember_me": "Beni Hatırla",
+    },
+    "en": {
+        "domain": "Domain",
+        "access_key": "Access Key",
+        "password": "Password",
+        "remember_me": "Remember Me",
+    },
+}

ApiLayers/LanguageModels/Request/__init__.py

@@ -0,0 +1,5 @@
+from .Auth.login import LoginRequestLanguageModel
+
+__all__ = [
+    "LoginRequestLanguageModel"
+    ]

ApiLayers/LanguageModels/Response/all_responses.py

@@ -0,0 +1,3 @@
+from .authentication.auth import authResponses
+
+all_response_list = [authResponses]

ApiLayers/LanguageModels/Response/authentication/auth.py

@@ -0,0 +1,18 @@
+authResponses = {
+    "LOGIN_SELECT": {
+        "tr": {
+            "message": "Şirket/Görev başarılı bir şekilde seçildi.",
+        },
+        "en": {
+            "message": "Company/Duty selected successfully.",
+        },
+    },
+    "LOGIN_SUCCESS": {
+        "tr": {
+            "message": "Giriş başırı ile tamamlandı. Devam etmek için bir şirket/görev seçiniz.",
+        },
+        "en": {
+            "message": "Login successful. Please select an company/duty to continue.",
+        },
+    },
+}

ApiLayers/LanguageModels/default_template.py

@@ -0,0 +1,10 @@
+responses = {
+    "LOGIN_SELECT": {
+        "tr": {
+            "": "",
+        },
+        "en": {
+            "": "",
+        },
+    },
+}

ApiLayers/LanguageModels/set_defaults/language_setters.py

@@ -0,0 +1,144 @@
+from ApiLayers.AllConfigs.Redis.configs import RedisValidationKeys
+from ApiLayers.AllConfigs.main import LanguageConfig
+from Events.Engine.set_defaults.category_cluster_models import CategoryClusterController
+from Services.Redis.Actions.actions import RedisActions
+
+
+class SetDefaultLanguageModelsRedis:
+
+    std_out: str = ""
+
+    def __init__(
+        self,
+        set_response_languages_list: list[dict],
+        set_errors_languages_list: list[dict],
+    ):
+        self.responses_list: list[dict] = set_response_languages_list
+        self.errors_list: list[dict] = set_errors_languages_list
+
+    def __str__(self):
+        return f"\nPrepareLanguageModels:\n\n{self.std_out}"
+
+    def set_all(self):
+        
+        # RedisActions.delete(list_keys=["*"])
+        RedisActions.delete(list_keys=[f"{RedisValidationKeys.LANGUAGE_MODELS}:*"])
+
+        for response in self.responses_list:
+            for lang in list(LanguageConfig.SUPPORTED_LANGUAGES):
+                for code, dict_to_set in response.items():
+                    # [SAVE]REDIS => LANGUAGE_MODELS:STATIC:RESPONSES:{ResponseCode}:tr = {...}
+                    redis_key = f"{RedisValidationKeys.LANGUAGE_MODELS}:{RedisValidationKeys.STATIC}"
+                    set_key = f"{redis_key}:{RedisValidationKeys.RESPONSES}:{code}:{lang}"
+                    RedisActions.set_json(list_keys=[set_key], value=dict_to_set)
+
+        self.std_out += f"Language Response Models are set to Redis\n"
+        for response in self.errors_list:
+            for lang in list(LanguageConfig.SUPPORTED_LANGUAGES):
+                for code, dict_to_set in response.items():
+                    # [SAVE]REDIS => LANGUAGE_MODELS:STATIC:ERRORCODES:{ErrorCode}:en = {...}
+                    redis_key = f"{RedisValidationKeys.LANGUAGE_MODELS}:{RedisValidationKeys.STATIC}"
+                    set_key = f"{redis_key}:{code}:{lang}"
+                    RedisActions.set_json(list_keys=[set_key], value=dict_to_set)
+
+        self.std_out += f"Language Error Models are set to Redis\n"
+
+
+class SetClusterLanguageModelsRedis:
+
+    std_out: str = ""
+    events_lm_dict: dict[str, dict[str, dict]] = {}
+    events_rq_dict: dict[str, dict[str, dict]] = {}
+    events_rs_dict: dict[str, dict[str, dict]] = {}
+
+    def __init__(self, cluster_controller_group: CategoryClusterController):
+        self.cluster_controller_group = cluster_controller_group
+
+    def __str__(self):
+        return f"\nPrepareLanguageModels:\n\n{self.std_out}"
+
+    @staticmethod
+    def merge_language_dicts(list_of_lang_models: list[dict]):
+        """
+        Merges the language models of the events to a single dictionary.
+        """
+        merged_lang_models: dict[str, dict] = {}
+        for lang_model in list_of_lang_models:
+            for lang in list(LanguageConfig.SUPPORTED_LANGUAGES):
+                if not lang_model.get(lang, None):
+                    raise ValueError(f"Language model for {lang} not found in {lang_model}")
+                if lang not in merged_lang_models:
+                    merged_lang_models[lang] = lang_model[lang]
+                else:
+                    merged_lang_models[lang].update(lang_model[lang])
+        return merged_lang_models
+
+    def set_models_from_cluster(self):
+        # iterate(ClusterToMethod) to set all models by pairing function codes
+        for cluster_control in self.cluster_controller_group.imports:
+            self.std_out += f"Setting models from cluster : {cluster_control.name}\n"
+            for endpoint in cluster_control.category_cluster.ENDPOINTS.values():
+                for key_event, event in endpoint.EVENTS.items():
+                    merged_language_dict = self.merge_language_dicts(event.LANGUAGE_MODELS)
+                    request_validation = getattr(event.REQUEST_VALIDATOR, 'model_fields', None)
+                    response_validation = getattr(event.RESPONSE_VALIDATOR, 'model_fields', None)
+                    objects_missing = bool(request_validation) and bool(response_validation) and bool(merged_language_dict)
+                    if not objects_missing:
+                        continue
+                    if merged_language_dict:
+                        self.events_lm_dict[key_event] = merged_language_dict
+                    if request_validation:
+                        self.events_rq_dict[key_event] = request_validation
+                    if response_validation:
+                        self.events_rs_dict[key_event] = response_validation
+                    self.std_out += f"Request/Response/Language validation model is set {key_event}\n"
+
+    def set_all(self):
+        # Set all language models from cluster list by pairing event code and models
+        self.set_models_from_cluster()
+        if self.events_lm_dict and self.events_rq_dict:
+            """
+            [SAVE]REDIS => LANGUAGE_MODELS:DYNAMIC:HEADERS:REQUEST:{FunctionCode}:tr = {...}
+            Get Request BaseModel pydantic model_fields of each event and set headers which are included in model_fields
+            """
+            for lang in list(LanguageConfig.SUPPORTED_LANGUAGES):   # Iterate(languages ["tr", "en"])
+                for key_field in self.events_rq_dict.keys():     # Iterate(function_code)
+                    request_model = self.events_rq_dict[key_field]
+                    if not request_model:
+                        self.std_out += f"Request validation model not found for {key_field}\n"
+                        continue
+                    if key_field not in self.events_rq_dict or key_field not in self.events_lm_dict:
+                        self.std_out += f"Request language model not found for {key_field}\n"
+                        continue
+
+                    value_to_set = {}
+                    redis_key = f"{RedisValidationKeys.LANGUAGE_MODELS}:{RedisValidationKeys.DYNAMIC}"
+                    set_key = f"{redis_key}:{key_field}:{lang}"
+                    for key in request_model.keys():
+                        value_to_set[key] = self.events_lm_dict[key_field][lang][key]
+                    RedisActions.set_json(list_keys=[set_key], value=value_to_set)
+        
+        self.std_out += f"Language Request Headers are set to Redis\n"
+        if self.events_lm_dict and self.events_rs_dict:
+            """
+            [SAVE]REDIS => LANGUAGE_MODELS:DYNAMIC:HEADERS:RESPONSE:{FunctionCode}:en = {...}
+            Get Response BaseModel pydantic model_fields of each event and set headers which are included in model_fields
+            """
+            for lang in list(LanguageConfig.SUPPORTED_LANGUAGES):   # Iterate(languages ["tr", "en"])
+                for key_field in self.events_rs_dict.keys():     # Iterate(function_code)
+                    response_model = self.events_rs_dict[key_field]
+                    if not response_model:
+                        self.std_out += f"Response validation model not found for {key_field}\n"
+                        continue
+                    if key_field not in self.events_rs_dict or key_field not in self.events_lm_dict:
+                        self.std_out += f"Response language model not found for {key_field}\n"
+                        continue
+
+                    value_to_set = {}
+                    redis_key = f"{RedisValidationKeys.LANGUAGE_MODELS}:{RedisValidationKeys.DYNAMIC}"
+                    set_key = f"{redis_key}:{key_field}:{lang}"
+                    for key in response_model.keys():
+                        value_to_set[key] = self.events_lm_dict[key_field][lang][key]
+                    RedisActions.set_json(list_keys=[set_key], value=value_to_set)
+        
+        self.std_out += f"Language Response Headers are set to Redis\n"