ApiLogicServer 15.0.10__py3-none-any.whl → 15.0.12__py3-none-any.whl

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/base_genai_demo_no_logic/integration/n8n/N8N_WebHook_from_ApiLogicServer.json

@@ -1,394 +0,0 @@
-{
-  "name": "WebHook from ApiLogicServer",
-  "nodes": [
-    {
-      "parameters": {
-        "respondWith": "allIncomingItems",
-        "options": {
-          "responseCode": 200
-        }
-      },
-      "type": "n8n-nodes-base.respondToWebhook",
-      "typeVersion": 1.1,
-      "position": [
-        920,
-        0
-      ],
-      "id": "37d950b1-e8bb-4c43-8d5c-2c4ef238e632",
-      "name": "Respond to Webhook"
-    },
-    {
-      "parameters": {
-        "content": "ApiLogicServer calls the Webhook using a logic rule on Insert - send different emails using SendGrid based on type"
-      },
-      "type": "n8n-nodes-base.stickyNote",
-      "typeVersion": 1,
-      "position": [
-        -420,
-        -20
-      ],
-      "id": "2617783e-ae85-4e56-816b-eb871146ce2c",
-      "name": "Sticky Note"
-    },
-    {
-      "parameters": {
-        "rules": {
-          "values": [
-            {
-              "conditions": {
-                "options": {
-                  "caseSensitive": true,
-                  "leftValue": "",
-                  "typeValidation": "strict",
-                  "version": 2
-                },
-                "conditions": [
-                  {
-                    "leftValue": "={{ $json.headers.wh_entity }}",
-                    "rightValue": "Employee",
-                    "operator": {
-                      "type": "string",
-                      "operation": "equals"
-                    }
-                  }
-                ],
-                "combinator": "and"
-              },
-              "renameOutput": true,
-              "outputKey": "Employee"
-            },
-            {
-              "conditions": {
-                "options": {
-                  "caseSensitive": true,
-                  "leftValue": "",
-                  "typeValidation": "strict",
-                  "version": 2
-                },
-                "conditions": [
-                  {
-                    "id": "32eaf447-bd76-48b3-b684-db8fff587e75",
-                    "leftValue": "={{ $json.headers.wh_entity }}",
-                    "rightValue": "Customer",
-                    "operator": {
-                      "type": "string",
-                      "operation": "equals",
-                      "name": "filter.operator.equals"
-                    }
-                  }
-                ],
-                "combinator": "and"
-              },
-              "renameOutput": true,
-              "outputKey": "Customer"
-            },
-            {
-              "conditions": {
-                "options": {
-                  "caseSensitive": true,
-                  "leftValue": "",
-                  "typeValidation": "strict",
-                  "version": 2
-                },
-                "conditions": [
-                  {
-                    "id": "b3cae18a-ee33-413d-b342-fd39bc6bcb0d",
-                    "leftValue": "={{ $json.headers.wh_entity }}",
-                    "rightValue": "Order",
-                    "operator": {
-                      "type": "string",
-                      "operation": "equals",
-                      "name": "filter.operator.equals"
-                    }
-                  }
-                ],
-                "combinator": "and"
-              },
-              "renameOutput": true,
-              "outputKey": "Order"
-            }
-          ]
-        },
-        "options": {}
-      },
-      "type": "n8n-nodes-base.switch",
-      "typeVersion": 3.2,
-      "position": [
-        260,
-        0
-      ],
-      "id": "450d7beb-cd8c-48b3-86d5-33d919863d80",
-      "name": "Switch"
-    },
-    {
-      "parameters": {
-        "resource": "mail",
-        "fromEmail": "info@genai-logic.com",
-        "fromName": "Tyler Band",
-        "toEmail": "={{ $json.data.email }}",
-        "subject": "Test",
-        "contentValue": "=Welcome EMAIL to {{ $json.data.Email }} for Entity {{ $json.headers.wh_entity }}\n{{ $json.data.LastName }} {{ $json.data.FirstName }}\n{{ $json.data.Title }}\n{{ $json.data.Address }}\n{{ $json.data.City }} {{ $json.data.PostalCode }}",
-        "additionalFields": {}
-      },
-      "type": "n8n-nodes-base.sendGrid",
-      "typeVersion": 1,
-      "position": [
-        720,
-        -180
-      ],
-      "id": "ccc1e5ae-523c-4687-9bee-08bbf1dd12cd",
-      "name": "SendGrid Employee",
-      "credentials": {
-        "sendGridApi": {
-          "id": "Jo176FB10nmOOVHa",
-          "name": "SendGrid account"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "resource": "mail",
-        "fromEmail": "info@genai-logic.com",
-        "fromName": "Tyler Band",
-        "toEmail": "={{ $json.data.email }}",
-        "subject": "Test",
-        "contentValue": "=EMAIL for Entity {{ $json.headers.wh_entity }} from ApiLogicServer\nName: {{ $json.data.CompanyName }}\nAddress: \n{{ $json.data.Address }}\n{{ $json.data.City }} {{ $json.data.PostalCode }} {{ $json.data.Country }}\nPhone: {{ $json.data.Phone }}\nCustomer ID: {{ $json.data.Id }}",
-        "additionalFields": {}
-      },
-      "type": "n8n-nodes-base.sendGrid",
-      "typeVersion": 1,
-      "position": [
-        580,
-        0
-      ],
-      "id": "8ee21216-861d-4161-900f-476fd4f6146d",
-      "name": "SendGrid Customer",
-      "credentials": {
-        "sendGridApi": {
-          "id": "Jo176FB10nmOOVHa",
-          "name": "SendGrid account"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "resource": "mail",
-        "fromEmail": "info@genai-logic.com",
-        "fromName": "Tyler Band",
-        "toEmail": "={{ $json.data.email }}",
-        "subject": "Test",
-        "contentValue": "=Test EMAIL for Entity {{ $json.headers.wh_entity }} from ApiLogicServer\nOrder Date: {{ $json.data[\"Order Date\"] }}\nOrder Id {{ $json.data[\"Order Id\"] }} Total ${{ $json.data[\"Order Total\"] }}\nName on Order: {{ $json.data[\"Customer Name\"] }}",
-        "additionalFields": {}
-      },
-      "type": "n8n-nodes-base.sendGrid",
-      "typeVersion": 1,
-      "position": [
-        580,
-        220
-      ],
-      "id": "017c78ad-360c-4a92-b668-261278d32398",
-      "name": "SendGrid Order",
-      "credentials": {
-        "sendGridApi": {
-          "id": "Jo176FB10nmOOVHa",
-          "name": "SendGrid account"
-        }
-      }
-    },
-    {
-      "parameters": {
-        "conditions": {
-          "options": {
-            "caseSensitive": true,
-            "leftValue": "",
-            "typeValidation": "strict",
-            "version": 2
-          },
-          "conditions": [
-            {
-              "id": "7c3eaac8-c469-4f96-923b-4f9c77946453",
-              "leftValue": "={{ $json.headers.wh_state }}",
-              "rightValue": "ins",
-              "operator": {
-                "type": "string",
-                "operation": "equals",
-                "name": "filter.operator.equals"
-              }
-            }
-          ],
-          "combinator": "and"
-        },
-        "options": {}
-      },
-      "type": "n8n-nodes-base.if",
-      "typeVersion": 2.2,
-      "position": [
-        460,
-        -140
-      ],
-      "id": "dca6455f-a439-443c-8391-d8a85f664821",
-      "name": "If Inserted"
-    },
-    {
-      "parameters": {
-        "jsCode": "// Loop over input items and add a new field called 'myNewField' to the JSON of each one\nfor (const item of $input.all()) {\n\n  item.json.data = JSON.parse(item.json.body)\n  item.json.data.email = \"tyler.band@aimicroservice.org\";\n}\n\nreturn $input.all();"
-      },
-      "type": "n8n-nodes-base.code",
-      "typeVersion": 2,
-      "position": [
-        80,
-        0
-      ],
-      "id": "13a89d57-4248-4f1d-8bfc-38381ef62f46",
-      "name": "Convert Body to JSON"
-    },
-    {
-      "parameters": {
-        "httpMethod": "POST",
-        "path": "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69",
-        "authentication": "basicAuth",
-        "responseMode": "responseNode",
-        "options": {}
-      },
-      "type": "n8n-nodes-base.webhook",
-      "typeVersion": 2,
-      "position": [
-        -140,
-        0
-      ],
-      "id": "019b4be0-7043-4ca6-84e1-e6364d482bde",
-      "name": "Webhook from ApiLogicServer",
-      "webhookId": "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69",
-      "credentials": {
-        "httpBasicAuth": {
-          "id": "h9GtMBSAuNe0F2wW",
-          "name": "Basic Auth credential"
-        }
-      }
-    }
-  ],
-  "pinData": {},
-  "connections": {
-    "Respond to Webhook": {
-      "main": [
-        []
-      ]
-    },
-    "Switch": {
-      "main": [
-        [
-          {
-            "node": "If Inserted",
-            "type": "main",
-            "index": 0
-          }
-        ],
-        [
-          {
-            "node": "SendGrid Customer",
-            "type": "main",
-            "index": 0
-          }
-        ],
-        [
-          {
-            "node": "SendGrid Order",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "SendGrid Employee": {
-      "main": [
-        [
-          {
-            "node": "Respond to Webhook",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "SendGrid Customer": {
-      "main": [
-        [
-          {
-            "node": "Respond to Webhook",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "SendGrid Order": {
-      "main": [
-        [
-          {
-            "node": "Respond to Webhook",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "If Inserted": {
-      "main": [
-        [
-          {
-            "node": "SendGrid Employee",
-            "type": "main",
-            "index": 0
-          }
-        ],
-        [
-          {
-            "node": "Respond to Webhook",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Convert Body to JSON": {
-      "main": [
-        [
-          {
-            "node": "Switch",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    },
-    "Webhook from ApiLogicServer": {
-      "main": [
-        [
-          {
-            "node": "Convert Body to JSON",
-            "type": "main",
-            "index": 0
-          }
-        ]
-      ]
-    }
-  },
-  "active": true,
-  "settings": {
-    "executionOrder": "v1",
-    "callerPolicy": "workflowsFromSameOwner"
-  },
-  "versionId": "2c9c2ee8-4d7b-4d4c-87c8-bc5229a460af",
-  "meta": {
-    "instanceId": "0b4446ffa01d8d457453f727df1e129603cc16296fab60e155d7bf4ea4ba2a50"
-  },
-  "id": "2jaWeJIoLn8K7IRs",
-  "tags": [
-    {
-      "createdAt": "2024-12-17T19:42:11.359Z",
-      "updatedAt": "2024-12-17T19:42:11.359Z",
-      "id": "lQ0qDvs9q1zBv9Vn",
-      "name": "webhook sendgrid"
-    }
-  ]
-}

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/base_genai_demo_no_logic/integration/n8n/n8n_producer.py

@@ -1,125 +0,0 @@
-"""
-
-Version 1.1
-
-Invoked at server start (api_logic_server_run.py -> config/setup.py)
-
-Connect to n8n, if N8N_CONNECT specified in Config.py
-
-You do not normally need to alter this file
-
-"""
-import traceback
-import requests
-from config.config import Args
-import json
-import logging
-from logic_bank.exec_row_logic.logic_row import LogicRow
-from integration.system.RowDictMapper import RowDictMapper
-from flask import jsonify
-import api.system.api_utils as api_utils
-from config.config import Args
-
-producer = None
-""" connected producer (or null if N8N not enabled in Config.py) """
-
-conf = None
-""" filled from config (N8N_CONNECT) """
-
-logger = logging.getLogger('integration.n8n')
-logger.debug("n8n_connect imported")
-
-def n8n_producer():
-    """
-    Called by api_logic_server_run>server_setup to listen on kafka using confluent_kafka
-
-    Enabled by config.KAFKA_CONNECT (dict, of bootstrap.servers, client.id)
-
-    Args:
-        none
-    """
-
-    global conf
-    if Args.instance.n8n_producer:
-        conf = Args.instance.n8n_producer
-        producer = conf
-        # good place to do defaults, get api keys, etc
-        logger.debug('N8N producer initialized')
-
-
-def send_n8n_message(http_method: str = "POST", ins_upd_dlt: str = "ins", msg: str = "",
-        wh_entity: str = "unknown",
-        logic_row: LogicRow = None, 
-        row_dict_mapper: RowDictMapper = None, 
-        payload: dict = None) -> any:
-    """ Send N8N webhook message regarding [logic_row, mapped by row_dict_mapper or by  payload]
-
-    * Typically called from declare_logic event
-
-    Args:
-        http_method (str):  [GET, POST,PUT,PATCH, DELETE] default is POST
-        ins_upd_dlt (str): "ins, upd, dlt" (logic row state) logic_row.ins_upd_dlt or manual (wh_state pass in header)
-        logic_row (LogicRow):(Optional) logic row contains row, old_row, ins_upd_dlt and more
-        msg: this is used for debugging
-        row_dict_mapper (RowDictMapper): (Optional) typically subclass of RowDictMapper, transforms row to dict
-        payload (str): (Optional) JSON data to be sent as string (json.dumps(row.to_dict()))    
-        wh_entity (str): the webhook entity name pass in header
-    """
-
-    global conf
-    if conf is None:
-        conf = Args.instance.n8n_producer #FIXME not sure why this fails - conf is None
-        #return "N8N not enabled in Config.py"
-        
-    if row_dict_mapper is None and payload is None and logic_row is None:
-        return "send_n8n_message: payload, logic_row, row_dict_mapper are all None - must provide one"
-    row_obj_dict = None
-    if isinstance(payload, dict):
-        row_obj_dict = json.dumps(payload)
-    elif logic_row is not None:
-        row_obj_dict = json.dumps(logic_row.row.to_dict())
-    elif row_dict_mapper is not None:
-        row_obj_dict = row_dict_mapper().row_to_dict(row = logic_row.row)
-    elif row_dict_mapper is None:
-        row_obj_dict = RowDictMapper(model_class=logic_row.row.__class__).row_to_dict(row = logic_row.row)
-    elif payload is None and http_method.lower() == "post":
-        raise ValueError(f"send_n8n_message payload type not supported: {type(payload)}") 
-
-    wh_state =  ins_upd_dlt if logic_row is None else logic_row.ins_upd_dlt
-    wh_entity = logic_row.row.__class__.__name__ if logic_row else wh_entity
-    try:
-        if row_obj_dict is not None:
-            json_payload = jsonify(f'{row_obj_dict}').data.decode('utf-8')
-            msg = f"Webhook send_n8n_message: http_method: {http_method} wh_state: {wh_state} wh_entity: {wh_entity}"
-            logger.debug(f'\n\n{msg}\n{json_payload}')
-        
-        status = {"status_code": 500}
-
-        if conf is None:
-            logger.debug(f"n8n_producer: not configured in config/Config.py")
-        else:
-            headers = {
-                "Authorization": conf['authorization'],
-                "Content-Type": "application/json",
-                "wh_state": wh_state,
-                "wh_entity": wh_entity
-            }
-            endpoint = f'{conf["n8n_url"]}'
-            status = {"status_code": 500}
-            if http_method in {"post", "POST"}:
-                #Only passing payload in this example
-                status = requests.post(endpoint, json=row_obj_dict, headers=headers)
-            elif http_method.lower() == "get":
-                status = requests.get(endpoint, headers=headers)
-            elif http_method.lower() in {"put", "patch", "delete"}:
-                logger.error(f"n8n_producer: http_method: {http_method} not implemented")
-
-            if status and status.status_code != 200:
-                logger.error(f"n8n_producer: status_code: {status.status_code}")
-        return status
-    except Exception as e:
-        logger.error(f"\nn8n_producer fails with: {e}")
-        long_message = traceback.format_exc()
-        logger.error(long_message)
-        return long_message
-

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/base_genai_demo_no_logic/integration/n8n/n8n_readme.md

@@ -1,48 +0,0 @@
-# Workflow Integration using n8n.io
-The n8n.io has over 400 integrations predefined. There are over 1,000 prebuilt templates including AI chatbot creation that can be used to integrate with ApiLogicServer. In the integration/n8n folder, the N8N_WebHook_from_ApiLogicServer,json which can be imported into your n8n.io running project and use the Northwind sample to test. [Note - the SendGrid APIKey is not provided] 
-
-## Download and install n8n.io locally
-The cloud version is available - but for development we will use the local install
-```
-https://docs.n8n.io/hosting/installation/npm/
-```
-
-## Create a new workflow and create webhook instance
-Use the POST method and add basic authentication (user: admin, password: p) 
-
-## Populate config.py values
-Copy the path UUID (wh_path)
-```
-    # 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"
-    wh_server = "localhost" # or cloud.n8n.io...
-    wh_port = 5678
-    wh_endpoint = "webhook-test"
-    wh_path = "002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"
-    token = "...."
-    # Basic Auth is (user: admin, password: p) base64 encoded
-
-    N8N_PRODUCER = {"authorization": "Basic {token}}", "n8n_url": f'"{wh_scheme}://{wh_server}:{wh_port}/{wh_endpoint}/{wh_path}"'} 
-    # OR enter the full URL
-    N8N_PRODUCER = {"authorization": "Basic {token}","n8n_url":"http://localhost:5678/webhook-test/002fa0e8-f7aa-4e04-b4e3-e81aa29c6e69"}  
-  	N8N_PRODUCER = None # comment out to enable N8N producer
-```
-
-## Start the n8n.io workflow webhook to listen
-In the logic/logic_discovery - see workflow_integration.py
-After Flush (all rules have fired and database has been updated)
-call the webhook interface - once you have the body - you can extract values and pass to other nodes
-in the workflow (e.g. SendGrid email)
-```
-    def call_n8n_workflow(row: models.Customer, old_row: models.Customer, logic_row: LogicRow):
-        """
-        Webhook Workflow:  When Customer is inserted/updated = post to external system
-        """
-        if logic_row.is_inserted():
-            status = send_n8n_message(logic_row=logic_row)
-            logic_row.debug(status)
-
-    Rule.after_flush_row_event(on_class=models.Customer, calling=call_n8n_workflow)
-```

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/base_genai_demo_no_logic/integration/row_dict_maps/row_dict_maps_readme.md

@@ -1,3 +0,0 @@
-Create definitions here to configure mappings for row <-> dicts, typically for application integration.
-
-To see a Sample Integration, [click here](https://apilogicserver.github.io/Docs/Sample-Integration/).

api_logic_server_cli/prototypes/manager/system/genai/examples/genai_demo/wg_dev_merge/base_genai_demo_no_logic/integration/system/FlaskKafka.py

@@ -1,101 +0,0 @@
-import signal
-import threading, time
-import logging
-import sys
-import signal
-from confluent_kafka import Producer, KafkaException, Consumer
-
-####
-# adapted from and thanks to: https://pypi.org/project/flask-kafka
-####
-
-logger = logging.getLogger('integration.kafka')
-__version__ = "1.01"
-
-class FlaskKafka():
-    def __init__(self, interrupt_event: object, conf: dict, safrs_api: object, **kw):
-        self.consumer = None  # create consumer KafkaConsumer(**kw)
-        self.handlers={}
-        self.interrupt_event = interrupt_event
-        self.conf = conf
-        self.safrs_api = safrs_api
-
-
-    def _add_handler(self, topic, handler):
-        if self.handlers.get(topic) is None:
-            self.handlers[topic] = []
-        logger.debug(f"FlaskKafka._add_handler - topic: {topic}, handler: {handler}")
-        self.handlers[topic].append(handler)
-
-    def handle(self, topic):
-        """Annotation to identify handler for topic
-
-        Args:
-            topic (str): name of topic
-        """
-        def decorator(f):
-            self._add_handler(topic, f)
-            return f
-        return decorator
-
-    def _run_handlers(self, msg):
-        try:
-            handlers = self.handlers[msg.topic()]
-            for handler in handlers:
-                handler(msg = msg, safrs_api = self.safrs_api)
-            # self.consumer.commit()
-        except Exception as e:
-            logger.critical(str(e), exc_info=1)
-            # self.consumer.close()
-            sys.exit("Exited due to exception")
-
-    def signal_term_handler(self, signal, frame):
-        logger.info("closing consumer")
-        self.consumer.close()
-        sys.exit(0)
-
-
-    def _start(self):
-        """ thread target (from _run) """
-
-        # thanks: https://www.reddit.com/r/learnpython/comments/gfg97m/how_do_i_run_a_function_every_5_seconds_inside_a/
-
-        topics = self.handlers.keys()
-        logger.info(f" - FlaskKafka._start: begin polling (v {__version__}), with \n -- conf: {self.conf} \n -- topics: {topics}")
-        consumer = Consumer(self.conf)
-        consumer.subscribe(topics=list(topics))
-        while True:
-            msg = consumer.poll(1.0)
-            logger.debug(f' - KafkaConnect._start - consuming consumer.poll(1.0): {msg}')
-            if msg is None:
-                continue
-            if msg.error():
-                pass  # Handle errors as needed
-            else:
-                self._run_handlers(msg)  # accrued per annotations
-
-
-    def listen_kill_server(self):
-        signal.signal(signal.SIGTERM, self.interrupted_process)
-        signal.signal(signal.SIGINT, self.interrupted_process)
-        signal.signal(signal.SIGQUIT, self.interrupted_process)
-        signal.signal(signal.SIGHUP, self.interrupted_process)
-            
-    def interrupted_process(self, *args):
-        logger.info("closing consumer")
-        self.consumer.close()
-        sys.exit(0)
-
-    
-    def _run(self):
-        logger.info(" * The flask Kafka thread started")
-        t = threading.Thread(target=self._start)
-        t.start()
-
-
-    # run the consumer application
-    def run(self):
-        """
-        Kafka consumption, threading, handler annotations
-        """
-        self._run()