ApiLogicServer 14.3.14__py3-none-any.whl → 14.3.25__py3-none-any.whl

api_logic_server_cli/api_logic_server.py

@@ -3,7 +3,7 @@
 '''
 ApiLogicServer CLI: given a database url, create [and run] customizable ApiLogicProject.
     * Basically clones prototype project (api_logic_server_cli/prototypes/base), and creates:
-        * database/models.py for SQLAlchemy, using modified sqlacodegen & safrs metadata
+        * database/models.py for SQLAlchemy,` using modified sqlacodegen & safrs metadata
         * ui/admin/admin.yaml for the Admin App     - using introspected models.py
         * api/expose_api_models.py for a safrs api  - using introspected models.py
     * Special provisions for NW Sample, to show customizations.
@@ -12,9 +12,11 @@ ApiLogicServer CLI: given a database url, create [and run] customizable ApiLogic
 Called from api_logic_server_cli.py, by instantiating the ProjectRun object.
 '''
 
-__version__ = "14.03.14"
+__version__ = "14.03.25"
 recent_changes = \
     f'\n\nRecent Changes:\n' +\
+    "\t03/30/2024 - 14.03.25: WebGenAI fixes for Kafka and Keycloak \n"\
+    "\t03/19/2024 - 14.03.20: licensed webgenai docker, [87] sra fix for home.js \n"\
     "\t02/26/2024 - 14.03.14: [85: reserved words], genai_demo fixes \n"\
     "\t02/16/2024 - 14.03.12: Docker w/ std container, mgr assistant for local WebG \n"\
     "\t02/13/2024 - 14.03.11: fixes [78: Keycloak, 79: boolean defaulting, 80: Send If missing attribute] \n"\
@@ -1110,9 +1112,12 @@ class ProjectRun(Project):
         app_logger.debug(f'.. overridden from env variable: {CONFIG_URI}')
 
     """
-        config_insert = config_insert.replace("<CONFIG_URI_VALUE>", "{" + f'{CONFIG_URI}' + "}")
         config_file = f'{self.project_directory}/config/config.py'
         config_built = create_utils.does_file_contain(search_for=CONFIG_URI, in_file=config_file)
+        if self.add_auth_in_progress and self.auth_provider_type == 'sql' and self.bind_key == 'authentication' and self.auth_db_url == 'auth':
+            pass
+            # config_built = True  # already built in add_auth
+        config_insert = config_insert.replace("<CONFIG_URI_VALUE>", "{" + f'{CONFIG_URI}' + "}")
         if not config_built:
             create_utils.insert_lines_at(lines=config_insert,
                                         at="# End Multi-Database URLs (from ApiLogicServer add-db...)",
@@ -1364,9 +1369,12 @@ from database import <project.bind_key>_models
             log.debug("  3. Update config at: SQLALCHEMY_DATABASE_URI_AUTHENTICATION = '")
         log.debug("==================================================================\n")
         config_file_name = f'{self.project_directory_path.joinpath("config/config.py")}'
-        create_utils.assign_value_to_key_in_file(value=self.abs_db_url, 
-                    key="    SQLALCHEMY_DATABASE_URI_AUTHENTICATION",
-                    in_file=config_file_name)
+        if self.abs_db_url.endswith('database/authentication_db.sqlite'):
+            pass
+        else:
+            create_utils.assign_value_to_key_in_file(value=self.abs_db_url, 
+                        key="    SQLALCHEMY_DATABASE_URI_AUTHENTICATION",
+                        in_file=config_file_name)
 
         self.run = save_run
         self.command = save_command

api_logic_server_cli/api_logic_server_info.yaml

@@ -1,3 +1,3 @@
-last_created_date: February 17, 2025 13:08:45
-last_created_project_name: ../../../servers/ucf
-last_created_version: 14.03.12
+last_created_date: March 26, 2025 13:40:07
+last_created_project_name: genai_demo
+last_created_version: 14.03.22

api_logic_server_cli/cli.py

@@ -738,6 +738,44 @@ def genai_logic(ctx, using, genai_version: str, retries: int, suggest: click.BOO
     log.info("")
 
 
+@main.command("genai-graphics", cls=HideDunderCommand)
+@click.option('--using',
+              default=f'docs/graphics',
+              help="File or dir")
+@click.option('--genai-version', 'genai_version',
+              default='gpt-4o',
+              help="Eg, gpt-3.5-turbo, gpt-4o")
+@click.pass_context
+def genai_graphics(ctx, using, genai_version: str):
+    """
+        Adds (or suggests) logic to current project.
+    """
+    global command
+    project_dir = resolve_blank_project_name('')
+    project_name = Path(project_dir).name
+    project = PR.ProjectRun(command="add_security", 
+              project_name=project_name, 
+              db_url="",
+              execute=False
+              )
+    project.project_directory, project.api_name, project.merge_into_prototype = \
+        create_utils.get_project_directory_and_api_name(project)
+    project.project_directory_actual = os.path.abspath(os.getcwd())  # make path absolute, not relative (no /../)
+    project.project_directory_path = Path(project.project_directory_actual)
+    models_py_path = project.project_directory_path.joinpath('database/models.py')
+    project.abs_db_url, project.nw_db_status, project.model_file_name = \
+        create_utils.get_abs_db_url("0. Using Sample DB", project, is_auth=True)
+
+    if not models_py_path.exists():
+        log.info(f'... Error - does not appear to be a project: {str(project.project_directory_path)}')
+        log.info(f'... Typical usage - cd into project, use --project_name=. \n')
+        exit (1)
+    from api_logic_server_cli.genai.genai_graphics import GenAIGraphics
+    genai_graphics = GenAIGraphics(using=using, project=project, genai_version=genai_version)
+    pass
+    log.info("")
+
+
 @main.command("genai-create", cls=HideDunderCommand) 
 @click.option('--project-name', 'project_name',
               default=f'{last_created_project_name}',

api_logic_server_cli/create_from_model/ont_build.py

@@ -196,7 +196,7 @@ class OntBuilder(object):
         #to_dir = self.project.project_directory_path.joinpath(f'ui/{self.app}/')
         #shutil.copytree(from_dir, to_dir, dirs_exist_ok=True)  # create default app files
 
-        entity_favorites = self.build_entity_favorites(app_model)
+        entity_favorites = self.build_entity_favorites()
         
         for setting_name, each_setting in app_model.settings.style_guide.items():
             #style guide
@@ -221,19 +221,40 @@ class OntBuilder(object):
         if getattr(self.global_values,"exclude_listpicker",None) is None:
             self.global_values["exclude_listpicker"] = False
             
-        for each_entity_name, each_entity in app_model.entities.items():
-            if self.api_endpoint and each_entity_name != self.api_endpoint:
-                continue
-            if  each_entity.get("exclude", "false") == "true":
-                continue
-            entity_name = each_entity_name
-            
-            # Each entity will have a home, new, detail, routing template
-            self.generate_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
-            self.generate_new_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
-            self.generate_detail_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
-            self.generate_routing(app_path, each_entity_name, each_entity, entity_name)
-            self.generate_card_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
+        # If the application yaml has been included = we will use the values from the yaml
+        if "application" in app_model:
+            for app in app_model.application:
+                # yaml may have multiple apps = only work on the one selected app-build --app={app}
+                if self.app != app:
+                    continue
+                menu_group = app_model.application[app]["menu_group"] 
+                for mg in menu_group:
+                    for mi in menu_group[mg]["menu_item"]:
+                        each_entity =app_model.entities[mi]
+                        for p in menu_group[mg]["menu_item"][mi]["page"]:
+                            if p == 'home':
+                                self.generate_home_template(app_path, entity_favorites, mi, each_entity, mi)
+                            elif p == "detail":
+                                self.generate_detail_template(app_path, entity_favorites, mi, each_entity, mi)
+                            elif p == "new":
+                                self.generate_new_template(app_path, entity_favorites, mi, each_entity, mi)
+                            
+                        self.generate_routing(app_path, mi, each_entity, mi)
+                        self.generate_card_home_template(app_path, entity_favorites, mi, each_entity, mi)
+        else:
+            for each_entity_name, each_entity in app_model.entities.items():
+                if self.api_endpoint and each_entity_name != self.api_endpoint:
+                    continue
+                if  each_entity.get("exclude", "false") == "true":
+                    continue
+                entity_name = each_entity_name
+                
+                # Each entity will have a home, new, detail, routing template
+                self.generate_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
+                self.generate_new_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
+                self.generate_detail_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
+                self.generate_routing(app_path, each_entity_name, each_entity, entity_name)
+                self.generate_card_home_template(app_path, entity_favorites, each_entity_name, each_entity, entity_name)
             
         # menu groups/routing and service config
         self.generate_menu_services(app_path, app_model)
@@ -278,7 +299,7 @@ class OntBuilder(object):
         write_file(app_path, entity_name, "", ".module.ts", module)
 
     def generate_menu_services(self, app_path, app_model):
-        entities = app_model.entities.items()
+        entities = self.build_entity_list_from_app()
         sidebar_menu = self.gen_sidebar_routing("main_routing.jinja", entities=entities)
         write_root_file(
             app_path, "main", "main-routing.module.ts", sidebar_menu
@@ -295,6 +316,25 @@ class OntBuilder(object):
             source=app_menu_config,
         )
 
+    def build_entity_list_from_app(self):
+        entity_list = self.app_model.entities.items()
+        if "application" in self.app_model:
+            entities = []
+            for app in self.app_model.application:
+                # yaml may have multiple apps = only work on the one selected app-build --app={app}
+                if self.app != app:
+                    continue
+                menu_group = self.app_model.application[app]["menu_group"] 
+                for mg in menu_group:
+                    for mi in menu_group[mg]["menu_item"]:
+                        each_entity = self.app_model.entities[mi]
+                        for each_entity_name, each_entity in entity_list:
+                            if each_entity_name == mi:
+                                entities.append((mi,each_entity))
+            return entities
+                        
+        return entity_list
+
     def generate_card_home_template(self, app_path, entity_favorites, each_entity_name, each_entity, entity_name):
         card_template = self.load_card_template("card.component.html", each_entity_name, entity_favorites)
         ts = self.load_ts("card.component.jinja", each_entity_name, each_entity, entity_favorites)
@@ -304,25 +344,38 @@ class OntBuilder(object):
         write_card_file(app_path, entity_name,  "-card.component.scss", card_scss)
 
     def generate_detail_template(self, app_path, entity_favorites, each_entity_name, each_entity, entity_name):
-        detail_template_name = self.find_template(each_entity, "detail_template","detail_template.html")
+        if page := self.get_page("detail", each_entity_name):
+            detail_template_name = page.template_name
+            ts_name = page.typescript_name
+        else:
+            detail_template_name = self.find_template(each_entity, "detail_template","detail_template.html")
+            ts_name = "detail_component.jinja"
         detail_template = self.load_detail_template(detail_template_name, each_entity_name, each_entity, entity_favorites)
-        ts = self.load_ts("detail_component.jinja", each_entity_name, each_entity, entity_favorites)
+        ts = self.load_ts(ts_name, each_entity_name, each_entity, entity_favorites)
         detail_scss = self.get_template("detail.scss").render()
         write_file(app_path, entity_name, "detail", "-detail.component.html", detail_template)
         write_file(app_path, entity_name, "detail", "-detail.component.ts", ts)
         write_file(app_path, entity_name, "detail", "-detail.component.scss", detail_scss)
 
     def generate_new_template(self, app_path, entity_favorites, each_entity_name, each_entity, entity_name):
-        new_template_name = self.find_template(each_entity, "new_template","new_template.html")
+        if page := self.get_page("new", each_entity_name):
+            new_template_name = page.template_name
+            ts_name = page.typescript_name
+        else:
+            new_template_name = self.find_template(each_entity, "new_template","new_template.html")
+            ts_name = "new_component.jinja"
         new_template = self.load_new_template(new_template_name, each_entity_name, each_entity, entity_favorites)
-        ts = self.load_ts("new_component.jinja", each_entity_name, each_entity, entity_favorites)
+        ts = self.load_ts(ts_name, each_entity_name, each_entity, entity_favorites)
         new_scss = self.get_template("new.scss").render()
         write_file(app_path, entity_name, "new", "-new.component.html", new_template)
         write_file(app_path, entity_name, "new", "-new.component.ts", ts)
         write_file(app_path, entity_name, "new", "-new.component.scss", new_scss)
 
     def generate_home_template(self, app_path, entity_favorites, each_entity_name, each_entity, entity_name):
-        home_template_name = self.find_template(each_entity, "home_template","home_template.html")
+        if page := self.get_page("home", each_entity_name):
+            home_template_name = page.template_name
+        else:
+            home_template_name = self.find_template(each_entity, "home_template","home_template.html")
         home_template = self.load_home_template(home_template_name, each_entity, each_entity_name, entity_favorites)
         if home_template_name == "grid_template.html":
             home_scss = self.get_template("grid_home.scss").render(entity=each_entity_name)
@@ -382,9 +435,10 @@ class OntBuilder(object):
             return entity[template_name]
         else:
             return default_template
-    def build_entity_favorites(self, app_model):
+    def build_entity_favorites(self):
         entity_favorites = []
-        for each_entity_name, each_entity in app_model.entities.items():
+        entity_list = self.build_entity_list_from_app()
+        for each_entity_name, each_entity in entity_list:
             datatype = 'INTEGER'
             pkey_datatype = 'INTEGER'
             primary_key = each_entity["primary_key"]
@@ -449,7 +503,8 @@ class OntBuilder(object):
             setattr(self,setting_name,each_setting)
             
     def get_entity(self, entity_name):
-        for each_entity_name, each_entity in self.app_model.entities.items():
+        entity_list = self.build_entity_list_from_app()
+        for each_entity_name, each_entity in entity_list:
             if each_entity_name == entity_name:
                 return each_entity
         
@@ -479,7 +534,7 @@ class OntBuilder(object):
         # using the `self.get_template` method, and then processes the template by rendering it with a
         # dictionary of variables.
         template = self.get_template(template_name)
-        entity_vars = self.get_entity_vars(entity_name=entity_name,entity=entity)
+        entity_vars = self.get_entity_vars(entity_name=entity_name,entity=entity, page_name="home")
         fks = get_foreign_keys(entity, favorites)
         defaultValues = self.get_default_values(fks, entity)
         entity_vars["defaultValues"] = str(defaultValues)
@@ -506,7 +561,7 @@ class OntBuilder(object):
             tab_name, tab_vars = self.get_tab_attrs(detail_entity, parent_entity, tab_group)
             entity_vars['tableAttr'] = f'{tab_group["resource"]}Table'
             tab_vars["table_columns"] = self.get_entity_columns(detail_entity)
-            col_vars = self.get_entity_vars(detail_entity.type,detail_entity)
+            col_vars = self.get_entity_vars(detail_entity.type,detail_entity, 'detail')
             tab_vars |= col_vars
             tab_vars["tabTitle"] = tab_name
             tab_vars ["tableAttr"] = f'{tab_group["resource"]}Table'
@@ -525,14 +580,18 @@ class OntBuilder(object):
             row_cols.append(rv)
         return row_cols
 
-    def get_entity_vars(self, entity_name:str, entity):
+    def get_entity_vars(self, entity_name:str, entity, page_name: str = "home") -> dict:
         new_mode =  self.find_template(entity, "mode", self.new_mode)
         if getattr(entity,"tab_groups",  None) is None or len(entity.tab_groups) == 0:
             new_mode = "dialog"
         favorite =  self.find_template(entity,"favorite","")
         fav_column = find_column(entity,favorite)
-        cols = get_columns(entity)
-        visible_columns = get_visible_columns(entity, True)
+        if page := self.get_page(page_name, entity.type):
+            cols = page.visible_columns.replace(",",";",100)
+            visible_columns = page.visible_columns.replace(",",";",100)
+        else:
+            cols = self.get_columns(entity)
+            visible_columns = self.get_visible_columns(entity, True)
         fav_column_type = "VARCHAR" if fav_column and fav_column.type.startswith("VARCHAR") else "INTEGER"
         key =  make_keys(entity["primary_key"])
         entity_type = f"{entity.type}"
@@ -582,6 +641,52 @@ class OntBuilder(object):
         self.add_title(entity_name, f"{title[:1].upper()}{title[1:]}")
         entity_var |= self.global_values
         return entity_var
+    def get_visible_columns(self, entity,default:bool = True) -> str:
+        cols = []
+        for column in entity.columns:
+            visible = column.visible if hasattr(column, "visible") and column.visible != DotMap() else default
+            if visible:
+                cols.append(column.name)
+        return ";".join(cols)
+    
+    def get_columns(self, entity) -> str:
+        cols = []
+        for column in entity.columns:
+            cols.append(column.name)
+        return ";".join(cols)
+    
+    def get_page(self, page_name, entity_name: str) -> dict:
+        if "application" in self.app_model:
+            for app in self.app_model.application:
+                # yaml may have multiple apps = only work on the one selected app-build --app={app}
+                if self.app != app:
+                    continue
+                menu_group = self.app_model.application[app]["menu_group"] 
+                for mg in menu_group:
+                    for mi in menu_group[mg]["menu_item"]:
+                        #each_entity = self.app_model.entities[mi]
+                        if mi == entity_name:
+                            for p in menu_group[mg]["menu_item"][mi]["page"]:
+                                if page_name == p:
+                                    return menu_group[mg]["menu_item"][mi]["page"][p]
+        return None
+    def get_menu_group(self):
+        menu_groups = []
+        entity_list = self.build_entity_list_from_app()
+        # menu_group = {"group":group, "entities": entities}
+        if "application" in self.app_model:
+            for app in self.app_model.application:
+                # yaml may have multiple apps = only work on the one selected app-build --app={app}
+                if self.app != app:
+                    continue
+                menu_group = self.app_model.application[app]["menu_group"]
+                for mg in menu_group:
+                    entities = []
+                    for mi in menu_group[mg]["menu_item"]:
+                        for entity_name, each_entity in entity_list:
+                            if entity_name == mi:
+                                get_group(menu_groups, mg, each_entity)
+        return menu_groups
 
     def add_title(self, title, entity_name):
         for v in self.title_translation:
@@ -785,7 +890,7 @@ class OntBuilder(object):
         return "VARCHAR" if fk_column and fk_column.type.startswith("VARCHAR") else fk_column.type if hasattr(fk_column,"type") else "INTEGER"
     def load_tab_template(self, entity, parent_entity, template_var: any, parent_pkey:str) -> str:
         tab_template = self.tab_panel
-        entity_vars = self.get_entity_vars(entity.type, entity)
+        entity_vars = self.get_entity_vars(entity.type, entity, 'detail')
         template_var |= entity_vars
         row_cols = []
         for column in entity.columns:
@@ -819,7 +924,8 @@ class OntBuilder(object):
             if fk_tab["direction"] == "tomany":
                 tab_name, tab_vars = self.get_tab_attrs(entity, parent_entity, fk_tab)
                 primaryKey = make_keys(entity["primary_key"])
-                for each_entity_name, each_entity in self.app_model.entities.items():
+                entity_list = self.build_entity_list_from_app()
+                for each_entity_name, each_entity in entity_list:
                     if each_entity_name == tab_name:
                         template = self.load_tab_template(each_entity,entity,tab_vars, primaryKey )
                         panels.append(template)
@@ -970,11 +1076,13 @@ class OntBuilder(object):
             "routing_module": f"{entity_first_cap}RoutingModule",
         }
         additional_routes = ""
+        entity_list = self.build_entity_list_from_app()
         for tg in entity.tab_groups:
             if tg.direction == "tomany":
                 var["tab_name"] = tg.resource
                 var["tab_key"] = tg.fks[0]
-                additional_routes += f",{self.detail_route_template.render(var)}"
+                if next((e for e in entity_list if e[0] == tg.resource), None):
+                    additional_routes += f",{self.detail_route_template.render(var)}"
 
         var["additional_routes"] = additional_routes
         return template.render(var)
@@ -1007,13 +1115,13 @@ class OntBuilder(object):
         )
         import_template = Template("import {{ card_component }} from './{{ name }}-card/{{ name }}-card.component';")
         
-        #TODO create menu_group - default to data
-        groups = []
-        menu_separator = ""
         menu_groups = []
-        for each_entity_name, each_entity in entities:
-            group =  getattr(each_entity, "group") or "data" #TEMPORARY TODO
-            get_group(groups, group, each_entity)
+        menu_separator = ""
+        groups = self.get_menu_group()
+        if len(groups) == 0:
+            for each_entity_name, each_entity in entities:
+                group =  getattr(each_entity, "group") or "data" 
+                get_group(groups, group, each_entity)
         
         import_cards = []
         card_components = []    
@@ -1024,10 +1132,10 @@ class OntBuilder(object):
             menuitems = []
             sep = ""
             for entity in group_entities:
-                name = entity.type
+                name = entity["type"]
                 title = entity["label"].upper().replace("*","") if hasattr(entity, "label") and entity.label != DotMap() else name.upper()
                 name_first_cap = name[:1].upper()+ name[1:]
-                menuitem = menu_item_template.render(name=name, title=title, name_upper=each_entity_name.upper())
+                menuitem = menu_item_template.render(name=name, title=title, name_upper=name.upper())
                 menuitem = f"{sep}{menuitem}"
                 menuitems.append(menuitem)
                 card_component = "{ " + f"{name_first_cap}CardComponent" +" }"
@@ -1041,15 +1149,15 @@ class OntBuilder(object):
             menu_groups.append(mg)
 
         return template.render(menu_groups=menu_groups, import_cards=import_cards, card_components=card_components)
-def get_group(groups:list, group:str, entity_name: str):
+def get_group(groups:list, group:str, entity: any):
     entities = []
     for g in groups:
         if g["group"] == group:
             entities = g["entities"]
-            entities.append(entity_name)
+            entities.append(entity)
             g["entities"] = entities
             return
-    entities.append(entity_name)
+    entities.append(entity)
     menu_group = {"group":group, "entities": entities}
     groups.append(menu_group)
 
@@ -1119,7 +1227,6 @@ def get_foreign_keys(entity:any, favorites:any ) -> list:
     attrType = "INTEGER"
     for fkey in entity.tab_groups:
         if fkey.direction in ["tomany", "toone"]:
-            # attrType = "int" # get_column_type(entity, fkey.resource, fkey.fks)  # TODO
             fav_col, attrType = find_favorite(favorites, fkey.resource)
             fk = {
                 "attrs": fkey.fks,
@@ -1186,24 +1293,6 @@ def write_json_filename(app_path: Path, file_name: str, source: str):
     with open(f"{directory}/{file_name}", "w") as file:
         file.write(source)
 
-
-def get_visible_columns(entity,default:bool = True) -> str:
-    cols = ""
-    sep = ""
-    for column in entity.columns:
-        visible = column.visible if hasattr(column, "visible") and column.visible != DotMap() else default
-        if visible:
-            cols += f"{sep}{column.name}"
-            sep = ";"
-    return cols
-
-def get_columns(entity) -> str:
-    cols = ""
-    sep = ""
-    for column in entity.columns:
-        cols += f"{sep}{column.name}"
-        sep = ";"
-    return cols
 def find_column(entity, column_name) -> any:
     return next(
         (column for column in entity.columns if column.name == column_name),
@@ -1239,15 +1328,6 @@ def find_favorite(entity_favorites: any, entity_name:str):
             return entity_favorite["favorite"], datatype
     return "Id", "INTEGER"
 
-def get_column_type(app_model: any, fkey_resource: str, attrs: any) -> str:
-    # return datatype (and listcols?)
-    for each_entity_name, each_entity in app_model.entities.items():
-        if each_entity_name == fkey_resource:
-            for column in  each_entity.columns:
-                if column in attrs:
-                    return column.type
-    return "int"
-
     
 def translation_service(titles:dict,from_lang:str="en", to_lang:str="es") -> str:
     # this is very slow since it does title by title

api_logic_server_cli/create_from_model/ont_create.py

@@ -56,9 +56,9 @@ class OntCreator(object):
     num_related = 0
 
     def __init__(self,
-                 project: Project,
-                 admin_app: str = "admin",
-                 app: str = "app"):
+                project: Project,
+                admin_app: str = "admin",
+                app: str = "app"):
         self.project = project
         self.admin_app = admin_app
         self.app = app
@@ -137,7 +137,12 @@ class OntCreator(object):
             resource = resource_list[each_resource_name]
             for each_primary_key_attr in resource.primary_key:
                 app_model_out.entities[each_resource_name].primary_key.append(each_primary_key_attr.name)
-
+        
+        ###############################
+        # App/MenuGroup/MenuItem/Page #
+        ###############################
+        self.build_application(app_model_out)
+        
         ########################
         # No good, dirty rotten kludge for api emulation
         ########################
@@ -157,14 +162,67 @@ class OntCreator(object):
         if show_messages:
             log.info("\nEdit the add_model.yaml as desired, and ApiLogicServer app-build\n")
             
+    def build_application(self, app_model_out: DotMap):
+        '''
+            Each Application has a MenuGroup, which has MenuItems, which have Pages 
+            Pages are New, Home, Detail (used by app-build)
+            This function builds the app_model_out.yaml
+        '''
+        this_app = {
+            "name": self.app,
+            "description": "generated Ontimize application"
+            # this_app["template_dir"] = f"{self.app}/templates"
+        }
+        a = {self.app: this_app }
+        # MENU GROUP
+        mg_list = {}
+        this_menu_group = {
+            "menu_name": "data",
+            "icon": "edit_square",
+            "opened":  True,
+            "menu_title": "data"  
+            # "order: mg["menu_order"]  # TODO
+        }
+        mg_list = {"data": this_menu_group}
+        this_app["menu_group"] = mg_list
+        # MENU ITEM
+        mi_list = {}
+        for entity in app_model_out.entities:
+            cols = []
+            cols.extend(column.name for column in app_model_out.entities[entity].columns)
+            columns = ",".join(cols)
+            this_menu_item = {
+                "menu_name": entity,
+                "menu_title": entity,
+                "template_name": "module.jinja",
+                "icon": "edit_square",
+            }
+            mi_list[entity] = this_menu_item  
+            # PAGE (new, home, detail)
+            p = {}
+            for page_name in ["new", "home", "detail"]:
+                ts_type = "template" if page_name == "home" else "component"
+                this_page = {
+                    "title": entity,
+                    "page_name": page_name,
+                    "template_name": f"{page_name}_template.html",
+                    "typescript_name": f"{page_name}_{ts_type}.jinja",
+                    "columns": columns,
+                    "visible_columns": columns,
+                    "include_children": True
+                }
+                p[page_name] = this_page
+            this_menu_item["page"] = p
+            this_menu_group["menu_item"] = mi_list
+        app_model_out.application = a
     def create_model_entity(self, each_resource, resources: list) -> DotMap:
         each_resource.favorite = each_resource.user_key
-        each_resource.exclude = "false"
+        #each_resource.exclude = "false"
         each_resource.label = each_resource.type # resources[each_resource.type].table_name
-        each_resource.new_template = "new_template.html"
-        each_resource.home_template = "home_template.html"
-        each_resource.detail_template = "detail_template.html"
-        each_resource.mode = "tab"
+        #each_resource.new_template = "new_template.html"
+        #each_resource.home_template = "home_template.html"
+        #each_resource.detail_template = "detail_template.html"
+        #each_resource.mode = "tab"
         each_resource.pop('user_key')
         return each_resource
 

api_logic_server_cli/create_from_model/safrs-react-admin-npm-build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "/admin-app/static/css/main.a6dcf785.css",
-    "main.js": "/admin-app/static/js/main.7c8c0e37.js",
+    "main.js": "/admin-app/static/js/main.671002cd.js",
     "static/js/325.b8967990.chunk.js": "/admin-app/static/js/325.b8967990.chunk.js",
     "static/css/4284.c1cb3055.chunk.css": "/admin-app/static/css/4284.c1cb3055.chunk.css",
     "static/js/4284.94d7d6c7.chunk.js": "/admin-app/static/js/4284.94d7d6c7.chunk.js",
@@ -120,7 +120,7 @@
     "static/media/uicons-brands-XJPKRNBN.woff2": "/admin-app/static/media/uicons-brands-XJPKRNBN.033917e9fd41cfa9727c.woff2",
     "index.html": "/admin-app/index.html",
     "main.a6dcf785.css.map": "/admin-app/static/css/main.a6dcf785.css.map",
-    "main.7c8c0e37.js.map": "/admin-app/static/js/main.7c8c0e37.js.map",
+    "main.671002cd.js.map": "/admin-app/static/js/main.671002cd.js.map",
     "325.b8967990.chunk.js.map": "/admin-app/static/js/325.b8967990.chunk.js.map",
     "4284.c1cb3055.chunk.css.map": "/admin-app/static/css/4284.c1cb3055.chunk.css.map",
     "4284.94d7d6c7.chunk.js.map": "/admin-app/static/js/4284.94d7d6c7.chunk.js.map",
@@ -212,6 +212,6 @@
   },
   "entrypoints": [
     "static/css/main.a6dcf785.css",
-    "static/js/main.7c8c0e37.js"
+    "static/js/main.671002cd.js"
   ]
 }