2021-08-28 21:12:08 +02:00
|
|
|
|
2021-08-29 12:50:59 +02:00
|
|
|
# -----------------------------------------
|
2021-08-28 21:12:08 +02:00
|
|
|
# THIS FILE HAS BEEN GENERATED
|
|
|
|
# DO NOT EDIT MANUALLY
|
2021-08-29 12:50:59 +02:00
|
|
|
# -----------------------------------------
|
2021-08-28 21:12:08 +02:00
|
|
|
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
from db import dbGetMany, dbGetOne, dbInsert
|
|
|
|
from loguru import logger
|
2021-08-02 17:03:24 +02:00
|
|
|
|
|
|
|
def get_accounts(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
FROM account_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
description
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_account(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO account_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_account: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_account(user, token_info, accountId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
FROM account_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (accountId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_tenants(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,salutation
|
|
|
|
,firstname
|
|
|
|
,lastname
|
|
|
|
,address1
|
|
|
|
,address2
|
|
|
|
,address3
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
,phone1
|
|
|
|
,phone2
|
|
|
|
,iban
|
|
|
|
,account
|
|
|
|
FROM tenant_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
lastname
|
|
|
|
,firstname
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_tenant(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_salutation = body["salutation"]
|
|
|
|
v_firstname = body["firstname"]
|
|
|
|
v_lastname = body["lastname"]
|
|
|
|
v_address1 = body["address1"]
|
|
|
|
v_address2 = body["address2"]
|
|
|
|
v_address3 = body["address3"]
|
|
|
|
v_zip = body["zip"]
|
|
|
|
v_city = body["city"]
|
|
|
|
v_phone1 = body["phone1"]
|
|
|
|
v_phone2 = body["phone2"]
|
|
|
|
v_iban = body["iban"]
|
|
|
|
v_account = body["account"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO tenant_t
|
|
|
|
(
|
|
|
|
salutation
|
|
|
|
,firstname
|
|
|
|
,lastname
|
|
|
|
,address1
|
|
|
|
,address2
|
|
|
|
,address3
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
,phone1
|
|
|
|
,phone2
|
|
|
|
,iban
|
|
|
|
,account
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_salutation
|
|
|
|
,v_firstname
|
|
|
|
,v_lastname
|
|
|
|
,v_address1
|
|
|
|
,v_address2
|
|
|
|
,v_address3
|
|
|
|
,v_zip
|
|
|
|
,v_city
|
|
|
|
,v_phone1
|
|
|
|
,v_phone2
|
|
|
|
,v_iban
|
|
|
|
,v_account
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_tenant: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_tenant(user, token_info, tenantId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,salutation
|
|
|
|
,firstname
|
|
|
|
,lastname
|
|
|
|
,address1
|
|
|
|
,address2
|
|
|
|
,address3
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
,phone1
|
|
|
|
,phone2
|
|
|
|
,iban
|
|
|
|
,account
|
|
|
|
FROM tenant_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (tenantId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_premises(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,street
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
FROM premise_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
description
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_premise(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_street = body["street"]
|
|
|
|
v_zip = body["zip"]
|
|
|
|
v_city = body["city"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO premise_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,street
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_street
|
|
|
|
,v_zip
|
|
|
|
,v_city
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_premise: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_premise(user, token_info, premiseId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,street
|
|
|
|
,zip
|
|
|
|
,city
|
|
|
|
FROM premise_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (premiseId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_flats(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
,area
|
|
|
|
,flat_no
|
|
|
|
FROM flat_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
premise
|
|
|
|
,description
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_flat(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_premise = body["premise"]
|
|
|
|
v_area = body["area"]
|
|
|
|
v_flat_no = body["flat_no"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO flat_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,premise
|
|
|
|
,area
|
|
|
|
,flat_no
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_premise
|
|
|
|
,v_area
|
|
|
|
,v_flat_no
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_flat: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_flat(user, token_info, flatId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
,area
|
|
|
|
,flat_no
|
|
|
|
FROM flat_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (flatId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_overhead_advances(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,amount
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM overhead_advance_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
description
|
|
|
|
,startdate
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_overhead_advance(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_amount = body["amount"]
|
|
|
|
v_startdate = body["startdate"]
|
|
|
|
v_enddate = body["enddate"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO overhead_advance_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,amount
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_amount
|
|
|
|
,v_startdate
|
|
|
|
,v_enddate
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_overhead_advance: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_overhead_advance(user, token_info, overhead_advanceId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,amount
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM overhead_advance_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (overhead_advanceId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_overhead_advance_flat_mappings(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,overhead_advance
|
|
|
|
,flat
|
|
|
|
FROM overhead_advance_flat_mapping_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
overhead_advance
|
|
|
|
,flat
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_overhead_advance_flat_mapping(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_overhead_advance = body["overhead_advance"]
|
|
|
|
v_flat = body["flat"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO overhead_advance_flat_mapping_t
|
|
|
|
(
|
|
|
|
overhead_advance
|
|
|
|
,flat
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_overhead_advance
|
|
|
|
,v_flat
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_overhead_advance_flat_mapping: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_overhead_advance_flat_mapping(user, token_info, overhead_advance_flat_mappingId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,overhead_advance
|
|
|
|
,flat
|
|
|
|
FROM overhead_advance_flat_mapping_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (overhead_advance_flat_mappingId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_parkings(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
FROM parking_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
premise
|
|
|
|
,description
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_parking(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_premise = body["premise"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO parking_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,premise
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_premise
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_parking: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_parking(user, token_info, parkingId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
FROM parking_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (parkingId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_commercial_premises(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
FROM commercial_premise_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
premise
|
|
|
|
,description
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_commercial_premise(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_premise = body["premise"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO commercial_premise_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,premise
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_premise
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_commercial_premise: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_commercial_premise(user, token_info, commercial_premiseId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,premise
|
|
|
|
FROM commercial_premise_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (commercial_premiseId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_tenancys(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,tenant
|
|
|
|
,flat
|
|
|
|
,parking
|
|
|
|
,commercial_premise
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM tenancy_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
description
|
|
|
|
,startdate
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_tenancy(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_tenant = body["tenant"]
|
|
|
|
v_flat = body["flat"]
|
|
|
|
v_parking = body["parking"]
|
|
|
|
v_commercial_premise = body["commercial_premise"]
|
|
|
|
v_startdate = body["startdate"]
|
|
|
|
v_enddate = body["enddate"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO tenancy_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,tenant
|
|
|
|
,flat
|
|
|
|
,parking
|
|
|
|
,commercial_premise
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_tenant
|
|
|
|
,v_flat
|
|
|
|
,v_parking
|
|
|
|
,v_commercial_premise
|
|
|
|
,v_startdate
|
|
|
|
,v_enddate
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_tenancy: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_tenancy(user, token_info, tenancyId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,tenant
|
|
|
|
,flat
|
|
|
|
,parking
|
|
|
|
,commercial_premise
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM tenancy_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (tenancyId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_fees(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,amount
|
|
|
|
,fee_type
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM fee_t
|
2021-08-28 19:00:49 +02:00
|
|
|
ORDER BY
|
|
|
|
description
|
|
|
|
,startdate
|
2021-08-02 17:03:24 +02:00
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_fee(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_amount = body["amount"]
|
|
|
|
v_fee_type = body["fee_type"]
|
|
|
|
v_startdate = body["startdate"]
|
|
|
|
v_enddate = body["enddate"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO fee_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,amount
|
|
|
|
,fee_type
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_amount
|
|
|
|
,v_fee_type
|
|
|
|
,v_startdate
|
|
|
|
,v_enddate
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_fee: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_fee(user, token_info, feeId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,amount
|
|
|
|
,fee_type
|
|
|
|
,startdate
|
|
|
|
,enddate
|
|
|
|
FROM fee_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (feeId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_tenancy_fee_mappings(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,tenancy
|
|
|
|
,fee
|
|
|
|
FROM tenancy_fee_mapping_t
|
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_tenancy_fee_mapping(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_tenancy = body["tenancy"]
|
|
|
|
v_fee = body["fee"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO tenancy_fee_mapping_t
|
|
|
|
(
|
|
|
|
tenancy
|
|
|
|
,fee
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_tenancy
|
|
|
|
,v_fee
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_tenancy_fee_mapping: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_tenancy_fee_mapping(user, token_info, tenancy_fee_mappingId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,tenancy
|
|
|
|
,fee
|
|
|
|
FROM tenancy_fee_mapping_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (tenancy_fee_mappingId, )
|
|
|
|
}
|
|
|
|
)
|
|
|
|
def get_account_entrys(user, token_info):
|
|
|
|
return dbGetMany(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,account
|
|
|
|
,created_at
|
|
|
|
,amount
|
|
|
|
FROM account_entry_t
|
|
|
|
""",
|
|
|
|
"params": ()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-08-31 17:24:54 +02:00
|
|
|
def insert_account_entry(user, token_info, **args):
|
|
|
|
try:
|
|
|
|
body = args["body"]
|
|
|
|
v_description = body["description"]
|
|
|
|
v_account = body["account"]
|
|
|
|
v_created_at = body["created_at"]
|
|
|
|
v_amount = body["amount"]
|
|
|
|
return dbInsert(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
INSERT INTO account_entry_t
|
|
|
|
(
|
|
|
|
description
|
|
|
|
,account
|
|
|
|
,created_at
|
|
|
|
,amount
|
|
|
|
) VALUES (
|
|
|
|
%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
,%s
|
|
|
|
)
|
|
|
|
RETURNING *
|
|
|
|
""",
|
|
|
|
"params": [
|
|
|
|
v_description
|
|
|
|
,v_account
|
|
|
|
,v_created_at
|
|
|
|
,v_amount
|
|
|
|
]
|
|
|
|
})
|
|
|
|
except KeyError as e:
|
|
|
|
logger.warning("insert_account_entry: parameter missing: {}".format(e))
|
|
|
|
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
|
|
|
|
|
|
|
|
|
2021-08-02 17:03:24 +02:00
|
|
|
def get_account_entry(user, token_info, account_entryId=None):
|
|
|
|
return dbGetOne(user, token_info, {
|
|
|
|
"statement": """
|
|
|
|
SELECT
|
|
|
|
id
|
|
|
|
,description
|
|
|
|
,account
|
|
|
|
,created_at
|
|
|
|
,amount
|
|
|
|
FROM account_entry_t
|
|
|
|
WHERE id = %s
|
|
|
|
""",
|
|
|
|
"params": (account_entryId, )
|
|
|
|
}
|
|
|
|
)
|