Install Banking for Ontimize POC

Start with a running MySQL docker image

1. Deploy database/authdb.sql

2. Deploy database/banking.sql

3. Modify config/config.py user/password and ports for: SQLALCHEMY_DATABASE_URI SQLALCHEMY_DATABASE_URI_AUTHENTICATION

4. Optional - Install and start Docker Kafka modify the KAFKA_PRODUCER KAFKA_CONSUMER

5. Start the ATLAS server (press F5)

6. Point Ontimize environments.ts apiEndpoint: 'http://localhost:5656/ontimizeweb/services/qsallcomponents-jee/services/rest'

7. Start Ontimize and run (http://localhost:4800) user: demo pw: demouser

Put a breakpoint api/customize_api.py function def ontimize_endpoint if you want to see PUT, POST, GET from Ontimize

Quick Start

For VSCode Users, you are ready to run:

1. Press F5 to Run (your venv is defaulted)
2. Disable the startup message by renaming .vscode/tasks.json

For other IDEs, please follow the Setup and Run procedure, below.

Tip: create the sample app for customization examples: ApiLogicServer create --project_name=ApiLogicProject --db_url=

 

Using this readme

This readme contains the following sections:

Section	Info
1. Setup and Run	Information about API Logic Server, and setting up your venv
2. Deployment	Deploy early previews to the cloud - enable team collaboration
3. Key Customization Files	Quick idea of the key files you'll alter
4. Project Requirements	Options for capturing requirements
5. Project Information	Creation dates, versions
Appendix - Key Technologies	Doc links of key libraries

 

1. Setup and Run

To run your project, the system requires various runtime systems for data access, api, and logic. These are included with API Logic Server (architecture doc here).

So, to run your project:

• 1.1 Establish your Python Environment
  • Docker or VSCode - nothing to do
  • Otherwise, Establish Your Python Environment to activate these runtime systems
• 1.2 Run

 

1.1 Establish Your Python Environment - Other Environments

Your requirements.txt has already been created, so...

python -m venv venv                        # may require python3 -m venv venv
venv\Scripts\activate                      # mac/linux: source venv/bin/activate
python -m pip install -r requirements.txt  # accept "new Virtual environment"

Notes:

• See also the venv_setup directory in this API Logic Project.

• If using SqlServer, install pyodbc. Not required for docker-based projects. For local installs, see the Quick Start.

 

Docker or VSCode - nothing to do

Nothing to do here:

• VSCode: projects automatically use installed API Logic Server venv, so this step is not required until you want to create a local venv for additional packages.

• Docker: Your runtime systems are part of Dev Container, which you probably activated when you opened the project.

  • If you did not accept the "Open in Container" option when you started VSCode, use View > Command Palette > Remote-Containers: Reopen in Container.

 

 

1.2 Run

The ApiLogicServer create command creates Run Configurations for PyCharm and VSCode:

• For PyCharm, press Ctl-D
• For VSCode,  press F5:

As shown above:

1. Use the pre-supplied Run Configurations; use either...
   • ApiLogicServer to run with security
   • ApiLogicServer - No Security (simplifies use of Swagger)
2. Click the url in the console to start the Admin App
   • Use it to explore your data (shown below)
   • And your API (via Swagger)

 

2. Deployment

The devops directory contains several scripts for creating container images, testing them, and deploying them.

Since API Logic Server creates working software (UI, API), you can do this after creating your project, to collaborate with your team.

 

3. Key Customization Files

Your project is ready to run, but it's likely you'll want to customize it - declare logic, new endpoints, etc.

Tip: in particular, use the sample app to explore the value of declarative logic and security. Unique to API Logic Server, this is critical to unlocking the full value of API Logic Server.

The Key Customization Files listed in the table below are created as stubs, intended for you to add customizations that extend the created API, Logic and Web App.

• Since they are separate files, the project can be rebuilt (e.g., synchronized with a revised schema), preserving your customizations.

To explore customization, see the nw sample for examples of typical customizations. You can open it in GitHub (use Shift + "." to view in project mode) - click here, or create it locally (ApiLogicServer create - accept defaults).

To make customizations easy to explore, search for:

• #als will reveal key customization examples
• Your Code Goes Here to find key files to customize, summarized below:

Directory	Usage	Key Customization File	Typical Customization
api	JSON:API Ready to Run	api/customize_api.py	Add new end points / services
ui	Multi-Page Admin App Ready to Run	ui/admin/admin.yaml	Control field display - order, captions etc.
database	SQLAlchemy Data Model Classes	database/customize_models.py	Add derived attributes, and relationships missing in the schema
logic	Transactional Logic spreadsheet-like rules	logic/declare_logic.py	Declare multi-table derivations, constraints, and Python events such as send mail / messages
security	Authentication, Authorization	security/declare_security.py	Control login, role-based row access
integration	Consume Kafka Messages	integration/kafka/kafka_consumer.py	Application Integration
tests	Behave Test Suite	tests/api_logic_server_behave/features	Declare and implement Behave Tests

Note: API Logic Server CLI provides commands you can use to ugrade your project, e.g., to add security. Discover the CLI commands with ApiLogicServer.

 

4. Project Requirements

Optionally, you can document requirements as part of an executable test plan. Test plan execution creates documentation (in markdown), including requirements traceability into implementation. See example here.

 

5. Project Information

This API Logic Project was created with the ApiLogicServer create command. For information on Managing API Logic Projects, click here.

About	Info
Created	February 15, 2024 09:33:45
API Logic Server Version	10.02.04
Created in directory	banking
API Name	api
Execution begins with	api_logic_server_run.py

 

Appendix: Key Technologies

API Logic Server is based on the projects shown below. Consult their documentation for important information.

 

SARFS JSON:API Server

SAFRS: Python OpenAPI & JSON:API Framework

SAFRS is an acronym for SqlAlchemy Flask-Restful Swagger. The purpose of this framework is to help python developers create a self-documenting JSON API for sqlalchemy database objects and relationships.

These objects are serialized to JSON and created, retrieved, updated and deleted through the JSON API. Optionally, custom resource object methods can be exposed and invoked using JSON.

Class and method descriptions and examples can be provided in yaml syntax in the code comments.

The description is parsed and shown in the swagger web interface. The result is an easy-to-use swagger/OpenAPI and JSON:API compliant API implementation.

 

LogicBank

Transaction Logic for SQLAlchemy Object Models

Use Logic Bank to govern SQLAlchemy update transaction logic - multi-table derivations, constraints, and actions such as sending mail or messages. Logic consists of both:

• Rules - 40X more concise using a spreadsheet-like paradigm, and

• Python - control and extensibility, using standard tools and techniques

Logic Bank is based on SQLAlchemy - it handles before_flush events to enforce your logic. Your logic therefore applies to any SQLAlchemy-based access - JSON:Api, Admin App, etc.

 

SQLAlchemy

Object Relational Mapping for Python.

SQLAlchemy provides Python-friendly database access for Python.

It is used by JSON:Api, Logic Bank, and the Admin App.

SQLAlchemy processing is based on Python model classes, created automatically by API Logic Server from your database, and saved in the database directory.

 

Admin App

This generated project also contains a React Admin app:

• Multi-page - including page transitions to "drill down"
• Multi-table - master / details (with tab sheets)
• Intelligent layout - favorite fields first, predictive joins, etc
• Logic Aware - updates are monitored by business logic

 

Python Tips

If you are new to Python, check out these tips.