add helper

.gitignore

@@ -1,2 +1,7 @@
 __pycache__/
-ENV
+ENV
+
+# generated files
+create.sql
+methods.py
+openapi.yaml

Dockerfile

@@ -18,7 +18,8 @@ RUN \
     pip3 install uwsgi && \
     pip3 install flask-cors && \
     pip3 install python-jose[cryptography] && \
-    pip3 install loguru
+    pip3 install loguru && \
+    pip3 install Cheetah3
 
 
 
@@ -28,13 +29,19 @@ RUN \
     useradd -d ${APP_DIR} -u 1000 user
 
 COPY *.py ${APP_DIR}/
-COPY openapi.yaml ${APP_DIR}/
+COPY openapi.yaml.tmpl ${APP_DIR}/
+COPY methods.py.tmpl ${APP_DIR}/
+COPY schema.json ${APP_DIR}/
 COPY server.ini ${CONF_DIR}/
 
-USER 1000:1000
 WORKDIR ${APP_DIR}
 VOLUME ${CONF_DIR}
 
+RUN \
+    python3 generate.py
+
+USER 1000:1000
+
 EXPOSE 5000
 EXPOSE 9191
 

account.py

@@ -1,17 +0,0 @@
-from db import execDatabaseOperation
-from loguru import logger
-import json
-
-
-def _opGetAccounts(cursor, params):
-    accounts = []
-    cursor.execute('SELECT id, description FROM account_t')
-    for accountObj in cursor:
-        logger.debug("add account {} -> {}".format(accountObj[0], accountObj[1]))
-        accounts.append({"id": accountObj[0], "description": accountObj[1]})
-    return accounts
-
-
-def getAccounts(user, token_info):
-    logger.info("getAccounts, token: {}".format(json.dumps(token_info)))
-    return execDatabaseOperation(_opGetAccounts, ())

create.sql.tmpl

@@ -0,0 +1,29 @@
+#for $table in $tables
+CREATE TABLE ${table.name}_t (
+  id serial not null primary key
+#for $column in $table.columns
+  ,$column.name $column.sqltype #slurp
+  #if (('notnull' in $column) and $column.notnull)
+    not null #slurp
+  #end if
+  #if (('primarykey' in $column) and $column.primarykey)
+    primary key #slurp
+  #end if
+  #if (('foreignkey' in $column) and $column.foreignkey)
+  references ${column.name}_t (id) #slurp
+  #end if
+  #if ('default' in $column)
+  default $column.default #slurp
+  #end if
+
+#end for
+#if ('tableConstraints' in $table)
+#for $tableConstraint in $table.tableConstraints
+  ,$tableConstraint
+#end for
+#end if
+);
+
+#end for
+
+

db.py

@@ -1,7 +1,10 @@
 import psycopg2
+import psycopg2.extras
 from loguru import logger
 import os
 import configparser
+import json
+import werkzeug
 
 
 
@@ -22,7 +25,11 @@ except KeyError:
     DB_HOST = config["database"]["host"]
     DB_NAME = config["database"]["name"]
 
-logger.info(f"db config: {DB_USER}, {DB_NAME}, {DB_HOST}, {DB_PASS}")
+
+
+class NoDataFoundException(Exception): pass
+
+class TooMuchDataFoundException(Exception): pass
 
 
 def databaseOperation(cursor, params):
@@ -38,10 +45,11 @@ def execDatabaseOperation(func, params):
     cur = None
     try:
         conn = psycopg2.connect(user = DB_USER, password = DB_PASS,
-                                host = DB_HOST, database = DB_NAME)
+                                host = DB_HOST, database = DB_NAME,
+                                sslmode = 'require')
         conn.autocommit = False
 
-        with conn.cursor() as cur:
+        with conn.cursor(cursor_factory = psycopg2.extras.RealDictCursor) as cur:
             return func(cur, params)
     except psycopg2.Error as err:
         raise Exception("Error when connecting to database: {}".format(err))
@@ -50,3 +58,46 @@ def execDatabaseOperation(func, params):
             conn.close()
 
 
+
+def _opGetMany(cursor, params):
+    items = []
+    cursor.execute(params["statement"])
+    for itemObj in cursor:
+        logger.debug("item received {}".format(str(itemObj)))
+        items.append(itemObj)
+    return items
+
+def dbGetMany(user, token_info, params):
+    logger.info("params: {}, token: {}".format(params, json.dumps(token_info)))
+    try:
+        return execDatabaseOperation(_opGetMany, params)
+    except Exception as e:
+        logger.error(f"Exception: {e}")
+        raise werkzeug.exceptions.InternalServerError
+
+
+
+def _opGetOne(cursor, params):
+    cursor.execute(params["statement"], params["params"])
+    itemObj = cursor.fetchone()
+    logger.debug(f"item received: {itemObj}")
+    if not itemObj:
+        raise NoDataFoundException
+    dummyObj = cursor.fetchone()
+    if dummyObj:
+        raise TooMuchDataFoundException
+    return itemObj
+
+def dbGetOne(user, token_info, params):
+    logger.info("params: {}, token: {}".format(params, json.dumps(token_info)))
+    try:
+        return execDatabaseOperation(_opGetOne, params)
+    except NoDataFoundException:
+        logger.error("no data found")
+        raise werkzeug.exceptions.NotFound
+    except TooMuchDataFoundException:
+        logger.error("too much data found")
+        raise werkzeug.exceptions.InternalServerError
+    except Exception as e:
+        logger.error(f"Exception: {e}")
+        raise werkzeug.exceptions.InternalServerError

generate.py

@@ -0,0 +1,49 @@
+import json
+from Cheetah.Template import Template
+import glob
+import argparse
+
+parser = argparse.ArgumentParser(description="generate.py")
+parser.add_argument('--schema', '-s',
+                    help='Schema file. Default: schema.json in the current folder.',
+                    required=False,
+                    default='./schema.json')
+parser.add_argument('--template', '-t',
+                    help="""Template file, templates files must be named as the final output file
+with an additional .tmpl extension. Default: all template files in the current folder.""",                    
+                    required=False,
+                    default="*.tmpl")
+args = parser.parse_args()
+
+
+with open(args.schema) as schemaFile:
+    schema = json.load(schemaFile)
+
+for table in schema["tables"]:
+    for column in table["columns"]:
+        if column["sqltype"] == 'serial':
+            column["apitype"] = 'integer'
+            column["jstype"] = 'number'
+        elif column["sqltype"] == 'integer':
+            column["apitype"] = 'integer'
+            column["jstype"] = 'number'
+        elif column["sqltype"] == 'date':
+            column["apitype"] = 'string'
+            column["jstype"] = 'string'
+        elif column["sqltype"] == 'timestamp':
+            column["apitype"] = 'string'
+            column["jstype"] = 'string'
+        elif column["sqltype"].startswith('varchar'):
+            column["apitype"] = 'string'
+            column["jstype"] = 'string'
+        elif column["sqltype"].startswith('numeric'):
+            column["apitype"] = 'number'
+            column["jstype"] = 'number'
+
+for f in glob.glob(args.template):
+    print(f"process {f}")
+    tmpl = Template(file=f, searchList=[schema])
+    with open(f[:-5], 'w') as outFile:
+        outFile.write(str(tmpl))
+
+

generateHelper.py

@@ -0,0 +1,3 @@
+def JsNameConverter(tmplName):
+    return ''.join([x.capitalize() for x in tmplName.split('_')])
+

methods.py.tmpl

@@ -0,0 +1,32 @@
+from db import dbGetMany, dbGetOne
+
+#for $table in $tables
+def get_${table.name}s(user, token_info):
+    return dbGetMany(user, token_info, {
+            "statement": """
+SELECT
+  id
+#for $column in $table.columns  
+  ,$column.name
+#end for
+  FROM ${table.name}_t
+                         """, 
+            "params": ()
+        }
+    )
+
+def get_${table.name}(user, token_info, ${table.name}Id=None):
+    return dbGetOne(user, token_info, {
+            "statement": """
+SELECT 
+  id
+#for $column in $table.columns  
+  ,$column.name
+#end for
+  FROM ${table.name}_t
+  WHERE id = %s
+                         """, 
+            "params": (${table.name}Id, )
+        }
+    )
+#end for

openapi.yaml.tmpl

@@ -12,36 +12,46 @@ externalDocs:
   url: "https://home.hottis.de/dokuwiki/doku.php?id=hv2pub:externaldocs"
 
 paths:
-  /v1/test:
+#for $table in $tables
+  /v1/${table.name}s:
     get:
-      tags: [ "Test" ]
-      summary: Return secret string
-      operationId: auth.testToken
+      tags: [ "$table.name" ]
+      summary: Return all normalized ${table.name}s
+      operationId: methods.get_${table.name}s
       responses:
         '200':
-          description: secret response
-          content:
-            'application/json':
-              schema:
-                $ref: '#/components/schemas/TestOutput'
-      security:
-      - jwt: ['secret']
-  /v1/accounts:
-    get:
-      tags: [ "Account" ]
-      summary: Return all normalized accounts
-      operationId: account.getAccounts
-      responses:
-        '200':
-          description: accounts response
+          description: ${table.name}s response
           content:
             'application/json':
               schema:
                 type: array
                 items:
-                  $ref: '#/components/schemas/Account'
+                  \$ref: '#/components/schemas/$table.name'
       security:
       - jwt: ['secret']
+  /v1/${table.name}s/{${table.name}Id}:
+    get:
+      tags: [ "$table.name" ]
+      summary: Return the normalized $table.name with given id
+      operationId: methods.get_$table.name
+      parameters:
+        - name: ${table.name}Id
+          in: path
+          required: true
+          schema:
+            type: integer
+      responses:
+        '200':
+          description: $table.name response
+          content:
+            'application/json':
+              schema:
+                type: array
+                items:
+                  \$ref: '#/components/schemas/$table.name'
+      security:
+      - jwt: ['secret']
+#end for
 
 components:
   securitySchemes:
@@ -51,19 +61,15 @@ components:
       bearerFormat: JWT
       x-bearerInfoFunc: auth.decodeToken
   schemas:
-    TestOutput:
-      description: Test Output
-      type: object
-      properties:
-        message:
-          type: string
-        details:
-          type: string
-    Account:
-      description: Account
+#for $table in $tables    
+    $table.name:
+      description: $table.name
       type: object
       properties:
         id:
           type: integer
-        description:
-          type: string
+#for $column in $table.columns
+        $column.name:
+          type: $column.apitype
+#end for
+#end for          

schema.json

@@ -0,0 +1,119 @@
+{
+    "tables": [
+        {
+            "name": "account",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)", "notnull": true }
+            ]
+        },
+        {
+            "name": "tenant",
+            "columns": [
+                { "name": "salutation", "sqltype": "varchar(128)" },
+                { "name": "firstname", "sqltype": "varchar(128)" },
+                { "name": "lastname", "sqltype": "varchar(128)" },
+                { "name": "address1", "sqltype": "varchar(128)" },
+                { "name": "address2", "sqltype": "varchar(128)" },
+                { "name": "address3", "sqltype": "varchar(128)" },
+                { "name": "zip", "sqltype": "varchar(10)" },
+                { "name": "city", "sqltype": "varchar(128)" },
+                { "name": "phone1", "sqltype": "varchar(64)" },
+                { "name": "phone2", "sqltype": "varchar(64)" },
+                { "name": "iban", "sqltype": "varchar(64)" },
+                { "name": "account", "sqltype": "integer", "notnull": true, "foreignkey": true }
+            ]            
+        },
+        {
+            "name": "premise",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "street", "sqltype": "varchar(128)", "notnull": true },
+                { "name": "zip", "sqltype": "varchar(10)", "notnull": true },
+                { "name": "city", "sqltype": "varchar(128)", "notnull": true }
+            ]
+        },
+        {
+            "name": "flat",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "premise", "sqltype": "integer", "foreignkey": true },
+                { "name": "area", "sqltype": "numeric(10,2)", "notnull": true },
+                { "name": "flat_no", "sqltype": "integer" }
+            ]
+        },
+        { 
+            "name": "overhead_advance",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "amount", "sqltype": "numeric(10,4)", "notnull": true },
+                { "name": "startdate", "sqltype": "date" },
+                { "name": "enddate", "sqltype": "date" }
+            ]
+        },
+        { 
+            "name": "overhead_advance_flat_mapping",
+            "columns": [
+                { "name": "overhead_advance", "sqltype": "integer", "notnull": true, "foreignkey": true },
+                { "name": "flat", "sqltype": "integer", "notnull": true, "foreignkey": true }
+            ]
+        },
+        {
+            "name": "parking",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "premise", "sqltype": "integer", "foreignkey": true }
+            ]
+        },
+        {
+            "name": "commercial_premise",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "premise", "sqltype": "integer", "foreignkey": true }
+            ]
+        },
+        {
+            "name": "tenancy",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "tenant", "sqltype": "integer", "notnull": true, "foreignkey": true },
+                { "name": "flat", "sqltype": "integer", "notnull": false, "foreignkey": true },
+                { "name": "parking", "sqltype": "integer", "notnull": false, "foreignkey": true },
+                { "name": "commercial_premise", "sqltype": "integer", "notnull": false, "foreignkey": true },
+                { "name": "startdate", "sqltype": "date", "notnull": true },
+                { "name": "enddate", "sqltype": "date", "notnull": false }
+            ],
+            "tableConstraints": [ 
+                "constraint tenancy_only_one_object check ((flat is not null and parking is null and commercial_premise is null) or (flat is null and parking is not null and commercial_premise is null) or (flat is null and parking is null and commercial_premise is not null))"
+            ]
+        },
+        {
+            "name": "fee",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)" },
+                { "name": "amount", "sqltype": "numeric(10,2)", "notnull": true },
+                { "name": "fee_type", "sqltype": "varchar(10)", "notnull": true },
+                { "name": "startdate", "sqltype": "date" },
+                { "name": "enddate", "sqltype": "date" }
+            ],
+            "tableConstraints": [
+                "constraint fee_fee_type check (fee_type = 'per_area' or fee_type = 'total')"
+            ]
+        },
+        { 
+            "name": "tenancy_fee_mapping",
+            "columns": [
+                { "name": "tenancy", "sqltype": "integer", "notnull": true, "foreignkey": true },
+                { "name": "fee", "sqltype": "integer", "notnull": true, "foreignkey": true }
+            ]
+        },
+        {
+            "name": "account_entry",
+            "columns": [
+                { "name": "description", "sqltype": "varchar(128)", "notnull": true },
+                { "name": "account", "sqltype": "integer", "notnull": true, "foreignkey": true },
+                { "name": "created_at", "sqltype": "timestamp", "notnull": true, "default": "now()" },
+                { "name": "amount", "sqltype": "numeric(10,2)", "notnull": true }
+            ]
+        }
+    ]
+}

testdata/testdata.sql

@@ -0,0 +1,48 @@
+insert into account_t (description) values ('account testtenant1');
+
+insert into tenant_t (lastname, account) values (
+    'testtenant1', 
+    (select id from account_t where description = 'account testtenant1')
+);
+
+insert into premise_t (street, zip, city) values ('Hemsingskotten 38', '45259', 'Essen');
+
+insert into parking_t (description, premise) values ('Garage 1', (select id from premise_t where street = 'Hemsingskotten 38'));
+
+insert into flat_t (description, premise, area, flat_no) values('EG links', (select id from premise_t where street = 'Hemsingskotten 38'), 59.0, 1);
+
+insert into fee_t (description, amount, fee_type, startdate) values ('Altenwohnung Hemsingskotten', 5.23, 'per_area', '2021-01-01');
+
+insert into fee_t (description, amount, fee_type, startdate) values ('Garage intern', 30.0, 'total', '2021-01-01');
+
+insert into tenancy_t (tenant, flat, description, startdate) values (
+    (select id from tenant_t where lastname = 'testtenant1'),
+    (select id from flat_t where flat_no = 1),
+    'flat testtenant1',
+    '2021-06-01'
+);
+
+insert into tenancy_t (tenant, parking, description, startdate) values (
+    (select id from tenant_t where lastname = 'testtenant1'),
+    (select id from parking_t where description = 'Garage 1'),
+    'parking testtenant1',
+    '2021-06-01'
+);
+
+insert into overhead_advance_t (description, amount, startdate) values ('BKV Altenwohnung Hemsingskotten', 0.34, '2021-01-01');
+
+insert into overhead_advance_flat_mapping_t (overhead_advance, flat) values (
+    (select id from overhead_advance_t where description = 'BKV Altenwohnung Hemsingskotten'),
+    (select id from flat_t where flat_no = 1)
+);
+
+insert into tenancy_fee_mapping_t (tenancy, fee) values (
+    (select id from tenancy_t where description = 'flat testtenant1'),
+    (select id from fee_t where description = 'Altenwohnung Hemsingskotten')
+);
+
+insert into tenancy_fee_mapping_t (tenancy, fee) values (
+    (select id from tenancy_t where description = 'parking testtenant1'),
+    (select id from fee_t where description = 'Garage intern')
+);
+