ApiLogicServer 14.3.20__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,10 +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.20"
+__version__ = "14.03.25"
 recent_changes = \
     f'\n\nRecent Changes:\n' +\
-    "\t03/19/2024 - 14.03.20: [87] sra fix for home.js, licensed webgenai docker \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"\

api_logic_server_cli/api_logic_server_info.yaml

@@ -1,3 +1,3 @@
-last_created_date: March 14, 2025 17:03:35
-last_created_project_name: samples/nw_sample_nocust
-last_created_version: 14.03.16
+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/genai/genai.py

@@ -27,6 +27,7 @@ from api_logic_server_cli.genai.genai_svcs import K_LogicBankOff
 from api_logic_server_cli.genai.genai_svcs import K_LogicBankTraining
 from api_logic_server_cli.genai.genai_svcs import fix_and_write_model_file as fix_and_write_model_file_svcs
 import api_logic_server_cli.genai.genai_svcs as genai_svcs
+from api_logic_server_cli.genai.genai_graphics import GenAIGraphics
 
 log = logging.getLogger(__name__)
 
@@ -575,7 +576,7 @@ class GenAI(object):
         except:  # intentional try/catch/bury - it's just docs, so don't fail
             import traceback
             log.error(f"\n\nERROR creating genai project docs: {docs_dir}\n\n{traceback.format_exc()}")
-        pass
+        genai_graphics = GenAIGraphics(project=self.project, using=None, genai_version=self.project.genai_version)
 
     def save_prompt_messages_to_system_genai_temp_project(self):
         """

api_logic_server_cli/genai/genai_graphics.py

@@ -0,0 +1,165 @@
+import shutil
+from typing import Dict, List
+from api_logic_server_cli.cli_args_project import Project
+import logging
+from pathlib import Path
+import importlib
+from api_logic_server_cli.genai.genai_utils import call_chatgpt
+import requests
+import os
+import datetime
+import create_from_model.api_logic_server_utils as utils
+import time
+from openai import OpenAI
+from api_logic_server_cli.genai.genai_svcs import WGResult
+from api_logic_server_cli.genai.genai_svcs import Rule
+import api_logic_server_cli.genai.genai_svcs as genai_svcs
+import json
+from typing import List, Dict
+from pydantic import BaseModel
+from dotmap import DotMap
+from natsort import natsorted
+import glob
+import create_from_model.api_logic_server_utils as create_utils
+from jinja2 import Environment, FileSystemLoader
+
+
+K_data_model_prompt = "Use SQLAlchemy to create"
+
+log = logging.getLogger(__name__)
+
+class GenAIGraphics(object):
+    """ 
+    Adds Graphics to **existing** projects (genai project or als project):
+    * adds `api/api_discovery` file(s) to project
+    * adds html to `home.js` (?  currently just creating a 1-off in api/api_discovery)
+
+    Invoked from:
+    1. **New GenAI Project:** for newly created project (e,g, mgr system/genai/examples/genai_demo/genai_demo.prompt)
+        * `--using` is None ==> Docs folder already has WGResponse.graphics[]      
+    2. **Existing Project:** CLI/genai-graphics existing project, using *docs/graphics* eg 
+        * `--using`  ==> Call ChatGPT for WGResponse.graphics `<project>/docs/graphics/*.prompt`  
+        * note: dbml not rebuilt after rebuild-from-db
+    3. **Existing WG Project:** in-place (do not create new project with new test data)
+        *  Same as #1, but requires WG UI change ('in place', 'graphics' button, ...) to use genai_graphics cmd
+
+
+    **Issue:** what is the persistence model for graphics?  (eg, in docs/graphics, or docs/response.json, wg database??)
+    * if existing wg project, is docs/response.json updated?
+
+    Open Issues
+    * How to integrate with als/wg home.js?
+    * How to enforce licensing?
+    * How to choose graph vs chart?
+    
+    """
+
+    def __init__(self, project: Project, using: str, genai_version: str):
+        """ 
+        Add graphics to existing projects - [see docs](https://apilogicserver.github.io/Docs/WebGenAI-CLI/#add-graphics-to-existing-projects)
+
+        see key_module_map() for key methods
+
+        """        
+
+        self.project = project        
+        self.project.genai_using = using
+        self.manager_path = genai_svcs.get_manager_path()
+
+        if using is None:           # New GenAI Project: use docs/response.json
+            graphics_response_path = self.project.project_directory_path.joinpath('docs/response.json')
+        else:                       # Existing (any) Project - use graphics files  -> ChatGPT
+            graphics_response_path = self.project.project_directory_path.joinpath('docs/graphics/response.json')
+            if bypass_for_debug := False:
+                pass
+            else:
+                prompt = genai_svcs.read_and_expand_prompt(self.manager_path.joinpath('system/genai/prompt_inserts/graphics_request.prompt'))
+                prompt_lines = prompt.split('\n')                   # ChatGPT instructions
+                prompt_lines.extend(self.append_data_model())       # add data model
+                prompt_lines.extend(self.append_graphics_files())   # and the users's requests from graphics files
+                prompt_str = "\n".join(prompt_lines)
+                
+                prompt_messages : List[ Dict[str, str] ] = []  # prompt/response conversation to be sent to ChatGPT
+                prompt = genai_svcs.get_prompt_you_are()
+                prompt["content"] = prompt_str
+                prompt_messages.append( prompt )
+                genai_svcs.call_chatgpt(messages = prompt_messages, 
+                                        using = self.project.project_directory_path.joinpath('docs/graphics'),
+                                        api_version=genai_version)
+
+        self.process_graphics_response(graphics_response_path)
+        pass
+
+    def process_graphics_response(self, graphics_response_path: Path):
+        """ Process graphics response from ChatGPT graphics_response_path """
+
+        graphic_services_header_path = self.manager_path.joinpath('system/genai/graphics_templates/graphics_services.py')
+        graphics_services_path = self.project.project_directory_path.joinpath('api/api_discovery/graphics_services.py')
+        shutil.copy(graphic_services_header_path, graphics_services_path)
+
+        # open and read the graphics_response_path json file
+        assert graphics_response_path.exists(), f'Graphics response file not found: {graphics_response_path}'
+        with open(graphics_response_path, 'r') as file:
+            graphics_response = json.load(file)
+            log.info(f'Graphics response loaded from {graphics_response_path}')
+        graphics = graphics_response['graphics']
+        for each_graphic in graphics:  # add each service to api/api_discovery
+            self.fix_sqlalchemy_query(each_graphic)
+            env = Environment(loader=FileSystemLoader(self.manager_path.joinpath('system/genai/graphics_templates')))
+
+            template = env.get_template('service_template_jsonapi_rpc.jinja')
+            rendered_result = template.render( **each_graphic )
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/graphics_services.py'), 'a') as out_file:
+                out_file.write(rendered_result)
+
+            template = env.get_template('html_template.jinja')
+            rendered_result = template.render( **each_graphic )
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/{each_graphic['name']}.html'), 'w') as out_file:
+                out_file.write(rendered_result)
+
+            with open(self.project.project_directory_path.joinpath(f'api/api_discovery/{each_graphic['name']}.sql'), 'w') as out_file:
+                out_file.write(each_graphic['sql_query'])
+
+            log.info(f'.. added service: {each_graphic['name']} to api_discovery')
+        pass
+
+    def fix_sqlalchemy_query(self, graphic: Dict):
+        """ Fix the SQLAlchemy query for the graphic """
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('\\n', '\n')
+        graphic['sqlalchemy_query'] = graphic['sqlalchemy_query'].replace('\"', '"')
+        pass
+
+
+    def append_data_model(self) -> List[str]:
+        """ Get the data model
+
+        Returns:
+            list: logic_files
+        """
+
+        data_model_lines = []
+        data_model_path = self.project.project_directory_path.joinpath('database/models.py')
+        assert data_model_path.exists(), f"Data model file not found: {data_model_path}"
+        with open(data_model_path, 'r') as file:
+            prompt_lines = file.readlines()
+        data_model_lines.extend(prompt_lines)
+        return data_model_lines
+    
+    def append_graphics_files(self) -> List[str]:
+        """ Get graphics files (typically from project)
+
+        Returns:
+            list: logic_files
+        """
+
+        graphics_lines = []
+        if Path(self.project.genai_using).is_dir():  # conversation from directory
+            for each_file in sorted(Path(self.project.genai_using).iterdir()):
+                if each_file.is_file() and each_file.suffix == '.prompt':
+                    # read lines from each_file, and append to prompt
+                    with open(each_file, 'r') as file:
+                        prompt_lines = file.readlines()
+                    graphics_lines.extend(prompt_lines)
+        return graphics_lines
+
+ 

api_logic_server_cli/genai/genai_logic_builder.py

@@ -27,7 +27,7 @@ log = logging.getLogger(__name__)
 
 class GenAILogic(object):
     """ 
-        Called by cli for *existing* project 
+        Called by cli for *existing* project (must be wg project with docs models)
         
         * **Create logic** from *logic files* eg `<project>/docs/logic/check_credit.prompt`
 
@@ -113,7 +113,7 @@ class GenAILogic(object):
         return learning_requests  # TODO - what if no learning requests?
     
     def get_learnings_and_data_model(self) -> List[Dict[str, str]]:
-        """ Get prompts from the docs dir (so GPT knows model, learnings)
+        """ Get prompts from the docs dir (so GPT knows model, learnings) -- **not** from database/models.py
 
         Most often, adding logic to new project, which looks like:
 

api_logic_server_cli/genai/genai_svcs.py

@@ -42,6 +42,13 @@ class Model(BaseModel):
     description: str
     name: str
 
+class Graph(BaseModel):
+    sqlalchemy_query: str  # sqlalchemy group by result = { "result": [ ("name", "value)  ] }
+    sql_query: str  # sql query using group by, returns result = { "result": [ ("name", "value")  ] }
+    classes_used: str # comma-delimited list of classes used in sqlalchemy_query
+    name: str  # suggested Python name for sqlalchemy_query
+    html_code: str # create a java script app to show a bar chart from sqlalchemy_query result
+
 class TestDataRow(BaseModel):
     test_data_row_variable: str  # the Python test data row variable
     code: str  # Python code to create a test data row instance
@@ -50,6 +57,7 @@ class WGResult(BaseModel):  # must match system/genai/prompt_inserts/response_fo
     # response: str # result
     models : List[Model] # list of sqlalchemy classes in the response
     rules : List[Rule] # list rule declarations
+    graphics: List[Graph] # list of graphs
     test_data: str
     test_data_rows: List[TestDataRow]  # list of test data rows
     test_data_sqlite: str # test data as sqlite INSERT statements

api_logic_server_cli/prototypes/base/config/config.py

@@ -116,15 +116,16 @@ class Config:
     # als add-auth --provider-type=sql --db-url=
     # als add-auth --provider-type=keycloak --db-url=localhost
     # als add-auth --provider-type=keycloak --db-url=http://10.0.0.77:8080
-    kc_base = 'http://localhost:8080'  # e.g., 'http://localhost:8080'
+    kc_base = os.getenv('KEYCLOAK_BASE','https://localhost:8080')
+    #kc_base = 'http://localhost:8080'
     ''' keycloak location '''
-    KEYCLOAK_REALM =  'kcals'
-    KEYCLOAK_BASE = f'{kc_base}/realms/{KEYCLOAK_REALM}'
-    KEYCLOAK_BASE_URL = f'{kc_base}'
-    KEYCLOAK_CLIENT_ID = 'alsclient'
+    KEYCLOAK_REALM =  os.getenv('KEYCLOAK_REALM','kcals')
+    KEYCLOAK_BASE = os.getenv('KEYCLOAK_BASE',f'{kc_base}')
+    KEYCLOAK_BASE_URL = os.getenv('KEYCLOAK_BASE_URL',f'{kc_base}/realms/{KEYCLOAK_REALM}')
+    KEYCLOAK_CLIENT_ID = os.getenv('KEYCLOAK_CLIENT_ID','alsclient')
     ''' keycloak client id '''
 
-    SECURITY_ENABLED = False  # disables security (regardless of SECURITY_PROVIDER)
+    SECURITY_ENABLED = os.getenv("SECURITY_ENABLED",False)
     SECURITY_PROVIDER = None
     if os.getenv('SECURITY_ENABLED'):  # e.g. export SECURITY_ENABLED=true
         security_export = os.getenv('SECURITY_ENABLED')  # type: ignore # type: str
@@ -141,6 +142,8 @@ class Config:
         app_logger.debug(f'config.py - security enabled')
     else:
         app_logger.info(f'config.py - security disabled')
+	
+    app_logger.info(f'SECURITY_PROVIDER={SECURITY_PROVIDER}')
 
     # Begin Multi-Database URLs (from ApiLogicServer add-db...)
     auth_db_path = str(project_path.joinpath('database/authentication_db.sqlite'))
@@ -164,11 +167,22 @@ class Config:
     SQLALCHEMY_TRACK_MODIFICATIONS = False
     PROPAGATE_EXCEPTIONS = False
 
-    KAFKA_PRODUCER = '{"bootstrap.servers": "localhost:9092"}'  #  , "client.id": "aaa.b.c.d"}'
-    KAFKA_PRODUCER = None  # comment out to enable Kafka producer
-    KAFKA_CONSUMER = '{"bootstrap.servers": "localhost:9092", "group.id": "als-default-group1"}'
-    KAFKA_CONSUMER = None  # comment out to enable Kafka consumer
-
+    KAFKA_PRODUCER = None
+    KAFKA_CONSUMER = None
+    KAFKA_CONSUMER_GROUP = None
+    KAFKA_SERVER = None
+    #KAFKA_SERVER = os.getenv('KAFKA_SERVER','localhost:9092') # if running locally default
+    if KAFKA_SERVER:
+        app_logger.info(f'config.py - KAFKA_SERVER: {KAFKA_SERVER}')
+        KAFKA_PRODUCER = os.getenv('KAFKA_PRODUCER',{"bootstrap.servers": f"{KAFKA_SERVER}"})  #  , "client.id": "aaa.b.c.d"}'
+        KAFKA_CONSUMER_GROUP = os.getenv('KAFKA_CONSUMER_GROUP','als-default-group1')
+        KAFKA_CONSUMER =  os.getenv('KAFKA_CONSUMER', {"bootstrap.servers": f"{KAFKA_SERVER}", "group.id": f"{KAFKA_CONSUMER_GROUP}", "enable.auto.commit": "false", "auto.offset.reset": "earliest"})
+    else:
+        app_logger.info(f'config.py - KAFKA_SERVER: {KAFKA_SERVER} - not set, no kafka producer/consumer')
+    print(f'config.py - KAFKA_PRODUCER: {KAFKA_PRODUCER}')
+    print(f'config.py - KAFKA_CONSUMER: {KAFKA_CONSUMER}')
+    print(f'config.py - KAFKA_CONSUMER_GROUP: {KAFKA_CONSUMER_GROUP}')
+    print(f'config.py - KAFKA_SERVER: {KAFKA_SERVER}')
     # N8N Webhook Args (for testing)
 	# see https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/?utm_source=n8n_app&utm_medium=node_settings_modal-credential_link&utm_campaign=n8n-nodes-base.webhook#path
     wh_scheme = "http"
@@ -245,6 +259,7 @@ class Args():
         self.http_scheme = Config.CREATED_HTTP_SCHEME
         self.kafka_producer = Config.KAFKA_PRODUCER
         self.kafka_consumer = Config.KAFKA_CONSUMER
+        self.kafka_consumer_group = Config.KAFKA_CONSUMER_GROUP
         self.n8n_producer = Config.N8N_PRODUCER
         self.keycloak_base = Config.KEYCLOAK_BASE
         self.keycloak_realm = Config.KEYCLOAK_REALM
@@ -463,14 +478,11 @@ class Args():
     @property
     def kafka_producer(self) -> dict:
         """ kafka connect string """
-        if "KAFKA_PRODUCER" in self.flask_app.config:
-            if self.flask_app.config["KAFKA_PRODUCER"] is not None:
-                value = self.flask_app.config["KAFKA_PRODUCER"]
-                if isinstance(value, dict):
-                    pass  # eg, from VSCode Run Config: "APILOGICPROJECT_KAFKA_PRODUCER": "{\"bootstrap.servers\": \"localhost:9092\"}",
-                else:
-                    value = json.loads(self.flask_app.config["KAFKA_PRODUCER"])
-                return value
+        if "KAFKA_PRODUCER" in self.flask_app.config and self.flask_app.config["KAFKA_PRODUCER"] is not None:
+            value = self.flask_app.config["KAFKA_PRODUCER"]
+            if not isinstance(value, dict):
+                value = json.loads(self.flask_app.config["KAFKA_PRODUCER"])
+            return value
         return None
     
     @kafka_producer.setter
@@ -480,23 +492,30 @@ class Args():
     @property
     def kafka_consumer(self) -> dict:
         """ kafka enable consumer """
-        if "KAFKA_CONSUMER" in self.flask_app.config:
-            if self.flask_app.config["KAFKA_CONSUMER"] is not None:
-                return json.loads(self.flask_app.config["KAFKA_CONSUMER"])
+        if "KAFKA_CONSUMER" in self.flask_app.config and self.flask_app.config["KAFKA_CONSUMER"] is not None:
+            value = self.flask_app.config["KAFKA_CONSUMER"]
+            if not isinstance(value, dict):
+                value = json.loads(self.flask_app.config["KAFKA_CONSUMER"])
+            return value
         return None
     
     @kafka_consumer.setter
     def kafka_consumer(self, a: str):
         self.flask_app.config["KAFKA_CONSUMER"] = a
 
-    def __str__(self) -> str:
-        rtn =  f'.. flask_host: {self.flask_host}, port: {self.port}, \n'\
-               f'.. swagger_host: {self.swagger_host}, swagger_port: {self.swagger_port}, \n'\
-               f'.. client_uri: {self.client_uri}, \n'\
-               f'.. http_scheme: {self.http_scheme}, api_prefix: {self.api_prefix}, \n'\
-               f'.. | verbose: {self.verbose}, create_and_run: {self.create_and_run}'
-        return rtn
-
+	
+    @property
+    def kafka_consumer_group(self) -> dict:
+        """ kafka enable consumer group """
+        if "KAFKA_CONSUMER_GROUP" in self.flask_app.config:
+            if self.flask_app.config["KAFKA_CONSUMER_GROUP"] is not None:
+                return self.flask_app.config["KAFKA_CONSUMER_GROUP"]
+        return None
+    
+    @kafka_consumer_group.setter
+    def kafka_consumer_group(self, a: str):
+        self.flask_app.config["KAFKA_CONSUMER_GROUP"] = a
+		
     @property
     def n8n_producer(self) -> dict:
         """ n8n connect string """
@@ -515,6 +534,15 @@ class Args():
         self.flask_app.config["N8N_PRODUCER"] = a
 
 
+    def __str__(self) -> str:
+        rtn =  f'.. flask_host: {self.flask_host}, port: {self.port}, \n'\
+            f'.. swagger_host: {self.swagger_host}, swagger_port: {self.swagger_port}, \n'\
+            f'.. client_uri: {self.client_uri}, \n'\
+            f'.. http_scheme: {self.http_scheme}, api_prefix: {self.api_prefix}, \n'\
+            f'.. | verbose: {self.verbose}, create_and_run: {self.create_and_run}'
+        return rtn
+
+
     def get_cli_args(self, args: 'Args', dunder_name: str):
         """
         returns tuple of start args:

api_logic_server_cli/prototypes/base/docs/graphics/readme.md

@@ -0,0 +1,12 @@
+### Add Natural Language Logic to Your Project
+
+You can add Natural Language logic files to this directory, e.g.: 
+
+* `.sales_by_category.prompt`: Graph Sales by Category
+
+Then, use GenAI to create executable logic in your `api/api_discovery` directory, e.g.,
+
+```bash
+als genai-graphics
+```
+1. Consider renaming your graphics files afterward (`valid_names.z-prompt`)so they are skipped on future runs

api_logic_server_cli/prototypes/base/security/authentication_provider/keycloak/auth_provider.py

@@ -78,7 +78,7 @@ class Authentication_Provider(Abstract_Authentication_Provider):
         from flask import jsonify, request
         from config.config import Args  # circular import error if at top
         
-        jwks_uri = Args.instance.keycloak_base + '/protocol/openid-connect/certs'
+        jwks_uri = Args.instance.keycloak_base_url + '/protocol/openid-connect/certs'
         for i in range(100):
             # we retry a couple of times in case there are connection problems
             try:

api_logic_server_cli/prototypes/base/security/declare_security.py

@@ -34,6 +34,8 @@ class Roles():
     admin = "CS_ADMIN"
     public="public"             # p1/p (no roles, but gets public)
     sa="sa"
+    default_roles_kcals = "default-roles-kcals"
+    uma_authorization = "uma_authorization"
     
 DefaultRolePermission(to_role=Roles.sa, can_read=True, can_update=True, can_insert=True, can_delete=True)
 DefaultRolePermission(to_role=Roles.tenant, can_read=True, can_delete=True)
@@ -43,3 +45,5 @@ DefaultRolePermission(to_role=Roles.teller, can_read=True, can_insert=True,can_u
 DefaultRolePermission(to_role=Roles.customer, can_read=True, can_insert=True,can_update=True, can_delete=False)
 DefaultRolePermission(to_role=Roles.read_only, can_read=True, can_insert=False,can_update=False, can_delete=False)
 DefaultRolePermission(to_role=Roles.public, can_read=True, can_insert=False,can_update=False, can_delete=False)
+DefaultRolePermission(to_role=Roles.default_roles_kcals, can_read=True, can_insert=True,can_update=True, can_delete=False)
+DefaultRolePermission(to_role=Roles.uma_authorization, can_read=True, can_insert=True,can_update=True, can_delete=False)

api_logic_server_cli/prototypes/base/ui/admin/admin_loader.py

@@ -140,7 +140,7 @@ def admin_events(flask_app: Flask, args: Args, validation_error: ValidationError
                 if "keycloak" in provider_name:
                     s = (f'\n'
                         f'  keycloak:\n'
-                        f'    url: {args.keycloak_base_url}\n'
+                        f'    url: {args.keycloak_base}\n'
                         f'    realm: {args.keycloak_realm}\n'
                         f'    clientId: {args.keycloak_client_id}\n'
                     )   
@@ -148,6 +148,8 @@ def admin_events(flask_app: Flask, args: Args, validation_error: ValidationError
                 elif "sql" in provider_name:
                     sql_auth_config = f'\n  endpoint: {args.http_scheme}://{args.swagger_host}:{args.swagger_port}/{args.api_prefix[1:]}/auth/login\n'
                     content = content.replace("'{system-default}'", sql_auth_config)
+                elif getattr(Config.SECURITY_PROVIDER, 'auth_config', None):
+                    content = content.replace("'{system-default}'", Config.SECURITY_PROVIDER.auth_config)
                 else:
                     sys.exit(f"ERROR[admin_loader]: unknown security type: {Config.SECURITY_PROVIDER}")         
 

api_logic_server_cli/prototypes/manager/README.md

@@ -98,7 +98,7 @@ Then, try your own databases [(db-url examples here)](https://apilogicserver.git
 
 <br>You can do this with or without signup:
 
-1. If you have signed up, this will create and open a project called `genai_demo` from `genai_demo.prompt` (available in left Explorer pane):
+1. If you have signed up (see *To obtain a ChatGPT API Key*, below), this will create and open a project called `genai_demo` from `genai_demo.prompt` (available in left Explorer pane):
 
 ```bash
 als genai --using=system/genai/examples/genai_demo/genai_demo.prompt --project-name=genai_demo
@@ -122,6 +122,20 @@ Verify it's operating properly:
 
 </br>
 
+
+<details markdown>
+
+<summary> To obtain a ChatGPT API Key</summary>
+
+<br>GenAI-Logic uses OpenAI, which requires an Open API Key:
+
+1. Obtain one from [here](https://platform.openai.com/account/api-keys) or [here](https://platform.openai.com/api-keys)
+2. Authorize payments [here](https://platform.openai.com/settings/organization/billing/overview)
+
+</details>
+
+</br>
+
 <details markdown>
 
 <summary> What Just Happened? &nbsp;&nbsp;&nbsp;Next Steps...</summary>
@@ -544,6 +558,21 @@ ApiLogicServer create --project-name=samples/nw_sample_nocust --db-url=nw
 
 &nbsp;
 
+## Explore WebGenAI
+
+In addition to the CLI examples above, you can use [WebGenAI](https://apilogicserver.github.io/Docs/WebGenAI/) - a web interface for creating projects from prompts.  You can install WebGenAI on a server, so that created projects are easy to review with colleagues.
+
+To try WebGenAI:
+
+```bash
+cd webgenai
+docker compose up
+```
+
+You will be directed to the registration process.  You will also require a ChatGPT API Key as described above.
+
+&nbsp;
+
 &nbsp;
 
 ## Appendix: Quick Basic Demo

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/genai_demo.prompt

@@ -14,6 +14,8 @@ Use case: Check Credit
 Use case: App Integration
     1. Send the Order to Kafka topic 'order_shipping' if the date_shipped is not None.
 
+Graph sales by month.
+
 Ensure each customer and product has a unique name.
 
 Ensure each Item quantity is not null.