updated account info gathering

ApiLayers/LanguageModels/PageInfos/accounts/account.py

@@ -0,0 +1,36 @@
+
+
+class AccountLanguageModels:
+    
+    account_language_update_models = {
+        "en": {
+            "page": "Update Account Records",
+        },
+        "tr": {
+            "page": "Hesap Kayıdı Güncelle",
+        },
+    }
+    account_language_created_models = {
+        "en": {
+            "page": "Create Account Records",
+        },
+        "tr": {
+            "page": "Hesap Kayıdı Oluştur",
+        },
+    }
+    account_language_list_models = {
+        "en": {
+            "page": "List Account Records",
+        },
+        "tr": {
+            "page": "Hesap Kaytlarını Listele",
+        },
+    }
+    account_language_create_form_models = {
+        "en": {"page": "Create Account Records", "button": "Create"},
+        "tr": {"page": "Hesap Kayıdı Oluştur", "button": "Oluştur"},
+    },
+    account_language_update_form_models = {
+        "en": {"page": "Update Account Records", "button:": "Update"},
+        "tr": {"page": "Hesap Kayıdı Güncelle", "button:": "Güncelle"},
+    },

Events/AllEvents/events/account/bases.py

@@ -1,3 +1,4 @@
+from typing import Any, Dict, Optional
 from Events.Engine.abstract_class import DefaultClusterName
 
 
@@ -5,6 +6,17 @@ cluster_name = "AccountCluster"
 prefix = "/accounts"
 icon = "Building"
 
+# Icons
+class Icons:
+    PENCIL = "Pencil"
+    PLUS = "Plus"
+    TABLE = "Table"
+
+# Components
+class Components:
+    TABLE = "Table"
+    FORM = "Form"
+    LINK = "Link"
 
 # Keys for the cluster
 class KeyValidations:
@@ -12,10 +24,32 @@ class KeyValidations:
     data = "data"
     validation = "validations"
 
+# Types of keys
+class KeyTypes:
+    REQUEST = "REQUEST"
+    RESPONSE = "RESPONSE"
+    BOTH = "BOTH"
+
 # Key URLS for the cluster
 class KeyURLs:
     validations = "/validations/validations"
 
+
+# "data": {"event_code": f"{KeyBases.list_key}", "asked_field": KeyValidations.headers, "type": KeyTypes.RESPONSE},
+class ValidationRequest:
+    event_code: str
+    asked_field: str
+    type: Optional[str] = "REQUEST"
+
+    @classmethod
+    def dump(cls) -> Dict[str, Any]:
+        return {
+            "event_code": cls.event_code,
+            "asked_field": cls.asked_field,
+            "type": cls.type,
+        }
+
+
 # Keys for the cluster
 class KeyBases:
     create_key = f"{prefix}/create"

Events/AllEvents/events/account/info.py

@@ -1,16 +1,17 @@
 from Events.Engine.abstract_class import PageInfo
-from .bases import KeyValidations, cluster_name, KeyBases, PageBases, icon, KeyURLs
+from .bases import Components, KeyTypes, ValidationRequest, icon, cluster_name
+from .bases import KeyValidations, KeyBases, PageBases, KeyURLs
 from .account_records import (
     AccountRecordsUpdateEventMethods,
     AccountRecordsCreateEventMethods,
     AccountRecordsListEventMethods,
 )
 from .lang_models import (
-    account_language_create_models_as_dict,
-    account_language_model_as_dict,
     account_language_list_models_as_dict,
-    account_language_created_models_as_dict,
+    account_language_create_form_models_as_dict,
     account_language_update_form_models_as_dict,
+    account_language_create_link_models_as_dict,
+    account_language_update_link_models_as_dict,
 )
 
 
@@ -27,7 +28,7 @@ RedisValidation = dict(
         "page": "Kullanıcı tüm hesap bilgilerine ulaşmak için Hesap Kayıtları",
       },
     },
-    SUBCATEGORIES={
+    SUB_COMPONENTS={
       "/accounts/create": {
         "SITE_URL": "/events/create?site=AccountCluster",
         "COMPONENT": "Link",
@@ -87,7 +88,7 @@ class ClustersPageInfo:
         name=f"{cluster_name}",
         url=PageBases.DASHBOARD,
         icon=icon,
-        page_info={
+        info={
             "en": {
                 "page": "Account Records for reaching user all types account information",
             },
@@ -95,53 +96,59 @@ class ClustersPageInfo:
                 "page": "Kullanıcı tüm hesap bilgilerine ulaşmak için Hesap Kayıtları",
             },
         },
-        instructions={
+        sub_components={
+            str(KeyBases.create_key): {
+                "SITE_URL": PageBases.CREATE,
+                "COMPONENT": Components.LINK,
+                "PREFIX_URL": KeyBases.create_key,
+                "ENDPOINTS": AccountRecordsCreateEventMethods.retrieve_all_event_keys(),
+                "LANGUAGE_MODELS": account_language_create_link_models_as_dict,
+                "INSTRUCTIONS": {},
+            },
+            str(KeyBases.update_key): {
+                "SITE_URL": PageBases.UPDATE,
+                "COMPONENT": Components.LINK,
+                "PREFIX_URL": KeyBases.update_key,
+                "ENDPOINTS": AccountRecordsUpdateEventMethods.retrieve_all_event_keys(),
+                "LANGUAGE_MODELS": account_language_update_link_models_as_dict,
+                "INSTRUCTIONS": {},
+            },
             str(KeyBases.list_key): {
-                "headers": {
+                "SITE_URL": PageBases.DASHBOARD,
-                    "store": True,
+                "COMPONENT": Components.TABLE,
-                    "url": KeyURLs.validations,
+                "PREFIX_URL": KeyBases.list_key,
-                    "data": {"event_code": f"{KeyBases.list_key}", "asked_field": KeyValidations.headers},
+                "INFO": {
+                    "en": {"page": "List Account Records"},
+                    "tr": {"page": "Hesap Kayıtlarını Listele"},
                 },
-                "data": {
+                "ENDPOINTS": AccountRecordsListEventMethods.retrieve_all_event_keys(),
-                    "store": True,
+                "LANGUAGE_MODELS": account_language_list_models_as_dict,
-                    "url": f"{KeyBases.list_key}",
+                "INSTRUCTIONS": {
-                    "data": dict(page=1, limit=1),
+                    "HEADERS": {
+                        "store": True,
+                        "url": KeyURLs.validations,
+                        "data": ValidationRequest(
+                            event_code=f"{KeyBases.list_key}",
+                            asked_field=KeyValidations.headers,
+                            type=KeyTypes.RESPONSE
+                        ).dump(),
+                    },
+                    "DATA": {
+                        "store": True,
+                        "url": f"{KeyBases.list_key}",
+                        "params": None,
+                        "data": dict(page=1, limit=1, order_by="uu_id", order_type="desc", query=None),
+                    },
                 },
             },
         },
-        endpoints={
-            str(KeyBases.update_key): AccountRecordsUpdateEventMethods.retrieve_all_event_keys(),
-            str(KeyBases.create_key): AccountRecordsCreateEventMethods.retrieve_all_event_keys(),
-            str(KeyBases.list_key): AccountRecordsListEventMethods.retrieve_all_event_keys(),
-        },
-        language_models={
-            str(KeyBases.list_key): {
-                str(KeyBases.update_key): account_language_model_as_dict,
-                str(KeyBases.create_key): account_language_created_models_as_dict,
-                str(KeyBases.list_key): account_language_list_models_as_dict,
-            }
-        },
     )
 
     create_page_info = PageInfo(
         name=f"{cluster_name}",
         url=PageBases.CREATE,
         icon=icon,
-        instructions={
+        info={
-            str(KeyBases.create_key): {
-                "validation": {
-                    "store": True,
-                    "url": KeyURLs.validations,
-                    "data": {"event_code": f"{KeyBases.create_key}", "asked_field": KeyValidations.validation },
-                },
-                "headers": {
-                    "store": True,
-                    "url": KeyURLs.validations,
-                    "data": {"event_code": f"{KeyBases.create_key}", "asked_field": KeyValidations.headers},
-                },
-            },
-        },
-        page_info={
             "en": {
                 "page": "Create Account Records for reaching user all types account information",
             },
@@ -149,11 +156,38 @@ class ClustersPageInfo:
                 "page": "Kullanıcı tüm hesap bilgilerine ulaşmak için Hesap Kayıt Oluştur",
             },
         },
-        endpoints={
+        sub_components={
-            str(KeyBases.create_key): AccountRecordsCreateEventMethods.retrieve_all_event_keys(),
+            str(KeyBases.create_key): {
-        },
+                "SITE_URL": PageBases.CREATE,
-        language_models={
+                "COMPONENT": Components.FORM,
-            str(KeyBases.create_key): account_language_create_models_as_dict,
+                "PREFIX_URL": KeyBases.create_key,
+                "INFO": {
+                    "en": {"page": "Create Account Records", "button": "Create"},
+                    "tr": {"page": "Hesap Kayıtlarını Oluştur", "button": "Oluştur"},
+                },
+                "ENDPOINTS": AccountRecordsCreateEventMethods.retrieve_all_event_keys(),
+                "LANGUAGE_MODELS": account_language_create_form_models_as_dict,
+                "INSTRUCTIONS": {
+                    "VALIDATION": {
+                        "store": True,
+                        "url": KeyURLs.validations,
+                        "data": ValidationRequest(
+                            event_code=f"{KeyBases.create_key}",
+                            asked_field=KeyValidations.validation,
+                            type=KeyTypes.REQUEST
+                        ).dump(), 
+                    },
+                    "HEADERS": {
+                        "store": True,
+                        "url": KeyURLs.validations,
+                        "data": ValidationRequest(
+                            event_code=f"{KeyBases.create_key}",
+                            asked_field=KeyValidations.headers,
+                            type=KeyTypes.REQUEST
+                        ).dump(),
+                    },
+                },
+            },
         },
     )
 
@@ -161,21 +195,7 @@ class ClustersPageInfo:
         name=f"{cluster_name}",
         url=PageBases.UPDATE,
         icon=icon,
-        instructions={
+        info={
-            str(KeyBases.update_key): {
-                "validation": {
-                    "store": True,
-                    "url": KeyURLs.validations,
-                    "data": {"event_code": f"{KeyBases.update_key}", "asked_field": KeyValidations.validation},
-                },
-                "headers": {
-                    "store": True,
-                    "url": KeyURLs.validations,
-                    "data": {"event_code": f"{KeyBases.update_key}", "asked_field": KeyValidations.headers},
-                },
-            },
-        },
-        page_info={
             "en": {
                 "page": "Update Account Records via all types account information",
             },
@@ -183,15 +203,47 @@ class ClustersPageInfo:
                 "page": "Tüm hesap bilgileri aracılığıyla Hesap Kayıtlarını Güncelle",
             },
         },
-        endpoints={
+        sub_components={
-            str(KeyBases.update_key): AccountRecordsUpdateEventMethods.retrieve_all_event_keys(),
+            str(KeyBases.update_key): {
-        },
+                "SITE_URL": PageBases.UPDATE,
-        language_models={
+                "COMPONENT": Components.FORM,
-            str(KeyBases.update_key): account_language_update_form_models_as_dict,
+                "PREFIX_URL": KeyBases.update_key,
+                "INFO": {
+                    "en": {"page": "Update Account Records", "button": "Update"},
+                    "tr": {"page": "Hesap Kayıtlarını Güncelle", "button": "Güncelle"},
+                },
+                "ENDPOINTS": AccountRecordsUpdateEventMethods.retrieve_all_event_keys(),
+                "LANGUAGE_MODELS": account_language_update_form_models_as_dict,
+                "INSTRUCTIONS": {
+                    "VALIDATION": {
+                        "store": True,
+                        "url": KeyURLs.validations,
+                        "data": ValidationRequest(
+                            event_code=f"{KeyBases.update_key}",
+                            asked_field=KeyValidations.validation,
+                            type=KeyTypes.REQUEST
+                        ).dump(),
+                    },
+                    "HEADERS": {
+                        "store": True,
+                        "url": KeyURLs.validations,
+                        "data": ValidationRequest(
+                            event_code=f"{KeyBases.update_key}",
+                            asked_field=KeyValidations.headers,
+                            type=KeyTypes.REQUEST
+                        ).dump(),
+                    },
+                    "DATA": {
+                        "store": True,
+                        "url": f"{KeyBases.list_key}",
+                        "params": {"uu_id": "SomeUUID"},
+                        "data": dict(page=1, size=1, limit=1, order_by="uu_id", order_type="desc", query={"uu_id": "SomeUUID"}),
+                    },
+                },
+            },
         },
     )
 
-
 # Page Variations of the cluster
 page_infos = {
     ClustersPageInfo.dashboard_page_info.URL: ClustersPageInfo.dashboard_page_info,

Events/AllEvents/events/account/lang_models.py

@@ -1,78 +1,44 @@
-from Events.Engine.abstract_class import DefaultClusterName, LanguageModels
+from ApiLayers.LanguageModels.PageInfos.accounts.account import AccountLanguageModels
-from .bases import KeyBases, cluster_name
+from Events.Engine.abstract_class import LanguageModels
+from .bases import Components, Icons, KeyBases, PageBases
 
 
 account_language_update_models = LanguageModels()
-account_language_update_models.COMPONENT = "Link"
+account_language_update_models.COMPONENT = Components.LINK
-account_language_update_models.SITE_URL = f"/update?{DefaultClusterName}={cluster_name}"
+account_language_update_models.SITE_URL = PageBases.UPDATE
-account_language_update_models.PREFIX_URL = (
+account_language_update_models.ICON = Icons.PENCIL
-    KeyBases.update_key
+account_language_update_models.PREFIX_URL = KeyBases.update_key
-)
+account_language_update_models.PAGE_INFO = AccountLanguageModels.account_language_update_models
-account_language_update_models.PAGE_INFO = {
+account_language_update_link_models_as_dict = account_language_update_models.as_dict()
-    "en": {
-        "page": "Update Account Records",
-    },
-    "tr": {
-        "page": "Hesap Kayıdı Güncelle",
-    },
-}
-account_language_model_as_dict = account_language_update_models.as_dict()
-
 
 account_language_created_models = LanguageModels()
-account_language_created_models.COMPONENT = "Link"
+account_language_created_models.COMPONENT = Components.LINK
-account_language_created_models.SITE_URL = f"/create?{DefaultClusterName}={cluster_name}"
+account_language_created_models.ICON = Icons.PLUS
-account_language_created_models.PREFIX_URL = (
+account_language_created_models.SITE_URL = PageBases.CREATE
-    KeyBases.create_key
+account_language_created_models.PREFIX_URL = KeyBases.create_key
-)
+account_language_created_models.PAGE_INFO = AccountLanguageModels.account_language_created_models
-account_language_created_models.PAGE_INFO = {
+account_language_create_link_models_as_dict = account_language_created_models.as_dict()
-    "en": {
-        "page": "Create Account Records",
-    },
-    "tr": {"page": "Hesap Kayıdı Oluştur"},
-}
-account_language_created_models_as_dict = account_language_created_models.as_dict()
 
 account_language_list_models = LanguageModels()
-account_language_list_models.COMPONENT = "Table"
+account_language_list_models.COMPONENT = Components.TABLE
-account_language_list_models.SITE_URL = f"/dashboard?{DefaultClusterName}={cluster_name}"
+account_language_list_models.ICON = Icons.TABLE
-account_language_list_models.PREFIX_URL = (
+account_language_list_models.SITE_URL = PageBases.DASHBOARD
-    KeyBases.list_key
+account_language_list_models.PREFIX_URL = KeyBases.list_key
-)
+account_language_list_models.PAGE_INFO = AccountLanguageModels.account_language_list_models
-account_language_list_models.PAGE_INFO = {
-    "en": {
-        "page": "List Account Records",
-    },
-    "tr": {
-        "page": "Hesap Kayıtlarını Listele",
-    },
-}
-
 account_language_list_models_as_dict = account_language_list_models.as_dict()
 
 account_language_create_form_models = LanguageModels()
-account_language_create_form_models.COMPONENT = "Form"
+account_language_create_form_models.COMPONENT = Components.FORM
-account_language_create_form_models.SITE_URL = f"/create?{DefaultClusterName}={cluster_name}"
+account_language_create_form_models.ICON = Icons.PLUS
-account_language_create_form_models.PREFIX_URL = (
+account_language_create_form_models.SITE_URL = PageBases.CREATE
-    KeyBases.create_key
+account_language_create_form_models.PREFIX_URL = KeyBases.create_key
-)
+account_language_create_form_models.PAGE_INFO = AccountLanguageModels.account_language_create_form_models
-account_language_create_form_models.PAGE_INFO = {
+account_language_create_form_models_as_dict = account_language_create_form_models.as_dict()
-    "en": {"page": "List Account Records", "button:": "Create"},
-    "tr": {"page": "Hesap Kayıtlarını Listele", "button:": "Oluştur"},
-}
-
-account_language_create_models_as_dict = account_language_create_form_models.as_dict()
 
 account_language_update_form_models = LanguageModels()
-account_language_update_form_models.COMPONENT = "Form"
+account_language_update_form_models.COMPONENT = Components.FORM
-account_language_update_form_models.SITE_URL = f"/update?{DefaultClusterName}={cluster_name}"
+account_language_update_form_models.ICON = Icons.PENCIL
-account_language_update_form_models.PREFIX_URL = (
+account_language_update_form_models.SITE_URL = PageBases.UPDATE
-    KeyBases.update_key
+account_language_update_form_models.PREFIX_URL = KeyBases.update_key
-)
+account_language_update_form_models.PAGE_INFO = AccountLanguageModels.account_language_update_form_models
-account_language_update_form_models.PAGE_INFO = {
+account_language_update_form_models_as_dict = account_language_update_form_models.as_dict()
-    "en": {"page": "Update Account Records", "button:": "Update"},
-    "tr": {"page": "Hesap Kayıdı Güncelle", "button:": "Güncelle"},
-}
-account_language_update_form_models_as_dict = (
-    account_language_update_form_models.as_dict()
-)

Events/AllEvents/validations/validation/function_handlers.py

@@ -2,7 +2,7 @@
 Validation function handlers
 """
 
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 from fastapi import Request
 
 from ApiLayers.AllConfigs.Redis.configs import (
@@ -75,7 +75,7 @@ class RedisValidationRetrieve(ValidateBase):
         )
         if redis_validation.status:
             return redis_validation.first
-        raise ValueError("Header not found")
+        raise ValueError("Validation not found")
 
 
 class ValidationsBoth(RedisHeaderRetrieve, RedisValidationRetrieve):
@@ -155,14 +155,27 @@ class RetrievePage(BaseRouteModel):
         raise NotImplementedError("Cluster not found")
 
     @classmethod
-    def retrieve_page(cls, data: Any):
+    def retrieve_page(cls, data: Any) -> Optional[Dict[str, Any]]:
         """
         Retrieve page by event function code
+        Check reachable codes for user to render which page and components on Frontend
+        Uses:
+            Context Token Retriever to get user information from ACCESS_TOKEN
+            CategoryCluster Retrieve Cluster Retrieve cluster by name
+            Check available instructions of page and info user with it
+        Returns:
+            NAME=cluster_name.name,
+            PREFIX=cluster_name.PREFIX,
+            URL=dict(page_info).get("URL", None),
+            ICON=dict(page_info).get("ICON", None),
+            INFO=dict(page_info).get("INFO", None),
+            SUB_COMPONENTS=sub_components,
         """
         from Events.Engine import CategoryCluster
         from Events.JustEvents.events_file import retrieve_cluster_by_name
 
         reachable_codes = []
+        page_name = getattr(data, "page", None)
         if cls.context_retriever.token.is_employee:
             reachable_codes = (
                 cls.context_retriever.token.selected_company.reachable_event_codes
@@ -171,46 +184,36 @@ class RetrievePage(BaseRouteModel):
             reachable_codes = (
                 cls.context_retriever.token.selected_occupant.reachable_event_codes
             )
-        cluster_from_all_events = cls.get_site_cluster(page_name=data.page)
+        cluster_from_all_events = cls.get_site_cluster(page_name=page_name)
         if not cluster_from_all_events:
-            raise ValueError(f"Cluster not found : {data.page}")
+            raise ValueError(f"Cluster not found : {page_name}")
 
         cluster_name: CategoryCluster = retrieve_cluster_by_name(cluster_from_all_events)
         if not cluster_name:
             raise ValueError("Cluster not found")
 
-        page_info = cluster_name.retrieve_page_info().get(data.page, None)
+        page_info = cluster_name.retrieve_page_info().get(page_name, None)
         if not page_info:
             raise ValueError("Page not found")
 
-        endpoints: dict = dict(page_info).get("endpoints", {})
+        sub_components: dict = dict(page_info).get("SUB_COMPONENTS", {})
-        if not endpoints:
+        if not sub_components:
-            raise ValueError("Endpoints not found")
+            raise ValueError("Sub components not found")
 
         new_page_info_dict = dict(
-            name=cluster_name.name,
+            NAME=cluster_name.name,
-            prefix=cluster_name.PREFIX,
+            PREFIX=cluster_name.PREFIX,
-            url=dict(page_info).get("url", None),
+            URL=dict(page_info).get("URL", None),
-            icon=dict(page_info).get("icon", None),
+            ICON=dict(page_info).get("ICON", None),
-            mapping=cluster_name.MAPPING,
+            INFO=dict(page_info).get("INFO", None),
-            page_info=dict(page_info).get("page_info", None),
+            SUB_COMPONENTS=sub_components,
-            endpoints={},
+            # MAPPING=cluster_name.MAPPING,
-            language_models={},
-            instructions={},
         )
-        for key, event_codes in dict(endpoints).items():
+        for key, events in dict(sub_components).items():
             # Meaning client can reach this endpoint [] & [] intersection
-            if set(event_codes) & set(reachable_codes):
+            endpoint_event_codes = dict(events).get("ENDPOINTS", [])
-                language_models = dict(page_info).get("language_models", {})
+            new_page_info_dict["SUB_COMPONENTS"][key].pop("ENDPOINTS")
-                instructions = dict(page_info).get("instructions", {})
+            if not set(endpoint_event_codes) & set(reachable_codes):
-                new_page_info_dict["endpoints"][key] = True
+                new_page_info_dict["SUB_COMPONENTS"].pop(key)
-                if language_models.get(key, None):
+            
-                    if key in language_models[key].keys():   # key has sub key blocks inside lang model
+        return new_page_info_dict
-                        for key_model, val_model in dict(language_models[key]).items():
-                            if key_model in new_page_info_dict["endpoints"].keys():
-                                new_page_info_dict["language_models"][key_model] = language_models[key][key_model]
-                    else:
-                        new_page_info_dict["language_models"][key] = language_models[key]
-                if instructions.get(key, None):
-                    new_page_info_dict["instructions"][key] = instructions.get(key, None)
-        return new_page_info_dict

Events/AllEvents/validations/validation/models.py

@@ -1,13 +1,13 @@
 """
 Validation records request and response models.
 """
-
 from typing import Optional
 from pydantic import BaseModel
 
 
 class ValidationsPydantic(BaseModel):
     event_code: str
+    type: Optional[str] = "REQUEST"
     asked_field: Optional[str] = "all"
 
 

Events/Engine/abstract_class.py

@@ -53,11 +53,76 @@ class PageInfo:
           "/update?site=AccountCluster": ["/accounts/update"],
           "/create?site=AccountCluster": ["/accounts/create"],
         },
+
+    RedisValidation = dict(
+    NAME="AccountCluster",
+    PREFIX="/accounts",
+    URL="/dashboard?site=AccountCluster",
+    ICON="Building",
+    INFO={
+      "en": {
+        "page": "Account Records for reaching user all types account information",
+      },
+      "tr": {
+        "page": "Kullanıcı tüm hesap bilgilerine ulaşmak için Hesap Kayıtları",
+      },
+    },
+    SUB_COMPONENTS={
+      "/accounts/create": {
+        "SITE_URL": "/events/create?site=AccountCluster",
+        "COMPONENT": "Link",
+        "PREFIX_URL": "/accounts/create",
+        "INFO": {
+          "en": {
+            "page": "Create Account Records",
+            "actions": "Actions",
+            "table": "Table",
+          },
+          "tr": {
+            "page": "Hesap Kayıdı Oluştur",
+            "actions": "Aksiyonlar",
+            "table": "Tablo",
+          },
+        },
+        "INSTRUCTIONS": None,
+      },
+      "/accounts/list": {
+        "SITE_URL": "/events/dashboard?site=AccountCluster",
+        "COMPONENT": "Table",
+        "PREFIX_URL": "/accounts/list",
+        "INFO": {
+          "en": { "page": "List Account Records" },
+          "tr": { "page": "Hesap Kayıtlarını Listele" },
+        },
+        "INSTRUCTIONS": {
+          "headers": {
+            "store": True,
+            "url": "/validations/header",
+            "data": {
+              "event_code": "/accounts/list",
+              "asked_field": "headers",
+            },
+          },
+          "data": {
+            "store": True,
+            "url": "/accounts/list",
+            "data": {
+              "page": 1,
+              "limit": 1,
+              "order_by": "uu_id",
+              "order_type": "desc",
+              "query": None,
+            },
+          },
+        },
+      },
+    },
+  )
     """
 
     NAME: str
     PAGE_URL: str
-    PAGEINFO: Dict[str, Any]
+    INFO: Dict[str, Any]
     URL: str = ""
     ENDPOINTS: Dict[str, Any]
     LANGUAGE_MODELS: Dict[str, Any]
@@ -69,10 +134,10 @@ class PageInfo:
         name: str,
         icon: str,
         url: str,
-        endpoints: Dict[str, Any],
+        info: Optional[Dict[str, Any]] = None,
-        language_models: Dict[str, Any],
+        endpoints: Optional[Dict[str, Any]] = None,
-        page_info: Optional[Dict[str, Any]] = None,
+        language_models: Optional[Dict[str, Any]] = None,
-        sub_components: Optional[list["PageComponent"]] = None,
+        sub_components: Optional[list[Dict[str, Any]]] = None,
         instructions: Optional[Dict[str, Any]] = None,
     ):
         self.NAME = name
@@ -81,7 +146,7 @@ class PageInfo:
         self.URL = url
         self.SUB_COMPONENTS = sub_components
         self.ENDPOINTS = endpoints
-        self.PAGEINFO = page_info
+        self.INFO = info
         self.INSTRUCTIONS = instructions
 
     @property
@@ -95,17 +160,13 @@ class PageInfo:
     @property
     def as_dict(self):
         as_dict = {
-            "name": self.NAME,
+            "NAME": self.NAME,
-            "icon": self.ICON,
+            "ICON": self.ICON,
-            "url": self.URL,
+            "URL": self.URL,
-            "endpoints": self.ENDPOINTS,
+            "LANGUAGE_MODELS": self.LANGUAGE_MODELS,
-            "language_models": self.LANGUAGE_MODELS,
+            "INFO": self.INFO,
-            "page_info": self.PAGEINFO,
+            "SUB_COMPONENTS": self.SUB_COMPONENTS,
         }
-        if self.INSTRUCTIONS:
-            as_dict["instructions"] = self.INSTRUCTIONS
-        if self.SUB_COMPONENTS:
-            as_dict["sub_components"] = [i.as_dict() for i in self.SUB_COMPONENTS]
         return as_dict
 
 
@@ -354,7 +415,7 @@ class CategoryCluster:
             return {"prefix": self.PREFIX, "mapping": self.MAPPING, **page_infos}
         if hasattr(self.PAGEINFO, "as_dict"):
             return {"prefix": self.PREFIX, "mapping": self.MAPPING, **self.PAGEINFO.as_dict}
-        return
+        raise ValueError("PAGE_INFO not found")
 
 
 class LanguageModels:
@@ -363,6 +424,7 @@ class LanguageModels:
     PREFIX_URL: str = ""
     PAGE_INFO: dict
     STATIC_PATH: str = STATIC_PATH
+    ICON: str = ""
 
     def as_dict(self):
         return {
@@ -370,6 +432,7 @@ class LanguageModels:
             "COMPONENT": self.COMPONENT,
             "PREFIX_URL": self.PREFIX_URL,
             "PAGE_INFO": self.PAGE_INFO,
+            "ICON": self.ICON,
         }