# -----------------------------------------
# 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
                         """, 
            "params": (accountId, )
        }
    )

def get_premises(user, token_info):
    return dbGetMany(user, token_info, {
            "statement": """
SELECT
  id
  ,description
  ,street
  ,zip
  ,city
  ,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_account = body["account"]
    return dbInsert(user, token_info, {
      "statement": """
INSERT INTO premise_t
  (
    description
    ,street
    ,zip
    ,city
    ,account
  ) VALUES (
    %s
    ,%s
    ,%s
    ,%s
    ,%s
  )
  RETURNING *
""",
      "params": [
    v_description
    ,v_street
    ,v_zip
    ,v_city
    ,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
  ,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"]
    return dbUpdate(user, token_info, {
      "statement": """
UPDATE premise_t
  SET
    description = %s
    ,street = %s
    ,zip = %s
    ,city = %s
  WHERE id = %s
  RETURNING *
""",
      "params": [
    v_description,
    v_street,
    v_zip,
    v_city,
    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
  ,account
  FROM premise_t
  WHERE account = %s
                         """, 
            "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
                         """, 
            "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
                         """, 
            "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
                         """, 
            "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
                         """, 
            "params": (premiseId, )
        }
    )

def get_commercial_premises(user, token_info):
    return dbGetMany(user, token_info, {
            "statement": """
SELECT
  id
  ,description
  ,premise
  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"]
    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))


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 update_commercial_premise(user, token_info, commercial_premiseId=None, **args):
  try:
    body = args["body"]
    v_description = body["description"]
    v_premise = body["premise"]
    return dbUpdate(user, token_info, {
      "statement": """
UPDATE commercial_premise_t
  SET
    description = %s
    ,premise = %s
  WHERE id = %s
  RETURNING *
""",
      "params": [
    v_description,
    v_premise,
    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
  FROM commercial_premise_t
  WHERE premise = %s
                         """, 
            "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
                         """, 
            "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
                         """, 
            "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
                         """, 
            "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
                         """, 
            "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
  ,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_overhead_relevant = body["overhead_relevant"]
    return dbInsert(user, token_info, {
      "statement": """
INSERT INTO account_entry_category_t
  (
    description
    ,overhead_relevant
  ) VALUES (
    %s
    ,%s
  )
  RETURNING *
""",
      "params": [
    v_description
    ,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
  ,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
  ,amount
  ,document_no
  ,account_entry_category
  FROM account_entry_t
  ORDER BY
    amount
                         """, 
            "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_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
    ,amount
    ,document_no
    ,account_entry_category
  ) VALUES (
    %s
    ,%s
    ,%s
    ,%s
    ,%s
    ,%s
  )
  RETURNING *
""",
      "params": [
    v_description
    ,v_account
    ,v_created_at
    ,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
  ,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
  ,amount
  ,document_no
  ,account_entry_category
  FROM account_entry_t
  WHERE account = %s
                         """, 
            "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
  ,amount
  ,document_no
  ,account_entry_category
  FROM account_entry_t
  WHERE account_entry_category = %s
                         """, 
            "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
                         """, 
            "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
                         """, 
            "params": (tenantId, )
        }
    )