ApiLogicServer 15.0.65__py3-none-any.whl → 15.1.2__py3-none-any.whl

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/api_discovery/order_b2b_service.py

@@ -0,0 +1,60 @@
+from flask import request
+from safrs import jsonapi_rpc
+import safrs
+from integration.row_dict_maps.OrderB2BMapper import OrderB2BMapper
+import logging
+
+app_logger = logging.getLogger("api_logic_server_app")
+
+def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_decorators = []):
+    api.expose_object(OrderB2BEndPoint)
+
+class OrderB2BEndPoint(safrs.JABase):
+    @classmethod
+    @jsonapi_rpc(http_methods=["POST"])
+    def OrderB2B(self, *args, **kwargs):  # yaml comment => swagger description
+        """ # yaml creates Swagger description
+            args :
+                data:
+                    Account: "Alice"
+                    Notes: "RUSH order for Q4 promotion"
+                    Items :
+                    - Name: "Widget"
+                      QuantityOrdered: 5
+                    - Name: "Gadget"
+                      QuantityOrdered: 3
+            ---
+        
+        Creates B2B orders from external partner systems with automatic lookups and business logic.
+        Features automatic customer/product lookups by name, unit price copying, 
+        amount calculations, customer balance updates, and credit limit validation.
+        """
+        db = safrs.DB
+        session = db.session
+        
+        try:
+            mapper_def = OrderB2BMapper()
+            request_dict_data = request.json["meta"]["args"]["data"]
+            
+            app_logger.info(f"OrderB2B: Processing order for account: {request_dict_data.get('Account')}")
+            
+            sql_alchemy_row = mapper_def.dict_to_row(row_dict=request_dict_data, session=session)
+            
+            session.add(sql_alchemy_row)
+            session.flush()  # Ensures ID is generated before accessing it
+            
+            order_id = sql_alchemy_row.id
+            customer_name = sql_alchemy_row.customer.name if sql_alchemy_row.customer else "Unknown"
+            item_count = len(sql_alchemy_row.ItemList)
+            
+            return {
+                "message": "B2B Order created successfully", 
+                "order_id": order_id,
+                "customer": customer_name,
+                "items_count": item_count
+            }
+            
+        except Exception as e:
+            app_logger.error(f"OrderB2B: Error creating order: {str(e)}")
+            session.rollback()
+            return {"error": "Failed to create B2B order", "details": str(e)}, 400

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/api_discovery/system.py

@@ -0,0 +1,77 @@
+from flask import request, jsonify
+import logging
+import api.system.api_utils as api_utils
+
+app_logger = logging.getLogger("api_logic_server_app")
+
+def add_service(app, api, project_dir, swagger_host: str, PORT: str, method_decorators = []):
+    pass
+
+
+    ###################
+    # Internal Services
+    ###################
+
+    @app.route('/server_log')
+    def server_log():
+        """
+        Used by test/*.py - enables client app to log msg into server's console log
+        """
+        return api_utils.server_log(request, jsonify)
+
+    
+    @app.route('/metadata')
+    def metadata():
+        """
+        Swagger provides typical API discovery.  This is for tool providers
+        requiring programmatic access to api definition, e.g., 
+        to drive artifact code generation.
+
+        Returns json for list of 1 / all resources, with optional attribute name/type, eg
+
+        curl -X GET "http://localhost:5656/metadata?resource=Category&include=attributes"
+
+        curl -X GET "http://localhost:5656/metadata?include=attributes"
+        """
+        import inspect
+        import sys
+        from sqlalchemy.ext.declarative import declarative_base
+
+        resource_name = request.args.get('resource')
+        include_attributes = False
+        include = request.args.get('include')
+        if include:
+            include_attributes = "attributes" in include
+        resource_list = []  # array of attributes[], name (so, the name is last...)
+        resource_objs = {}  # objects, named = resource_name
+
+        models_name = "database.models"
+        cls_members = inspect.getmembers(sys.modules["database.models"], inspect.isclass)
+        for each_cls_member in cls_members:
+            each_class_def_str = str(each_cls_member)
+            if (f"'{models_name}." in str(each_class_def_str) and
+                            "Ab" not in str(each_class_def_str)):
+                each_resource_name = each_cls_member[0]
+                each_resource_class = each_cls_member[1]
+                each_resource_mapper = each_resource_class.__mapper__
+                if resource_name is None or resource_name == each_resource_name:
+                    resource_object = {"name": each_resource_name}
+                    resource_list.append(resource_object)
+                    resource_objs[each_resource_name] = {}
+                    if include_attributes:
+                        attr_list = []
+                        for each_attr in each_resource_mapper.attrs:
+                            if not each_attr._is_relationship:
+                                try:
+                                    attribute_object = {"name": each_attr.key,
+                                                        "type": str(each_attr.expression.type)}
+                                except:
+                                    attribute_object = {"name": each_attr.key,
+                                                        "type": "unkown"}
+                                attr_list.append(attribute_object)
+                        resource_object["attributes"] = attr_list
+                        resource_objs[each_resource_name] = {"attributes": attr_list}
+        # pick the format you like
+        return_result = {"resources": resource_list}
+        return_result = {"resources": resource_objs}
+        return jsonify(return_result)

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/customize_api.py

@@ -0,0 +1,63 @@
+import logging
+import api.system.api_utils as api_utils
+import safrs
+from flask import request, jsonify
+from safrs import jsonapi_rpc
+from database import models
+
+# called by api_logic_server_run.py, to customize api (new end points, services).
+# separate from expose_api_models.py, to simplify merge if project recreated
+
+app_logger = logging.getLogger(__name__)
+
+# called by api_logic_server_run.py, to customize api (new end points, services).
+# separate from expose_api_models.py, to simplify merge if project recreated
+
+def expose_services(app, api, project_dir, swagger_host: str, PORT: str):
+    """ Customize API - new end points for services 
+    
+        Brief background: see readme_customize_api.md
+
+        Your Code Goes Here
+    
+    """
+    
+    app_logger.debug("api/customize_api.py - expose custom services")
+
+    from api.api_discovery.auto_discovery import discover_services
+    discover_services(app, api, project_dir, swagger_host, PORT)
+
+    @app.route('/hello_world')
+    def hello_world():  # test it with: http://localhost::5656/hello_world?user=ApiLogicServer
+        """
+        This is inserted to illustrate that APIs not limited to database objects, but are extensible.
+
+        See: https://apilogicserver.github.io/Docs/API-Customize/
+
+        See: https://github.com/thomaxxl/safrs/wiki/Customization
+        """
+        user = request.args.get('user')
+        return jsonify({"result": f'hello, {user}'})
+
+
+    @app.route('/stop')
+    def stop():  # test it with: http://localhost:5656/stop?msg=API stop - Stop API Logic Server
+        """
+        Use this to stop the server from the Browser.
+
+        See: https://stackoverflow.com/questions/15562446/how-to-stop-flask-application-without-using-ctrl-c
+
+        See: https://github.com/thomaxxl/safrs/wiki/Customization
+        """
+
+        import os, signal
+
+        if not os.getenv('APILOGICPROJECT_STOP_OK'):
+            return jsonify({ "success": False, "message": "Shutdown not enabled" })
+
+        msg = request.args.get('msg')
+        app_logger.info(f'\nStopped server: {msg}\n')
+
+        os.kill(os.getpid(), signal.SIGINT)
+        return jsonify({ "success": True, "message": "Server is shutting down..." })
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/expose_api_models.py

@@ -0,0 +1,52 @@
+import inspect
+import safrs
+import importlib
+import pathlib
+import logging as logging
+import flask_sqlalchemy
+from config.config import Args
+from config import config
+
+# use absolute path import for easier multi-{app,model,db} support
+database = __import__('database')
+app_logger = logging.getLogger(__name__)
+app_logger.debug("api/expose_api_models.py - endpoint for each table")
+
+def add_check_sum(cls):
+    """
+    Checksum decorator for each model
+    """
+    @safrs.jsonapi_attr
+    def _check_sum_(self):
+        if isinstance(self, flask_sqlalchemy.model.DefaultMeta) or not hasattr(self, "_check_sum_property"):   # property does not exist during initialization
+            return None
+        return self._check_sum_property
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):
+        self._check_sum_property = value
+
+    cls.S_CheckSum = _check_sum_
+    return cls
+
+def expose_models(api, method_decorators = []):
+    """
+        Declare API - on existing SAFRSAPI to expose each model - API model-driven automation
+        - Including get (filtering, pagination, related data access, optimistic locking)
+        - And post/patch/update (including logic enforcement)
+
+        Invoked at server startup (api_logic_server_run -> config/server_setup)
+
+        You typically do not customize this file
+        - See https://apilogicserver.github.io/Docs/Tutorial/#customize-and-debug
+    """
+
+    debug_inspect_list = inspect.getmembers(database.models)
+
+    # Get all the subclasses of the Base class and expose them in the api
+    for name, obj in inspect.getmembers(database.models):
+        if inspect.isclass(obj) and issubclass(obj, database.models.SAFRSBaseX) and obj is not database.models.SAFRSBaseX:
+            app_logger.info(f"Exposing /{name}")
+            api.expose_object(add_check_sum(obj), method_decorators= method_decorators)
+
+    return api

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/json_encoder.py

@@ -0,0 +1,17 @@
+from safrs import SAFRSJSONEncoder
+from sqlalchemy_utils.types.choice import Choice
+
+
+class SAFRSJSONEncoderExt(SAFRSJSONEncoder):
+    """
+        Quick example on adding additional types via CustomEncoder
+
+        see also https://gist.github.com/KodeKracker/b44dea8df6c0c90fdcdb
+        https://github.com/thomaxxl/safrs/blob/master/examples/demo_geoalchemy.py
+    """
+
+    def default(self, obj, **kwargs):
+        if isinstance(obj, Choice):
+            return obj.code
+
+        return super().default(obj, **kwargs)

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/readme_customize_api.md

@@ -0,0 +1,103 @@
+Without customization, your API supports multi-table retrieval.  For more information, [see here](https://apilogicserver.github.io/Docs/API-Multi-Table).
+
+This describes how to *add new endpoints*.  For more information, [see here](https://apilogicserver.github.io/Docs/API-Customize).
+
+ 
+
+## Examples      
+Examples from tutorial project:
+* Examples drawn from [tutorial project](https://github.com/ApiLogicServer/demo/blob/main/api/customize_api.py)
+* Use Shift + "." to view in project mode
+
+ 
+
+### New Endpoint: Standard Flask with Security, not exposed in Swagger
+
+Use standard Flask / SQLAlchemy (background [here](https://docs.sqlalchemy.org/en/20/core/connections.html)):
+
+```python
+    @app.route('/filters_cats')
+    @admin_required()
+    def filters_cats():
+        """
+        Illustrates:
+        * Explore SQLAlchemy and/or filters.
+        
+        Test (returns rows 2-5) (no auth):
+            curl -X GET "http://localhost:5656/filters_cats [no-filter | simple-filter]"
+        """
+
+        from sqlalchemy import and_, or_
+        filter_type = request.args.get('filter')
+        if filter_type is None:
+            filter_type = "multiple filters"
+        db = safrs.DB           # Use the safrs.DB, not db!
+        session = db.session    # sqlalchemy.orm.scoping.scoped_session
+        Security.set_user_sa()  # an endpoint that requires no auth header (see also @admin_required)
+
+        if filter_type.startswith("n"):
+            results = session.query(models.Category)    # .filter(models.Category.Id > 1)
+        elif filter_type.startswith("s"):               # normally coded like this
+            results = session.query(models.Category) \
+                .filter(models.Category.Id > 1) \
+                .filter(or_((models.Category.Client_id == 2), (models.Category.Id == 5)))
+        else:                                           # simulate grant logic (multiple filters)
+            client_grant = models.Category.Client_id == 2
+            id_grant = models.Category.Id == 5
+            grant_filter = or_( client_grant, id_grant)
+            results = session.query(models.Category) \
+                .filter(models.Category.Id > 1)  \
+                .filter(grant_filter)
+        return_result = []
+        for each_result in results:
+            row = { 'id': each_result.Id, 'name': each_result.CategoryName}
+            return_result.append(row)
+        return jsonify({ "success": True, "results":  return_result})
+```
+
+ 
+
+### New Endpoint: Standard Flask, exposed in Swagger
+
+```python
+class CategoriesEndPoint(safrs.JABase):
+    """
+    Illustrates
+    * Swagger-visible RPC that requires authentication (@jwt_required()).
+
+    Test in swagger (auth required)
+    * Post to endpoint auth to obtain <access_token> value - copy it to clipboard
+    * Authorize (top of swagger), using Bearer <access_token>
+    * Post to CategoriesEndPoint/get_cats, observe only row 1 returned
+
+    """
+
+    @staticmethod
+    @jwt_required()
+    @jsonapi_rpc(http_methods=['POST'], valid_jsonapi=False)
+    def get_cats():
+        db = safrs.DB
+        session = db.session
+        # Security.set_user_sa()  # use to bypass authorization (also requires @admin_required)
+
+        result = session.query(models.Category)
+        for each_row in result:
+            app_logger.debug(f'each_row: {each_row}')
+        rows = util.rows_to_dict(result)
+        response = {"result": rows}
+        return response
+```
+
+&nbsp;
+
+## Data Access
+
+The samples also illustrate several forms of data access, summarized in the table below.  Note the use of `util.py`, included with all projects.
+
+| Function | Auth required                         | Illustrates             | Util Usage  |
+|:-------------- |:------------------------------|:-----------------------------------|:--------------------------------------------------------------------------------------|
+| ```get_cats()``` |  Y  | Model query      |Util.rows_to_dict<br>..row.to_dict   |
+| ```filters_cats()``` |  Y  | Model query, filters         | No: No  - Manual {} creation   |
+| ```raw_sql_cats()``` |    | Raw sql        | Util.rows_to_dict<br>..fields iterator   |
+
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/api/system/api_utils.py

@@ -0,0 +1,171 @@
+"""
+Utilities for API Logic Server Projects (1.1)
+"""
+import sqlite3
+from os import path
+import logging
+import sys
+from typing import Any, Optional, Tuple
+from logic_bank.rule_bank.rule_bank import RuleBank
+
+app_logger = logging.getLogger(__name__)
+
+def log(msg: object) -> None:
+    app_logger.debug(msg)
+    # print("TIL==> " + msg)
+
+
+def connection() -> sqlite3.Connection:
+    ROOT: str = path.dirname(path.realpath(__file__))
+    log(ROOT)
+    _connection = sqlite3.connect(path.join(ROOT, "sqlitedata.db"))
+    return _connection
+
+
+def dbpath(dbname: str) -> str:
+    ROOT: str = path.dirname(path.realpath(__file__))
+    log('ROOT: '+ROOT)
+    PATH: str = path.join(ROOT, dbname)
+    log('DBPATH: '+PATH)
+    return PATH
+
+rule_count = 0
+from flask import request, jsonify
+
+def rules_report():
+    """
+    logs report of all rules, using rules_bank.__str__()
+    """
+    global rule_count
+    rules_bank = RuleBank()
+    logic_logger = logging.getLogger("logic_logger")
+    rule_count = 0
+    logic_logger.debug(f'\nThe following rules have been activated\n')
+    list_rules = rules_bank.__str__()
+    loaded_rules = list(list_rules.split("\n"))
+    for each_rule in loaded_rules:
+        logic_logger.info(each_rule + '\t\t##  ')
+        rule_count += 1
+    logic_logger.info(f'Logic Bank - {rule_count} rules loaded')
+
+
+def server_log(request, jsonify):
+    """
+    Used by test/*.py - enables client apps (the behave tests) to...
+    *  log msg into server, and 
+    * test/api_logic_server_behave/logs
+    """
+    import os
+    import datetime
+    from pathlib import Path
+    import logging
+    global rule_count
+
+
+    def add_file_handler(logger, name: str, log_dir):
+        """Add a file handler for this logger with the specified `name` (and
+        store the log file under `log_dir`)."""
+        # Format for file log
+        for each_handler in logger.handlers:
+            each_handler.flush()
+            handler_name = str(each_handler)
+            if "stderr" in handler_name:
+                pass
+                # print(f'do not delete stderr')
+            else:
+                logger.removeHandler(each_handler)
+        fmt = '%(asctime)s | %(levelname)8s | %(filename)s:%(lineno)d | %(message)s'
+        formatter = logging.Formatter(fmt)
+        formatter = logging.Formatter('%(message)s - %(asctime)s - %(name)s - %(levelname)s')
+
+        # Determine log path/file name; create log_dir if necessary
+        now = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        log_name = f'{str(name).replace(" ", "_")}'  # {now}'
+        if len(log_name) >= 26:
+            log_name = log_name[0:25]
+
+        if not os.path.exists(log_dir):
+            try:
+                os.makedirs(log_dir)
+            except:
+                app_logger.info(f'util.add_file_handler unable to create dir {log_dir}')
+                log_dir = '/tmp' if sys.platform.startswith('linux') else '.'
+                app_logger.info(f'Defaulting to {log_dir}.')
+
+        log_file = os.path.join(log_dir, log_name) + '.log'
+        if os.path.exists(log_file):
+            os.remove(log_file)
+        else:
+            pass  # file does not exist
+
+        # Create file handler for logging to a file (log all five levels)
+        # print(f'create file handler for logging: {log_file}')
+        logger.file_handler = logging.FileHandler(log_file)
+        logger.file_handler.setLevel(logging.DEBUG)
+        logger.file_handler.setFormatter(formatter)
+        logger.addHandler(logger.file_handler)
+
+    msg = request.args.get('msg')
+    test = request.args.get('test')
+    if "Server Log: Behave Run Successfully Completed" in msg:
+        debug_stop = 'good breakpoint'
+    if test is not None and test != "None":
+        if test == "None":
+            print(f'None for msg: {msg}')
+        logic_logger = logging.getLogger('logic_logger')  # for debugging user logic
+        # logic_logger.info("\n\nLOGIC LOGGER HERE\n")
+        use_relative = True
+        if use_relative:
+            api_utils_path = Path(__file__)
+            proj_path = api_utils_path.parent.parent.parent
+            log_path = proj_path.joinpath('test/api_logic_server_behave/logs/scenario_logic_logs')
+            print(f'Log Dir: {log_path}')
+            add_file_handler(logic_logger, test, log_path)
+        else:
+            dir = request.args.get('dir')
+            add_file_handler(logic_logger, test, Path(os.getcwd()).joinpath(dir))
+    if msg == "Rules Report":
+        rules_report()
+        logic_logger.info(f'Logic Bank - {rule_count} rules loaded')
+    else:
+        app_logger.info(f'{msg}')
+        if "Server Log: Behave Run Successfully Completed" in msg:
+            logic_logger.info(f'\n\n*** {msg}\n\n***\n\n')
+    return jsonify({"result": f'ok'})
+
+
+def sys_info(flask_app_config):  
+    """
+    Print env and path
+    """  
+    import os, socket
+    print("\n\nsys_info here")
+    print("\nEnvironment Variables...")
+    env = os.environ
+    for each_variable in os.environ:
+            print(f'.. {each_variable} = {env[each_variable]}')
+
+    print(f'\n\nflask_app.config: \n\t')
+    flask_app_config_str = str(flask_app_config)
+    flask_app_config_str = flask_app_config_str.replace(', ', ',\n\t')
+    print((flask_app_config_str))
+
+    print("\n\nPYTHONPATH..")
+    for p in sys.path:
+        print(".." + p)
+        
+    print("")
+    print(f'sys.prefix (venv): {sys.prefix}\n')
+
+    print("")
+    hostname = socket.gethostname()
+    IPAddr = 'unknown'
+    try:
+        local_ip = socket.gethostbyname(hostname)
+        IPAddr=socket.gethostbyname(hostname) 
+    except:
+        local_ip = f"Warning - Failed local_ip = socket.gethostbyname(hostname) with hostname: {hostname}"
+
+    print(f"hostname={hostname} on local_ip={local_ip}, IPAddr={IPAddr}\n\n")
+
+    print(f"os.getcwd()={os.getcwd()}\n\n")