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

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/database_discovery/authentication_models.py

@@ -0,0 +1,183 @@
+# coding: utf-8
+from sqlalchemy import Column, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+from sqlalchemy.ext.declarative import declarative_base
+from flask import abort
+from safrs import jsonapi_rpc
+from flask_jwt_extended import get_jwt_identity
+from flask_jwt_extended import create_refresh_token
+from flask_jwt_extended import create_access_token
+
+########################################################################################################################
+# Classes describing database for SqlAlchemy ORM, initially created by schema introspection.
+#
+# Alter this file per your database maintenance policy
+#    See https://apilogicserver.github.io/Docs/Project-Rebuild/#rebuilding
+#
+# Created:  June 07, 2024 13:20:13
+# Database: sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/servers/ApiLogicProject/database/authentication_db.sqlite
+# Dialect:  sqlite
+#
+# mypy: ignore-errors
+########################################################################################################################
+ 
+from database.system.SAFRSBaseX import SAFRSBaseX
+from flask_login import UserMixin
+import safrs, flask_sqlalchemy
+from safrs import jsonapi_attr
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Mapped
+from sqlalchemy.sql.sqltypes import NullType
+from typing import List
+
+db = SQLAlchemy() 
+Baseauthentication = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
+metadata = Baseauthentication.metadata
+
+#NullType = db.String  # datatype fixup
+#TIMESTAMP= db.TIMESTAMP
+
+from sqlalchemy.dialects.sqlite import *
+
+
+
+class Role(SAFRSBaseX, Baseauthentication, db.Model, UserMixin):  # type: ignore
+    __tablename__ = 'Role'
+    _s_collection_name = 'authentication-Role'  # type: ignore
+    __bind_key__ = 'authentication'
+
+    name = Column(String(64), primary_key=True)
+    allow_client_generated_ids = True
+
+    # parent relationships (access parent)
+
+    # child relationships (access children)
+    UserRoleList : Mapped[List["UserRole"]] = relationship(back_populates="Role")
+
+    @jsonapi_attr
+    def _check_sum_(self):  # type: ignore [no-redef]
+        return None if isinstance(self, flask_sqlalchemy.model.DefaultMeta) \
+            else self._check_sum_property if hasattr(self,"_check_sum_property") \
+                else None  # property does not exist during initialization
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):  # type: ignore [no-redef]
+        self._check_sum_property = value
+
+    S_CheckSum = _check_sum_
+
+
+class User(SAFRSBaseX, Baseauthentication, db.Model, UserMixin):  # type: ignore
+    __tablename__ = 'User'
+    _s_collection_name = 'authentication-User'  # type: ignore
+    __bind_key__ = 'authentication'
+
+    name = Column(String(128))
+    client_id = Column(Integer)
+    id = Column(String(64), primary_key=True, unique=True)
+    username = Column(String(128))
+    password_hash = Column(String(200))
+    region = Column(String(32))
+    allow_client_generated_ids = True
+
+    # parent relationships (access parent)
+
+    # child relationships (access children)
+    ApiList : Mapped[List["Api"]] = relationship(back_populates="owner")
+    UserRoleList : Mapped[List["UserRole"]] = relationship(back_populates="user")
+    
+    # authentication-provider extension - password check
+    def check_password(self, password=None):
+        # print(password)
+        return password == self.password_hash
+    
+    # authentication-provider extension - login endpoint (e.g., for swagger)
+
+    @classmethod
+    @jsonapi_rpc(valid_jsonapi=False)
+    def login(cls, *args, **kwargs):
+        """
+            description: Login - Generate a JWT access token
+            args:
+                username: user
+                password: password
+        """
+        username = kwargs.get("username", None)
+        password = kwargs.get("password", None)
+
+        user = cls.query.filter_by(id=username).one_or_none()
+        if not user or not user.check_password(password):
+            abort(401, "Wrong username or password")
+
+        access_token = create_access_token(identity=user)
+        return { "access_token" : access_token}
+
+    @jsonapi_attr
+    def _check_sum_(self):  # type: ignore [no-redef]
+        return None if isinstance(self, flask_sqlalchemy.model.DefaultMeta) \
+            else self._check_sum_property if hasattr(self,"_check_sum_property") \
+                else None  # property does not exist during initialization
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):  # type: ignore [no-redef]
+        self._check_sum_property = value
+
+    S_CheckSum = _check_sum_
+
+
+class Api(SAFRSBaseX, Baseauthentication, db.Model, UserMixin):  # type: ignore
+    __tablename__ = 'Apis'
+    _s_collection_name = 'authentication-Api'  # type: ignore
+    __bind_key__ = 'authentication'
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(32))
+    connection_string = Column(String(64))
+    owner_id = Column(ForeignKey('User.id'))
+
+    # parent relationships (access parent)
+    owner : Mapped["User"] = relationship(back_populates=("ApiList"))
+
+    # child relationships (access children)
+
+    @jsonapi_attr
+    def _check_sum_(self):  # type: ignore [no-redef]
+        return None if isinstance(self, flask_sqlalchemy.model.DefaultMeta) \
+            else self._check_sum_property if hasattr(self,"_check_sum_property") \
+                else None  # property does not exist during initialization
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):  # type: ignore [no-redef]
+        self._check_sum_property = value
+
+    S_CheckSum = _check_sum_
+
+
+class UserRole(SAFRSBaseX, Baseauthentication, db.Model, UserMixin):  # type: ignore
+    __tablename__ = 'UserRole'
+    _s_collection_name = 'authentication-UserRole'  # type: ignore
+    __bind_key__ = 'authentication'
+
+    user_id = Column(ForeignKey('User.id'), primary_key=True)
+    notes = Column(Text)
+    role_name = Column(ForeignKey('Role.name'), primary_key=True)
+    allow_client_generated_ids = True
+
+    # parent relationships (access parent)
+    Role : Mapped["Role"] = relationship(back_populates=("UserRoleList"))
+    user : Mapped["User"] = relationship(back_populates=("UserRoleList"))
+
+    # child relationships (access children)
+
+    @jsonapi_attr
+    def _check_sum_(self):  # type: ignore [no-redef]
+        return None if isinstance(self, flask_sqlalchemy.model.DefaultMeta) \
+            else self._check_sum_property if hasattr(self,"_check_sum_property") \
+                else None  # property does not exist during initialization
+
+    @_check_sum_.setter
+    def _check_sum_(self, value):  # type: ignore [no-redef]
+        self._check_sum_property = value
+
+    S_CheckSum = _check_sum_

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/database_discovery/auto_discovery.py

@@ -0,0 +1,27 @@
+import importlib
+from pathlib import Path
+import logging
+
+app_logger = logging.getLogger(__name__)
+
+def discover_models():
+    """
+    Discover models in the discovery directory
+    """
+    import os
+    models = []
+    models_path = Path(__file__).parent
+    for root, dirs, files in os.walk(models_path):
+        for file in files:
+            if file.endswith(".py"):
+                spec = importlib.util.spec_from_file_location("module.name", models_path.joinpath(file))
+                if file.endswith("auto_discovery.py"):
+                    pass
+                elif file.endswith('authentication_models.py'):  #tp - avoid double import??
+                    pass
+                else:
+                    models.append(file)
+                    each_model = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(each_model)  # runs "bare" module code (e.g., initialization)
+    app_logger.info(f"..discovered models: {models}")
+    return

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/db_debug/db_debug.py

@@ -0,0 +1,90 @@
+import sqlalchemy
+from sqlalchemy import create_engine, inspect, MetaData
+from sqlalchemy.orm import Session
+import os, sys
+import oracledb
+import traceback
+from pathlib import Path
+
+running_at = Path(__file__)
+project_dir = running_at.parent.parent.parent
+sys.path.append(str(project_dir))
+os.chdir(str(project_dir))  # so admin app can find images, code
+
+import database.models as models
+
+# *******************************************
+# Use this to inspect SQLAlchemy2 connection
+# *******************************************
+
+def print_meta(meta):
+    print("\n\nmeta.sorted_tables (meta = models.metadata.sorted_tables)\n")
+    for each_table in meta.sorted_tables:
+        print(f'\n{each_table.key}')
+        for each_column in each_table.columns:
+            print(f'\t{each_column.name}')
+
+db_loc = str(project_dir.joinpath('database/db.sqlite'))
+db_url = "sqlite:////Users/val/dev/servers/ApiLogicProject/database/db.sqlite"
+db_url = f"sqlite:///{db_loc}"
+# db_url = "sqlite:////Users/val/dev/servers/ApiLogicProject/database/nw-gold.sqlite"
+from config.config import Config
+db_url = Config.SQLALCHEMY_DATABASE_URI
+if '..' in db_url:  # e.g., f"sqlite:///../database/db.sqlite"
+    db_url = db_url.replace('../', '')
+
+if 'oracle' in db_url:
+    oracle_thick = False
+    if oracle_thick:
+        import oracledb
+        oracledb.init_oracle_client()
+
+print(f'\ndb_debug 10.03.23\nAttempting connect with:\n{db_url}\n')
+
+e = sqlalchemy.create_engine(db_url)
+try:
+    inspector = inspect(e)
+except:
+    traceback.print_exc()
+    print(f'\nConnection failed with:\n{db_url}\nfrom cwd: {os.getcwd()}\n')
+    exit(0)
+conn = e.connect()
+
+with Session(e) as session:
+    print(f'session: {session}')
+    
+    print(f'Tables\n{inspector.get_table_names()}\n')
+    print(f'Views\n{inspector.get_view_names()}')
+
+    # metadata = MetaData(bind=e)
+    metadata = MetaData()  # SQLAlchemy2
+    meta = models.metadata  # tables should show list of db tables
+    print_meta(meta)
+    print("\n\n")
+
+    is_northwind = False
+    if is_northwind:
+        """
+        Caution - disable / delete this code if your database is not Northwind
+
+        Caution - use of debugger may result in "no app context"
+        https://stackoverflow.com/questions/34122949/working-outside-of-application-context-flask
+        """
+        order_id = 10643
+        order : models.Order = session.query(models.Order).filter(models.Order.Id == order_id).one()
+        # hover to view code completion...
+        print(f'Order: {order.Id}, AmountTotal: {order.AmountTotal}, ready: {order.Ready}, Required: {order.RequiredDate}, Customer: {order.CustomerId}, Balance: {order.Customer.Balance}\n\n')
+        order.AmountTotal
+
+        departments = session.query(models.Department).all()
+        for each_dept in departments:
+            print(f'\nDept: {each_dept}')
+            for each_works_for_emp in each_dept.EmployeeList1:
+                print(f'...each_works_for_emp: {each_works_for_emp}')
+            print("")
+            for each_on_loan_emp in each_dept.EmployeeList:
+                print(f'...each_on_loan_emp: {each_on_loan_emp}')
+            print("")
+            for each_sub_dept in each_dept.DepartmentList:
+                print(f'...each_sub_dept: {each_sub_dept}')
+

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/mcp_models.py

@@ -0,0 +1,58 @@
+# coding: utf-8
+from sqlalchemy import DECIMAL, DateTime  # API Logic Server GenAI assist
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+
+########################################################################################################################
+# Classes describing database for SqlAlchemy ORM, initially created by schema introspection.
+#
+# Alter this file per your database maintenance policy
+#    See https://apilogicserver.github.io/Docs/Project-Rebuild/#rebuilding
+#
+# Created:  August 09, 2025 17:35:28
+# Database: sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer/basic_demo/database/mcp_db.sqlite
+# Dialect:  sqlite
+#
+# mypy: ignore-errors
+########################################################################################################################
+ 
+from database.system.SAFRSBaseX import SAFRSBaseX, TestBase
+from flask_login import UserMixin
+import safrs, flask_sqlalchemy, os
+from safrs import jsonapi_attr
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Mapped
+from sqlalchemy.sql.sqltypes import NullType
+from typing import List
+
+db = SQLAlchemy() 
+Basemcp = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
+metadata = Basemcp.metadata
+
+#NullType = db.String  # datatype fixup
+#TIMESTAMP= db.TIMESTAMP
+
+from sqlalchemy.dialects.sqlite import *
+
+if os.getenv('APILOGICPROJECT_NO_FLASK') is None or os.getenv('APILOGICPROJECT_NO_FLASK') == 'None':
+    Base = SAFRSBaseX   # enables rules to be used outside of Flask, e.g., test data loading
+else:
+    Base = TestBase     # ensure proper types, so rules work for data loading
+    print('*** Models.py Using TestBase ***')
+
+
+
+class SysMcp(Base):  # type: ignore
+    __tablename__ = 'sys_mcp'
+    _s_collection_name = 'mcp-SysMcp'  # type: ignore
+    __bind_key__ = 'mcp'
+
+    id = Column(Integer, primary_key=True)
+    request = Column(String)
+    request_prompt = Column(String)
+    completion = Column(String)
+
+    # parent relationships (access parent)
+
+    # child relationships (access children)

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/models.py

@@ -0,0 +1,132 @@
+# coding: utf-8
+from sqlalchemy import DECIMAL, DateTime  # API Logic Server GenAI assist
+from sqlalchemy import Boolean, Column, DECIMAL, Date, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+from sqlalchemy.ext.declarative import declarative_base
+
+########################################################################################################################
+# Classes describing database for SqlAlchemy ORM, initially created by schema introspection.
+#
+# Alter this file per your database maintenance policy
+#    See https://apilogicserver.github.io/Docs/Project-Rebuild/#rebuilding
+#
+# Created:  August 09, 2025 08:12:46
+# Database: sqlite:////Users/val/dev/ApiLogicServer/ApiLogicServer-dev/build_and_test/ApiLogicServer/basic_demo/database/db.sqlite
+# Dialect:  sqlite
+#
+# mypy: ignore-errors
+########################################################################################################################
+ 
+from database.system.SAFRSBaseX import SAFRSBaseX, TestBase
+from flask_login import UserMixin
+import safrs, flask_sqlalchemy, os
+from safrs import jsonapi_attr
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import Mapped
+from sqlalchemy.sql.sqltypes import NullType
+from typing import List
+
+db = SQLAlchemy() 
+Base = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
+metadata = Base.metadata
+
+#NullType = db.String  # datatype fixup
+#TIMESTAMP= db.TIMESTAMP
+
+from sqlalchemy.dialects.sqlite import *
+
+if os.getenv('APILOGICPROJECT_NO_FLASK') is None or os.getenv('APILOGICPROJECT_NO_FLASK') == 'None':
+    Base = SAFRSBaseX   # enables rules to be used outside of Flask, e.g., test data loading
+else:
+    Base = TestBase     # ensure proper types, so rules work for data loading
+    print('*** Models.py Using TestBase ***')
+
+
+
+class Customer(Base):  # type: ignore
+    __tablename__ = 'customer'
+    _s_collection_name = 'Customer'  # type: ignore
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    balance : DECIMAL = Column(DECIMAL)
+    credit_limit : DECIMAL = Column(DECIMAL)
+    email = Column(String)
+    email_opt_out = Column(Boolean)
+
+    # parent relationships (access parent)
+
+    # child relationships (access children)
+    OrderList : Mapped[List["Order"]] = relationship(back_populates="customer")
+    SysEmailList : Mapped[List["SysEmail"]] = relationship(back_populates="customer")
+
+
+
+class SysEmail(Base):  # type: ignore
+    __tablename__ = 'sysemail'
+    _s_collection_name = 'SysEmail'  # type: ignore
+
+    id = Column(Integer, primary_key=True)
+    message = Column(String)
+    subject = Column(String)
+    customer_id = Column(ForeignKey('customer.id'), nullable=False)
+    CreatedOn = Column(DateTime)
+
+    # parent relationships (access parent)
+    customer : Mapped["Customer"] = relationship(back_populates=("SysEmailList"))
+
+    # child relationships (access children)
+
+
+
+class Product(Base):  # type: ignore
+    __tablename__ = 'product'
+    _s_collection_name = 'Product'  # type: ignore
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    unit_price : DECIMAL = Column(DECIMAL)
+
+    # parent relationships (access parent)
+
+    # child relationships (access children)
+    ItemList : Mapped[List["Item"]] = relationship(back_populates="product")
+
+
+
+class Order(Base):  # type: ignore
+    __tablename__ = 'order'
+    _s_collection_name = 'Order'  # type: ignore
+
+    id = Column(Integer, primary_key=True)
+    notes = Column(String)
+    customer_id = Column(ForeignKey('customer.id'), nullable=False)
+    CreatedOn = Column(Date)
+    date_shipped = Column(Date)
+    amount_total : DECIMAL = Column(DECIMAL)
+
+    # parent relationships (access parent)
+    customer : Mapped["Customer"] = relationship(back_populates=("OrderList"))
+
+    # child relationships (access children)
+    ItemList : Mapped[List["Item"]] = relationship(back_populates="order")
+
+
+
+class Item(Base):  # type: ignore
+    __tablename__ = 'item'
+    _s_collection_name = 'Item'  # type: ignore
+
+    id = Column(Integer, primary_key=True)
+    order_id = Column(ForeignKey('order.id'))
+    product_id = Column(ForeignKey('product.id'), nullable=False)
+    quantity = Column(Integer, nullable=False)
+    amount : DECIMAL = Column(DECIMAL)
+    unit_price : DECIMAL = Column(DECIMAL)
+
+    # parent relationships (access parent)
+    order : Mapped["Order"] = relationship(back_populates=("ItemList"))
+    product : Mapped["Product"] = relationship(back_populates=("ItemList"))
+
+    # child relationships (access children)

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/system/SAFRSBaseX.py

@@ -0,0 +1,139 @@
+import json
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, DECIMAL, Date, ForeignKey, Integer, String
+from safrs import SAFRSBase, ValidationError
+from flask_login import UserMixin
+import safrs, flask_sqlalchemy
+from safrs import jsonapi_attr
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime
+import operator
+import json
+
+
+Base = declarative_base()  # type: flask_sqlalchemy.model.DefaultMeta
+#vh new x
+@classmethod
+def jsonapi_filter(cls):
+    """
+    Use this to override SAFRS JSON:API filtering
+
+    Returns:
+        _type_: SQLAlchemy query filter
+    """
+    from sqlalchemy import text, or_, and_
+    from flask import request
+    expressions = []
+    sqlWhere = ""
+    query = cls._s_query
+    if args := request.args:
+        from api.system.expression_parser import advancedFilter
+        expressions, sqlWhere = advancedFilter(cls, args)
+    if sqlWhere != "":    
+        return query.filter(text(sqlWhere))
+    else:
+        return query.filter(and_(*expressions))   
+
+class SAFRSBaseX(SAFRSBase, safrs.DB.Model):
+    __abstract__ = True
+    if do_enable_ont_advanced_filters := False:
+        jsonapi_filter = jsonapi_filter
+        
+    def _s_parse_attr_value(self, attr_name: str, attr_val: any):
+        """
+        Parse the given jsonapi attribute value so it can be stored in the db
+        :param attr_name: attribute name
+        :param attr_val: attribute value
+        :return: parsed value
+        """
+        attr = self.__class__._s_jsonapi_attrs.get(attr_name, None)
+        if hasattr(attr, "type"):  # pragma: no cover
+            
+            if str(attr.type) in ["DATE", "DATETIME"] and attr_val:
+                try:
+                    attr_val = attr_val.replace("T", " ")
+                    datetime.strptime(attr_val, '%Y-%m-%d %H:%M')
+                    attr_val += ":00"
+                except ValueError:
+                    pass
+                except Exception as exc:
+                    safrs.log.warning(exc)
+        
+        
+        return super()._s_parse_attr_value(attr_name, attr_val)
+
+
+    @classmethod
+    def _s_filter(cls, *filter_args, **filter_kwargs):
+        """
+        Apply a filter to this model
+        :param filter_args: A list of filters information to apply, passed as a request URL parameter.
+        Each filter object has the following fields:
+        - name: The name of the field you want to filter on.
+        - op: The operation you want to use (all sqlalchemy operations are available). The valid values are:
+            - like: Invoke SQL like (or "ilike", "match", "notilike")
+            - eq: check if field is equal to something
+            - ge: check if field is greater than or equal to something
+            - gt: check if field is greater than to something
+            - ne: check if field is not equal to something
+            - is_: check if field is a value
+            - is_not: check if field is not a value
+            - le: check if field is less than or equal to something
+            - lt: check if field is less than to something
+        - val: The value that you want to compare.
+        :return: sqla query object
+        """
+        try:
+            filters = json.loads(filter_args[0])
+        except json.decoder.JSONDecodeError:
+            raise ValidationError("Invalid filter format (see https://github.com/thomaxxl/safrs/wiki)")
+
+        if not isinstance(filters, list):
+            filters = [filters]
+
+        expressions = []
+        query = cls._s_query
+
+        for filt in filters:
+            if not isinstance(filt, dict):
+                safrs.log.warning(f"Invalid filter '{filt}'")
+                continue
+            attr_name = filt.get("name")
+            attr_val = filt.get("val")
+            if attr_name != "id" and attr_name not in cls._s_jsonapi_attrs:
+                raise ValidationError(f'Invalid filter "{filt}", unknown attribute "{attr_name}"')
+
+            op_name = filt.get("op", "").strip("_")
+            attr = cls._s_jsonapi_attrs[attr_name] if attr_name != "id" else cls.id
+            if op_name in ["in", "notin"]:
+                op = getattr(attr, op_name + "_")
+                query = query.filter(op(attr_val))
+            elif op_name in ["like", "ilike", "match", "notilike"] and hasattr(attr, "like"):
+                # => attr is Column or InstrumentedAttribute
+                like = getattr(attr, op_name)
+                expressions.append(like(attr_val))
+            elif not hasattr(operator, op_name):
+                raise ValidationError(f'Invalid filter "{filt}", unknown operator "{op_name}"')
+            else:
+                op = getattr(operator, op_name)
+                expressions.append(op(attr, attr_val))
+
+        if len(filters) > 1:
+            return query.filter(operator.and_(*expressions))
+        else:
+            return query.filter(*expressions)
+
+
+class TestBase(Base):
+    __abstract__ = True
+    def __init__(self, *args, **kwargs):
+        for name, val in kwargs.items():
+            col = getattr(self.__class__, name)
+            if 'amount_total' == name:
+                debug_stop = 'stop'
+            if val is not None:
+                if str(col.type) in ["DATE", "DATETIME"]:
+                    pass
+                else:
+                    kwargs[name] = col.type.python_type(val)
+        return super().__init__(*args, **kwargs)

api_logic_server_cli/prototypes/manager/samples/basic_demo/database/test_data/alp_init.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+import os, logging, logging.config, sys
+from config import server_setup
+import api.system.api_utils as api_utils
+from flask import Flask
+import logging
+import config.config as config
+
+os.environ["PROJECT_DIR"] = os.environ.get("PROJECT_DIR", os.path.abspath(os.path.dirname(__file__)))
+
+app_logger = server_setup.logging_setup()
+app_logger.setLevel(logging.INFO) 
+
+current_path = os.path.abspath(os.path.dirname(__file__))
+sys.path.extend([current_path, '.'])
+
+flask_app = Flask("API Logic Server", template_folder='ui/templates')
+flask_app.config.from_object(config.Config)
+flask_app.config.from_prefixed_env(prefix="APILOGICPROJECT")
+
+args = server_setup.get_args(flask_app)
+
+server_setup.api_logic_server_setup(flask_app, args)
+
+from database.models import *
+import safrs
+from datetime import date
+import os
+os.environ['AGGREGATE_DEFAULTS'] = 'True'
+
+with flask_app.app_context():
+    safrs.DB.create_all()
+    # try:
+    #     alice = Customer(id=1, name="Alice", credit_limit=1000, balance=0, total_orders=0)
+    #     safrs.DB.session.add(alice)
+    #     safrs.DB.session.commit()
+    # except Exception as e:
+    #     print(f"Error adding variable to session: {e}")
+
+