hv2-all-in-one/api/methods.py

1687 lines
33 KiB
Python

# -----------------------------------------
# THIS FILE HAS BEEN GENERATED
# DO NOT EDIT MANUALLY
# -----------------------------------------
from db import dbGetMany, dbGetOne, dbInsert, dbUpdate
from loguru import logger
import werkzeug
def get_accounts(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
FROM account_t
ORDER BY
description
""",
"params": ()
}
)
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))
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 update_account(user, token_info, accountId=None, **args):
try:
body = args["body"]
v_description = body["description"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE account_t
SET
description = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
accountId
]
})
except KeyError as e:
logger.warning("update_account: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
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
ORDER BY
lastname
,firstname
""",
"params": ()
}
)
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))
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 update_tenant(user, token_info, tenantId=None, **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"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE tenant_t
SET
salutation = %s
,firstname = %s
,lastname = %s
,address1 = %s
,address2 = %s
,address3 = %s
,zip = %s
,city = %s
,phone1 = %s
,phone2 = %s
,iban = %s
WHERE id = %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,
tenantId
]
})
except KeyError as e:
logger.warning("update_tenant: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_tenant_by_account(user, token_info, accountId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,salutation
,firstname
,lastname
,address1
,address2
,address3
,zip
,city
,phone1
,phone2
,iban
,account
FROM tenant_t
WHERE account = %s
ORDER BY
lastname
,firstname
""",
"params": (accountId, )
}
)
def get_premises(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,street
,zip
,city
,minus_area
,account
FROM premise_t
ORDER BY
description
""",
"params": ()
}
)
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"]
v_minus_area = body["minus_area"]
v_account = body["account"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO premise_t
(
description
,street
,zip
,city
,minus_area
,account
) VALUES (
%s
,%s
,%s
,%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_description
,v_street
,v_zip
,v_city
,v_minus_area
,v_account
]
})
except KeyError as e:
logger.warning("insert_premise: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_premise(user, token_info, premiseId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,description
,street
,zip
,city
,minus_area
,account
FROM premise_t
WHERE id = %s
""",
"params": (premiseId, )
}
)
def update_premise(user, token_info, premiseId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_street = body["street"]
v_zip = body["zip"]
v_city = body["city"]
v_minus_area = body["minus_area"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE premise_t
SET
description = %s
,street = %s
,zip = %s
,city = %s
,minus_area = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_street,
v_zip,
v_city,
v_minus_area,
premiseId
]
})
except KeyError as e:
logger.warning("update_premise: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_premise_by_account(user, token_info, accountId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,street
,zip
,city
,minus_area
,account
FROM premise_t
WHERE account = %s
ORDER BY
description
""",
"params": (accountId, )
}
)
def get_flats(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
,area
,flat_no
FROM flat_t
ORDER BY
premise
,description
""",
"params": ()
}
)
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))
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 update_flat(user, token_info, flatId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_premise = body["premise"]
v_area = body["area"]
v_flat_no = body["flat_no"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE flat_t
SET
description = %s
,premise = %s
,area = %s
,flat_no = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_premise,
v_area,
v_flat_no,
flatId
]
})
except KeyError as e:
logger.warning("update_flat: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_flat_by_premise(user, token_info, premiseId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
,area
,flat_no
FROM flat_t
WHERE premise = %s
ORDER BY
premise
,description
""",
"params": (premiseId, )
}
)
def get_overhead_advances(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,amount
,startdate
,enddate
FROM overhead_advance_t
ORDER BY
description
,startdate
""",
"params": ()
}
)
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))
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 update_overhead_advance(user, token_info, overhead_advanceId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_enddate = body["enddate"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE overhead_advance_t
SET
description = %s
,enddate = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_enddate,
overhead_advanceId
]
})
except KeyError as e:
logger.warning("update_overhead_advance: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
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
ORDER BY
overhead_advance
,flat
""",
"params": ()
}
)
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))
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_overhead_advance_flat_mapping_by_overhead_advance(user, token_info, overhead_advanceId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,overhead_advance
,flat
FROM overhead_advance_flat_mapping_t
WHERE overhead_advance = %s
ORDER BY
overhead_advance
,flat
""",
"params": (overhead_advanceId, )
}
)
def get_overhead_advance_flat_mapping_by_flat(user, token_info, flatId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,overhead_advance
,flat
FROM overhead_advance_flat_mapping_t
WHERE flat = %s
ORDER BY
overhead_advance
,flat
""",
"params": (flatId, )
}
)
def get_parkings(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
FROM parking_t
ORDER BY
premise
,description
""",
"params": ()
}
)
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))
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 update_parking(user, token_info, parkingId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_premise = body["premise"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE parking_t
SET
description = %s
,premise = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_premise,
parkingId
]
})
except KeyError as e:
logger.warning("update_parking: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_parking_by_premise(user, token_info, premiseId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
FROM parking_t
WHERE premise = %s
ORDER BY
premise
,description
""",
"params": (premiseId, )
}
)
def get_commercial_premises(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
,area
FROM commercial_premise_t
ORDER BY
premise
,description
""",
"params": ()
}
)
def insert_commercial_premise(user, token_info, **args):
try:
body = args["body"]
v_description = body["description"]
v_premise = body["premise"]
v_area = body["area"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO commercial_premise_t
(
description
,premise
,area
) VALUES (
%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_description
,v_premise
,v_area
]
})
except KeyError as e:
logger.warning("insert_commercial_premise: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_commercial_premise(user, token_info, commercial_premiseId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,description
,premise
,area
FROM commercial_premise_t
WHERE id = %s
""",
"params": (commercial_premiseId, )
}
)
def update_commercial_premise(user, token_info, commercial_premiseId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_premise = body["premise"]
v_area = body["area"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE commercial_premise_t
SET
description = %s
,premise = %s
,area = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_premise,
v_area,
commercial_premiseId
]
})
except KeyError as e:
logger.warning("update_commercial_premise: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_commercial_premise_by_premise(user, token_info, premiseId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,premise
,area
FROM commercial_premise_t
WHERE premise = %s
ORDER BY
premise
,description
""",
"params": (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
ORDER BY
description
,startdate
""",
"params": ()
}
)
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))
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 update_tenancy(user, token_info, tenancyId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_enddate = body["enddate"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE tenancy_t
SET
description = %s
,enddate = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_enddate,
tenancyId
]
})
except KeyError as e:
logger.warning("update_tenancy: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_tenancy_by_tenant(user, token_info, tenantId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,tenant
,flat
,parking
,commercial_premise
,startdate
,enddate
FROM tenancy_t
WHERE tenant = %s
ORDER BY
description
,startdate
""",
"params": (tenantId, )
}
)
def get_tenancy_by_flat(user, token_info, flatId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,tenant
,flat
,parking
,commercial_premise
,startdate
,enddate
FROM tenancy_t
WHERE flat = %s
ORDER BY
description
,startdate
""",
"params": (flatId, )
}
)
def get_tenancy_by_parking(user, token_info, parkingId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,tenant
,flat
,parking
,commercial_premise
,startdate
,enddate
FROM tenancy_t
WHERE parking = %s
ORDER BY
description
,startdate
""",
"params": (parkingId, )
}
)
def get_tenancy_by_commercial_premise(user, token_info, commercial_premiseId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,tenant
,flat
,parking
,commercial_premise
,startdate
,enddate
FROM tenancy_t
WHERE commercial_premise = %s
ORDER BY
description
,startdate
""",
"params": (commercial_premiseId, )
}
)
def get_fees(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,amount
,fee_type
,startdate
,enddate
FROM fee_t
ORDER BY
description
,startdate
""",
"params": ()
}
)
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))
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 update_fee(user, token_info, feeId=None, **args):
try:
body = args["body"]
v_description = body["description"]
v_enddate = body["enddate"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE fee_t
SET
description = %s
,enddate = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_description,
v_enddate,
feeId
]
})
except KeyError as e:
logger.warning("update_fee: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_tenancy_fee_mappings(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,tenancy
,fee
FROM tenancy_fee_mapping_t
""",
"params": ()
}
)
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))
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_tenancy_fee_mapping_by_tenancy(user, token_info, tenancyId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,tenancy
,fee
FROM tenancy_fee_mapping_t
WHERE tenancy = %s
""",
"params": (tenancyId, )
}
)
def get_tenancy_fee_mapping_by_fee(user, token_info, feeId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,tenancy
,fee
FROM tenancy_fee_mapping_t
WHERE fee = %s
""",
"params": (feeId, )
}
)
def get_account_entry_categorys(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,considerMinusArea
,overhead_relevant
FROM account_entry_category_t
ORDER BY
description
""",
"params": ()
}
)
def insert_account_entry_category(user, token_info, **args):
try:
body = args["body"]
v_description = body["description"]
v_considerMinusArea = body["considerMinusArea"]
v_overhead_relevant = body["overhead_relevant"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO account_entry_category_t
(
description
,considerMinusArea
,overhead_relevant
) VALUES (
%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_description
,v_considerMinusArea
,v_overhead_relevant
]
})
except KeyError as e:
logger.warning("insert_account_entry_category: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_account_entry_category(user, token_info, account_entry_categoryId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,description
,considerMinusArea
,overhead_relevant
FROM account_entry_category_t
WHERE id = %s
""",
"params": (account_entry_categoryId, )
}
)
def get_account_entrys(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,account
,created_at
,fiscal_year
,amount
,document_no
,account_entry_category
FROM account_entry_t
ORDER BY
created_at
""",
"params": ()
}
)
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_fiscal_year = body["fiscal_year"]
v_amount = body["amount"]
v_document_no = body["document_no"]
v_account_entry_category = body["account_entry_category"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO account_entry_t
(
description
,account
,created_at
,fiscal_year
,amount
,document_no
,account_entry_category
) VALUES (
%s
,%s
,%s
,%s
,%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_description
,v_account
,v_created_at
,v_fiscal_year
,v_amount
,v_document_no
,v_account_entry_category
]
})
except KeyError as e:
logger.warning("insert_account_entry: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_account_entry(user, token_info, account_entryId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,description
,account
,created_at
,fiscal_year
,amount
,document_no
,account_entry_category
FROM account_entry_t
WHERE id = %s
""",
"params": (account_entryId, )
}
)
def get_account_entry_by_account(user, token_info, accountId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,account
,created_at
,fiscal_year
,amount
,document_no
,account_entry_category
FROM account_entry_t
WHERE account = %s
ORDER BY
created_at
""",
"params": (accountId, )
}
)
def get_account_entry_by_account_entry_category(user, token_info, account_entry_categoryId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,description
,account
,created_at
,fiscal_year
,amount
,document_no
,account_entry_category
FROM account_entry_t
WHERE account_entry_category = %s
ORDER BY
created_at
""",
"params": (account_entry_categoryId, )
}
)
def get_notes(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,created_at
,tenant
,note
FROM note_t
ORDER BY
created_at
""",
"params": ()
}
)
def insert_note(user, token_info, **args):
try:
body = args["body"]
v_created_at = body["created_at"]
v_tenant = body["tenant"]
v_note = body["note"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO note_t
(
created_at
,tenant
,note
) VALUES (
%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_created_at
,v_tenant
,v_note
]
})
except KeyError as e:
logger.warning("insert_note: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_note(user, token_info, noteId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,created_at
,tenant
,note
FROM note_t
WHERE id = %s
""",
"params": (noteId, )
}
)
def get_note_by_tenant(user, token_info, tenantId=None):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,created_at
,tenant
,note
FROM note_t
WHERE tenant = %s
ORDER BY
created_at
""",
"params": (tenantId, )
}
)
def get_contracts(user, token_info):
return dbGetMany(user, token_info, {
"statement": """
SELECT
id
,supplier
,content
,identifier
,notes
FROM contract_t
ORDER BY
supplier
,content
""",
"params": ()
}
)
def insert_contract(user, token_info, **args):
try:
body = args["body"]
v_supplier = body["supplier"]
v_content = body["content"]
v_identifier = body["identifier"]
v_notes = body["notes"]
return dbInsert(user, token_info, {
"statement": """
INSERT INTO contract_t
(
supplier
,content
,identifier
,notes
) VALUES (
%s
,%s
,%s
,%s
)
RETURNING *
""",
"params": [
v_supplier
,v_content
,v_identifier
,v_notes
]
})
except KeyError as e:
logger.warning("insert_contract: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))
def get_contract(user, token_info, contractId=None):
return dbGetOne(user, token_info, {
"statement": """
SELECT
id
,supplier
,content
,identifier
,notes
FROM contract_t
WHERE id = %s
""",
"params": (contractId, )
}
)
def update_contract(user, token_info, contractId=None, **args):
try:
body = args["body"]
v_supplier = body["supplier"]
v_content = body["content"]
v_identifier = body["identifier"]
v_notes = body["notes"]
return dbUpdate(user, token_info, {
"statement": """
UPDATE contract_t
SET
supplier = %s
,content = %s
,identifier = %s
,notes = %s
WHERE id = %s
RETURNING *
""",
"params": [
v_supplier,
v_content,
v_identifier,
v_notes,
contractId
]
})
except KeyError as e:
logger.warning("update_contract: parameter missing: {}".format(e))
raise werkzeug.exceptions.UnprocessableEntity("parameter missing: {}".format(e))