invoiceum 1.0.0__py3-none-any.whl

invoiceum/__init__.py

@@ -0,0 +1,3 @@
+from .cinvoice import *
+
+__version__ = "1.0.0"

invoiceum/cinvoice.py

@@ -0,0 +1,251 @@
+"""
+Literp Invoicing Tool
+Dependencies:
+  pip install [tagrepo] uvia vapp invoiceum
+Start daemon:
+  export LLM_TRANSFORMER_MODEL="./all-MiniLM-L6-v2"
+  export SETUPKEY_ENCRYPT_SECRET="very-strong-password"
+  export JWT_SECRET="very-strong-password"
+  export TOKEN_EXPIRE_MINUTES=30
+  export ADMIN_AUTHENTICATOR_EMAIL_LIST=someone@company.com
+  export SUPERVISOR_AUTHENTICATOR_EMAIL_LIST=""
+  export STAFF_AUTHENTICATOR_EMAIL_LIST=""
+  export FINANCE_SUPERVISOR_AUTHENTICATOR_EMAIL_LIST=""
+  export FINANCE_STAFF_AUTHENTICATOR_EMAIL_LIST=""
+  export FILE_AVRO_DATA="./users/setupkeys.avro"
+  export FILE_AVRO_FINANCE_SUPERVISORS="./users/rolefbksupervisors.avro"
+  export FILE_AVRO_FINANCE_STAFF="./users/rolefbkstaff.avro"
+  export FILE_AVRO_SUPERVISORS="./users/rolecrmsupervisors.avro"
+  export FILE_AVRO_STAFF="./users/rolecrmstaff.avro"
+  export FILE_DUCKDB_VECTOR="./temp.db"
+  uvia -a vapp -m invoiceum [-p <PORT>] [-H <HOST>]
+VAPP routes:
+  Route: /callback -> callbackpage()
+  Route: /login -> loginpage()
+  Route: /call -> callpage()
+  GET -> request.query_params = {function, access_token, jsondata, module}
+"""
+
+from tagrepo.format import first_date_of_current_year, first_date_of_current_month
+
+from orderum import *
+
+from .param import get_request_invoice_options, get_request_payment_options, get_request_tax_options
+
+from .task import *
+from .title import *
+
+APP_PORT = 21911 ## for <uvia> and <vapp>
+
+## core <uvia> functions
+
+def homepage():
+  async def submit(request: Request):
+    return HTMLResponse(Template(APP_TMP_DIRECTORY_MENU).render(
+      APP_CHARSET=APP_CHARSET,
+      APP_VIEWPORT=APP_VIEWPORT,
+      APP_TITLE=APP_DESC,
+      FORM_TITLE=FORM_TITLE,
+      directory_items=[
+        {"href": "/login", "name": LABEL_MENU_LOGIN},
+        {"href": call_function(FUNCTION_INVOICE_INSERT), "name": LABEL_INVOICE_INSERT},
+        {"href": call_function(FUNCTION_DRAFT_INVOICES_SELECT), "name": LABEL_DRAFT_INVOICES_SELECT},
+        {"href": call_function(FUNCTION_NO_DRAFT_INVOICES_SELECT), "name": LABEL_NO_DRAFT_INVOICES_SELECT},
+        {"href": call_function(FUNCTION_INVOICES_REVIEW), "name": LABEL_INVOICES_REVIEW},
+        {"href": call_function(FUNCTION_PAYMENT_INSERT), "name": LABEL_PAYMENT_INSERT},
+        {"href": call_function(FUNCTION_DRAFT_PAYMENTS_SELECT), "name": LABEL_DRAFT_PAYMENTS_SELECT},
+        {"href": call_function(FUNCTION_NO_DRAFT_PAYMENTS_SELECT), "name": LABEL_NO_DRAFT_PAYMENTS_SELECT},
+        {"href": call_function(FUNCTION_PAYMENTS_REVIEW), "name": LABEL_PAYMENTS_REVIEW},
+        {"href": call_function(FUNCTION_TAX_COLLECT), "name": LABEL_TAX_COLLECT},
+        {"href": call_function(FUNCTION_INVOICES_SEARCH), "name": LABEL_INVOICES_SEARCH},
+        {"href": call_function("logout"), "name": LABEL_MENU_LOGOUT},
+      ]
+    ))
+  return submit
+
+def callpage():
+  async def submit(request: Request):
+    return await process_function_call(request, auth_functions, HTMLResponse, _callpage)
+  return submit
+
+async def _callpage(request, func: str):
+  if func == FUNCTION_CUSTOMERS_POPUP:
+    search = request.query_params.get("search")
+    return HTMLResponse(popup_customers_page(request, search))
+  elif func == FUNCTION_PRODUCTS_POPUP:
+    search = request.query_params.get("search")
+    return HTMLResponse(popup_products_page(request, search))
+  elif func == FUNCTION_INVOICES_POPUP:
+    search = request.query_params.get("search")
+    return HTMLResponse(popup_invoices_page(request, search))
+  elif func == FUNCTION_TYPE_POPUP:
+    return HTMLResponse(popup_type_page(request))
+  elif func == FUNCTION_INVOICE_INSERT:
+    if request.method == 'GET':
+      return HTMLResponse(insert_invoice_page(request))
+    else:
+      form = await request.form()
+      dated = form.get(DATED) or nowdate()
+      due = form.get(DUE) or ""
+      form = inputfilter(dstrip(form), Invoices, excludes=[])
+      form[DATED] = dated
+      form[DUE] = due
+      insert = insert_invoice_page(request, **form)
+      if insert == CALLBACK: return RedirectResponseGet(url=call_function(FUNCTION_INVOICES_SELECT))
+      return HTMLResponse(insert)
+  elif func == FUNCTION_INVOICES_SELECT:
+    return HTMLResponse(select_invoices_page(request, **get_request_invoice_options(request)))
+  elif func == FUNCTION_DRAFT_INVOICES_SELECT:
+    return HTMLResponse(select_draft_invoices_page(request, **get_request_invoice_options(request)))
+  elif func == FUNCTION_NO_DRAFT_INVOICES_SELECT:
+    return HTMLResponse(select_no_draft_invoices_page(request, **get_request_invoice_options(request)))
+  elif func == FUNCTION_INVOICE_SELECT:
+    invoice_id = request.query_params.get("id")
+    return HTMLResponse(select_invoice_page(request, invoice_id))
+  elif func == FUNCTION_CUSTOMER_SELECT:
+    customer_id = request.query_params.get("id")
+    return HTMLResponse(select_customer_page(request, customer_id))
+  elif func == FUNCTION_PRODUCT_SELECT:
+    product_id = request.query_params.get("id")
+    return HTMLResponse(select_product_page(request, product_id))
+  elif func == FUNCTION_INVOICE_NOTE_UPDATE: ## hidden
+    invoice_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(update_invoice_note_page(request, invoice_id))
+    else:
+      form = await request.form()
+      form = inputfilter(dstrip(form), Invoices, includes=UPDATE_INPUTS["Invoices"])
+      update = update_invoice_note_page(request, invoice_id, **form)
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICE_SELECT}&id={invoice_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_INVOICE_UPDATE: ## hidden
+    invoice_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(update_invoice_page(request, invoice_id))
+    else:
+      form = await request.form()
+      form = inputfilter(dstrip(form), Invoices, includes=UPDATE_INPUTS[Invoices])
+      update = update_invoice_page(request, invoice_id, **form)
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICE_SELECT}&id={invoice_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_INVOICE_UPGRADE:
+    invoice_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(upgrade_invoice_page(request, invoice_id))
+    else:
+      form = await request.form()
+      status = form.get(STATUS)
+      update = upgrade_invoice_page(request, invoice_id, status=status)
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICE_SELECT}&id={invoice_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_INVOICEITEM_INSERT:
+    invoice_id = request.query_params.get("invoice_id")
+    if request.method == 'GET':
+      return HTMLResponse(insert_invoiceitem_page(request, invoice_id=invoice_id))
+    else:
+      form = await request.form()
+      form = inputfilter(dstrip(form), Invoiceitems, excludes=[DATED])
+      insert = insert_invoiceitem_page(request, invoice_id=invoice_id, **form)
+      if insert == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICEITEMS_SELECT}&invoice_id={invoice_id}"))
+      return HTMLResponse(insert)
+  elif func == FUNCTION_INVOICEITEMS_SELECT:
+    invoice_id = request.query_params.get("invoice_id")
+    return HTMLResponse(select_invoiceitems_page(request, invoice_id))
+  elif func == FUNCTION_INVOICEITEM_SELECT:
+    invoiceitem_id = request.query_params.get("id")
+    return HTMLResponse(select_invoiceitem_page(request, invoiceitem_id))
+  elif func == FUNCTION_INVOICEITEM_UPDATE: ## hidden
+    invoiceitem_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(update_invoiceitem_page(request, invoiceitem_id))
+    else:
+      form = await request.form()
+      form = inputfilter(dstrip(form), Invoiceitems, includes=UPDATE_INPUTS[Invoiceitems])
+      update = update_invoiceitem_page(request, invoiceitem_id, **form) ## refresh subtotal
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICEITEM_SELECT}&id={invoiceitem_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_INVOICES_REVIEW:
+    if request.method == 'GET':
+      return HTMLResponse(review_invoices_page(request))
+    else:
+      form = await request.form()
+      status = form.get(STATUS)
+      return RedirectResponseGet(url=call_function(f"{FUNCTION_INVOICES_SELECT}&status={status}"))
+  elif func == FUNCTION_INVOICES_SEARCH:
+    author = request.query_params.get("author")
+    if request.method == 'GET':
+      return HTMLResponse(search_invoices_page(request))
+    else:
+      form = await request.form()
+      search = form.get("search")
+      seek = form.get("seek")
+      reset = form.get("reset")
+      search = search_invoices_page(request, search=search, reset=boolean(reset), seek=seek, author=author)
+      return HTMLResponse(search)
+  elif func == FUNCTION_INVOICES_AUTHOR_SEARCH: ## hidden
+    if request.method == 'GET':
+      return HTMLResponse(search_invoices_author_page(request))
+    else:
+      form = await request.form()
+      search = form.get("search")
+      seek = form.get("seek")
+      reset = form.get("reset")
+      search = search_invoices_author_page(request, search=search, reset=boolean(reset), seek=seek)
+      return HTMLResponse(search)
+  elif func == FUNCTION_PAYMENT_INSERT:
+    if request.method == 'GET':
+      return HTMLResponse(insert_payment_page(request))
+    else:
+      form = await request.form()
+      dated = form.get(DATED) or nowdate()
+      form = inputfilter(dstrip(form), Payments, excludes=[])
+      form[DATED] = dated
+      insert = insert_payment_page(request, **form)
+      if insert == CALLBACK: return RedirectResponseGet(url=call_function(FUNCTION_PAYMENTS_SELECT))
+      return HTMLResponse(insert)
+  elif func == FUNCTION_PAYMENTS_SELECT:
+    return HTMLResponse(select_payments_page(request, **get_request_payment_options(request)))
+  elif func == FUNCTION_PAYMENT_SELECT:
+    payment_id = request.query_params.get("id")
+    return HTMLResponse(select_payment_page(request, payment_id))
+  elif func == FUNCTION_PAYMENT_UPDATE: ## hidden
+    payment_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(update_payment_page(request, payment_id))
+    else:
+      form = await request.form()
+      form = inputfilter(dstrip(form), Payments, includes=UPDATE_INPUTS[Payments])
+      update = update_payment_page(request, payment_id, **form)
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_PAYMENT_SELECT}&id={payment_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_PAYMENT_UPGRADE:
+    payment_id = request.query_params.get("id")
+    if request.method == 'GET':
+      return HTMLResponse(upgrade_payment_page(request, payment_id))
+    else:
+      form = await request.form()
+      status = form.get(STATUS)
+      update = upgrade_payment_page(request, payment_id, status=status)
+      if update == CALLBACK: return RedirectResponseGet(url=call_function(f"{FUNCTION_PAYMENT_SELECT}&id={payment_id}"))
+      return HTMLResponse(update)
+  elif func == FUNCTION_DRAFT_PAYMENTS_SELECT:
+    return HTMLResponse(select_draft_payments_page(request, **get_request_payment_options(request)))
+  elif func == FUNCTION_NO_DRAFT_PAYMENTS_SELECT:
+    return HTMLResponse(select_no_draft_payments_page(request, **get_request_payment_options(request)))
+  elif func == FUNCTION_PAYMENTS_REVIEW:
+    if request.method == 'GET':
+      return HTMLResponse(review_payments_page(request))
+    else:
+      form = await request.form()
+      status = form.get(STATUS)
+      return RedirectResponseGet(url=call_function(f"{FUNCTION_PAYMENTS_SELECT}&status={status}"))
+  elif func == FUNCTION_TAX_COLLECT:
+    if request.method == 'GET':
+      return HTMLResponse(collect_tax_invoices_page(request))
+    else:
+      form = await request.form()
+      dated = form.get(DATED) or first_date_of_current_month()
+      dated_end = form.get(DATED_END) or nowdate()
+      return HTMLResponse(collect_tax_invoices_page(request, dated, dated_end))
+  else:
+    return HTMLResponse("Function not found or not accessible")

invoiceum/data.py

@@ -0,0 +1,117 @@
+from tagrepo.dataframe import _get_row_html, _get_row_dict
+from tagrepo.database import avro_sql_select_combo
+
+from orderum.data import *
+
+from .syslogin import *
+from .environ import *
+from .schema import *
+
+## data constants
+
+INVOICE_INSERT_FIELDS = arrayfilter(INSERT_INPUTS[Invoices], excludes=[])
+## EX_INVOICE_INSERT_FIELDS = arrayfilter(["customer"]+INSERT_INPUTS[Invoices], excludes=[])
+INVOICEITEM_INSERT_FIELDS = arrayfilter(INSERT_INPUTS[Invoiceitems], excludes=[INVOICE_ID, DATED, SUBTOTAL])
+## EX_INVOICEITEM_INSERT_FIELDS = arrayfilter(["product"]+INSERT_INPUTS[Invoiceitems], excludes=[INVOICE_ID, DATED, SUBTOTAL])
+PAYMENT_INSERT_FIELDS = arrayfilter(INSERT_INPUTS[Payments], excludes=[])
+
+## selecting derivatives
+
+def calculate_invoice_amount(invoice_id: str) -> float:
+  df = sql_simple_query_model("Invoiceitems", select="quantity,price,subtotal", where=f"invoice_id='{invoice_id}'")
+  return 0 if df is None or not len(df) else numfloat((df['quantity'] * df['price']).sum())
+
+def get_invoice_name(invoice_id: str) -> str:
+  return select_name_by_id(invoice_id, model="Invoices")
+
+def get_invoice(invoice_id: str) -> dict:
+  return _get_row_dict("Invoices", invoice_id)
+
+def select_pure_invoice(invoice_id: str) -> str:
+  return _get_row_html("Invoices", invoice_id)
+
+def select_invoice(invoice_id: str) -> str:
+  return select_pure_row("Invoices",
+    linkfields=SELECT_LINK_FIELDS[Invoices],
+    linkrefs={CUSTOMER_ID: call_function(f"{FUNCTION_CUSTOMER_SELECT}&id=")},
+    where=f"id='{invoice_id}'", limit=1)
+
+def select_invoiceitem(invoiceitem_id: str) -> str:
+  return select_pure_row("Invoiceitems",
+    linkfields=SELECT_LINK_FIELDS[Invoiceitems],
+    linkrefs={INVOICE_ID: call_function(f"{FUNCTION_INVOICE_SELECT}&id="), PRODUCT_ID: call_function(f"{FUNCTION_PRODUCT_SELECT}&id=")},
+    where=f"id='{invoiceitem_id}'", limit=1)
+
+def get_invoiceitem(invoiceitem_id: str) -> dict:
+  return _get_row_dict("Invoiceitems", invoiceitem_id)
+
+def invoice_not_updatable(invoice: any) -> bool:
+  if type(invoice) is dict: return invoice.get(STATUS) not in UPDATABLE_INVOICES
+  return not check_record_exist(invoice, model="Invoices", field=ID, where=INVOICE_IS_UPDATABLE)
+
+def invoice_closed(invoice: any) -> bool:
+  if type(invoice) is dict: return invoice.get(STATUS) in CLOSED_INVOICES
+  return check_record_exist(invoice, model="Invoices", field=ID, where=INVOICE_CLOSED)
+
+def invoice_item_duplicated(name: str, invoice_id: str) -> bool:
+  return check_record_exist(name, model="Invoiceitems", field=NAME, where=f"invoice_id='{invoice_id}'")
+
+def select_payment(payment_id: str) -> str:
+  return select_pure_row("Payments",
+    linkfields=SELECT_LINK_FIELDS[Payments],
+    linkrefs={INVOICE_ID: call_function(f"{FUNCTION_INVOICE_SELECT}&id=")},
+    where=f"id='{payment_id}'", limit=1)
+
+def get_payment(payment_id: str) -> dict:
+  return _get_row_dict("Payments", payment_id)
+
+def payment_not_updatable(payment: any) -> bool:
+  if type(payment) is dict: return payment.get(STATUS) not in UPDATABLE_PAYMENTS
+  return not check_record_exist(payment, model="Payments", field=ID, where=PAYMENT_IS_UPDATABLE)
+
+def payment_closed(payment: any) -> bool:
+  if type(payment) is dict: return payment.get(STATUS) in CLOSED_PAYMENTS
+  return check_record_exist(payment, model="Payments", field=ID, where=PAYMENT_CLOSED)
+
+## listing derivatives
+
+def list_invoices(popindex: int=1, **kwargs) -> str:
+  model = "Invoices"
+  show = LISTING_FIELDS[Invoices][popindex:]
+  df = sql_simple_query_model(model, **kwargs)
+  return df_list_insert_rows(df, show,
+    header=LISTING_HEADERS[Invoices][popindex:],
+    open_func=LISTING_LINK_BUTTON_FUNCTIONS[Invoices][popindex:],
+    callfunction=LISTING_LINK_CALL_FUNCTIONS[Invoices][popindex:],
+    idfield=LISTING_LINK_ID_FIELDS[Invoices][popindex:],
+    linkfield=LISTING_LINK_REF_FIELDS[Invoices][popindex:])
+
+def list_invoices_to_insert_invoiceitem(**kwargs) -> str:
+  return list_invoices(0, **kwargs) ## remove add_item
+
+def list_invoiceitems(invoice_id: str) -> str:
+  return list_review_rows("Invoiceitems",
+    show=LISTING_FIELDS[Invoiceitems],
+    callfunction="select-invoiceitem",
+    where=f"invoice_id='{invoice_id}'")
+
+def list_pick_invoices(**kwargs) -> str:
+  return list_select_rows(model="Invoices", show=SELECT_LISTING_FIELDS[Invoices], header=LISTING_HEADERS["Invoices"], **kwargs) ## ambiguous "Invoices"
+
+def list_select_payments(**kwargs) -> str:
+  return list_review_rows(model="Payments", show=LISTING_FIELDS[Payments], callfunction=FUNCTION_PAYMENT_SELECT, **kwargs)
+
+list_payments = list_select_payments
+
+def list_tax_invoices(dated: str, dated_end: str, statuses: str=INVOICE_TAXABLE_STATUSES, join_clause="db_main.customer_id=db_sub.id") -> str:
+  df = avro_sql_select_combo(model_main="Invoices", model_sub="Customers",
+    select=f"db_main.id, db_main.dated, db_sub.name AS customer, db_sub.{CUSTOMER_TAX_CODE} AS taxcode, db_main.tax, db_main.taxrate",
+    where=f"{join_clause} AND db_main.status IN {statuses} AND db_main.dated BETWEEN '{dated}' AND '{dated_end}'",
+    sort="db_main.dated,db_sub.name", asc=True, limit=LIST_MAX_ROWS)
+  if df is None or not len(df): return NO_DATA_AVAILABLE
+  return df_list_review_rows(df, show=REVIEW_LISTING_FIELDS[Invoices], callfunction=FUNCTION_INVOICE_SELECT)
+
+## vector search
+
+def get_search_invoice_option(request, seek: str="", author: str="") -> dict:
+  return get_search_status_option(request=request, seek=seek, author=author, status_list=INVOICE_STATUS_LIST)

invoiceum/environ.py

@@ -0,0 +1,17 @@
+from orderum.environ import *
+
+set_environ('CONFIRM_INVOICE_COMPLETED', 'Confirm: this invoice was completed?')
+set_environ('CONFIRM_INVOICE_CANCELLED', 'Confirm: this invoice was cancelled?')
+
+set_environ('WRONG_INVOICE_ID', 'Error: invalid invoice id')
+set_environ('BAD_INVOICE_ID', 'Error: invalid invoice id, or invoice is not updatable')
+set_environ('INVOICE_ITEM_DUPLICATED', 'Error: invoice line item is duplicated')
+
+set_environ('INVOICE_NOT_EXIST', 'Warning: invoice does not exist')
+set_environ('INVOICE_NOT_EXIST_OR_CLOSED', 'Warning: invoice does not exist or was closed')
+set_environ('INVOICE_NO_REVERSE_TO_DRAFT', 'Warning: invoice cannot be reversed to draft')
+set_environ('INVOICE_ALREADY_EXISTS', 'Warning: invoice with this name already exists')
+
+set_environ('PAYMENT_ALREADY_EXISTS', 'Warning: payment with this name already exists')
+set_environ('PAYMENT_NOT_EXIST_OR_CLOSED', 'Warning: payment does not exist or was closed')
+set_environ('BAD_PAYMENT_ID', 'Error: invalid payment id, or payment is not updatable')

invoiceum/param.py

@@ -0,0 +1,18 @@
+from orderum.param import *
+
+from .schema import INVOICE_SORT_FIELDS, PAYMENT_SORT_FIELDS, TAX_SORT_FIELDS, NAME
+
+def adjust_invoice_listing_options(where: str, author: str, sort: str, asc: str, limit: str, request=None) -> tuple:
+  return adjust_listing_options(where, author, sort, asc, limit, sort_fields=INVOICE_SORT_FIELDS, request=request)
+
+def adjust_payment_listing_options(where: str, author: str, sort: str, asc: str, limit: str, request=None) -> tuple:
+  return adjust_listing_options(where, author, sort, asc, limit, sort_fields=PAYMENT_SORT_FIELDS, request=request)
+
+def adjust_tax_listing_options(where: str, author: str, sort: str, asc: str, limit: str, request=None) -> tuple:
+  return adjust_listing_options(where, author, sort, asc, limit, sort_fields=TAX_SORT_FIELDS, request=request)
+
+get_request_invoice_options = get_request_data_options ## sort:DATED.desc
+
+get_request_payment_options = get_request_data_options ## sort:DATED.desc
+
+get_request_tax_options = get_request_data_options ## sort:DATED.desc

invoiceum/schema.py

@@ -0,0 +1,97 @@
+from tagrepo.schema15 import *
+from orderum.schema import *
+
+from .syslogin import *
+
+_CUSTOMER = "customer"
+_TAXCODE = "taxcode"
+
+INVOICE_SORT_FIELDS = [NAME, DATED, DUE, AMOUNT, DISCOUNT, TAXRATE, TAX, AUTHOR_ID, STATUS]
+PAYMENT_SORT_FIELDS = [NAME, DATED, AMOUNT, REF, TYPE, AUTHOR_ID, STATUS]
+TAX_SORT_FIELDS = [_CUSTOMER, _TAXCODE, TAX, TAXRATE, DATED]
+
+UPDATABLE_INVOICES = [INVOICE_DRAFT]
+CLOSED_INVOICES = [INVOICE_PAID, INVOICE_CANCELLED]
+OPEN_INVOICES = [INVOICE_SENT, INVOICE_OVERDUE] ## USABLE
+
+INVOICE_CLOSED = f"status IN ('{INVOICE_PAID}', '{INVOICE_CANCELLED}')"
+INVOICE_NOT_CLOSED = f"status NOT IN ('{INVOICE_PAID}', '{INVOICE_CANCELLED}')"
+INVOICE_IS_LISTABLE = f"status NOT IN ('{INVOICE_DRAFT}', '{INVOICE_CANCELLED}')"
+INVOICE_IS_UPDATABLE = f"status IN ('{INVOICE_DRAFT}')"
+INVOICE_IS_USABLE = f"status IN ('{INVOICE_SENT}', '{INVOICE_OVERDUE}')"
+
+UPDATABLE_PAYMENTS = [PAYMENT_DRAFT]
+CLOSED_PAYMENTS = [PAYMENT_COMPLETED, PAYMENT_CANCELLED]
+
+PAYMENT_CLOSED = f"status IN ('{PAYMENT_COMPLETED}', '{PAYMENT_CANCELLED}')"
+PAYMENT_NOT_CLOSED = f"status NOT IN ('{PAYMENT_COMPLETED}', '{PAYMENT_CANCELLED}')"
+PAYMENT_IS_LISTABLE = f"status NOT IN ('{PAYMENT_DRAFT}', '{PAYMENT_CANCELLED}')"
+PAYMENT_IS_UPDATABLE = f"status IN ('{PAYMENT_DRAFT}')"
+
+INVOICE_TAXABLE_STATUSES = f"('{INVOICE_SENT}', '{INVOICE_OVERDUE}', '{INVOICE_PAID}')"
+
+## complex data view: use with caution
+
+REVIEW_LISTING_FIELDS |= { ## complex view
+  Invoices: [HEADER_REVIEW, DATED, _CUSTOMER, _TAXCODE, TAXRATE, TAX],
+}
+
+LISTING_LINK_BUTTON_FUNCTIONS |= { ## complex view
+  Invoices: [add_button, view_button],
+}
+
+LISTING_LINK_CALL_FUNCTIONS |= { ## complex view
+  Invoices: [FUNCTION_INVOICEITEM_INSERT, FUNCTION_INVOICE_SELECT],
+}
+
+LISTING_LINK_ID_FIELDS |= { ## complex view
+  Invoices: [ID, ID],
+}
+
+LISTING_LINK_REF_FIELDS |= { ## complex view
+  Invoices: [INVOICE_ID, ID], ## add-item-line/view-item
+}
+
+## common data frame show
+
+LISTING_FIELDS |= { ## dataset viewer: all columns
+  Invoices: [HEADER_INSERT, HEADER_REVIEW, DATED, NAME, AMOUNT, DISCOUNT, DUE, TAXRATE, STATUS],
+  Invoiceitems: [HEADER_REVIEW, NAME, QUANTITY, PRICE, SUBTOTAL],
+  Payments: [HEADER_REVIEW, DATED, NAME, AMOUNT, TYPE, REF, STATUS],
+}
+
+SELECT_LINK_FIELDS |= { ## single record viewer: vertical view with links
+  Invoices: [CUSTOMER_ID],
+  Invoiceitems: [INVOICE_ID, PRODUCT_ID],
+  Payments: [INVOICE_ID],
+}
+
+SELECT_LISTING_FIELDS |= { ## dataset viewer for popup picker
+  Invoices: [HEADER_SELECT, NAME, STATUS, ID],
+}
+
+LISTING_HEADERS |= { ## dataset viewer: headers of extra columns
+  Invoices: [HEADER_INSERT, HEADER_REVIEW],
+  "Invoices": HEADER_SELECT, ## popup picker
+}
+
+## common data input options
+
+INSERT_INPUTS |= {
+  Invoices: [DATED, DUE, CUSTOMER_ID, NAME, AMOUNT, DISCOUNT, TAXRATE, ORDER_ID, NOTE],
+  InvoicesStatus: [ID, STATUS],
+  Invoiceitems: [INVOICE_ID, PRODUCT_ID, DATED, NAME, QUANTITY, PRICE, SUBTOTAL, NOTE],
+  Payments: [DATED, INVOICE_ID, NAME, AMOUNT, TYPE, REF, NOTE],
+}
+
+UPDATE_INPUTS |= {
+  Invoices: [AUTHOR_ID, NOTE, AMOUNT, DISCOUNT, TAXRATE],
+  "Invoices": [AUTHOR_ID, NOTE],
+  InvoicesStatus: [STATUS],
+  Invoiceitems: [NAME, QUANTITY, PRICE, NOTE],
+  Payments: [NAME, AUTHOR_ID, REF, TYPE, NOTE],
+}
+
+SEARCH_INPUTS |= {
+  Invoices: [NAME, NOTE, AUTHOR_ID],
+}

invoiceum/syslogin.py

@@ -0,0 +1,72 @@
+from orderum.syslogin import *
+
+from tagrepo.auth import check_finance_staff_login, check_finance_supervisor_login
+
+FUNCTION_INVOICE_INSERT = 'insert-invoice'
+FUNCTION_INVOICE_SELECT = 'select-invoice'
+FUNCTION_INVOICE_NOTE_UPDATE = 'note-invoice' ##RES
+FUNCTION_INVOICE_UPDATE = 'update-invoice' ##RES
+FUNCTION_INVOICE_UPGRADE = 'upgrade-invoice'
+
+FUNCTION_INVOICES_SELECT = 'select-invoices'
+FUNCTION_DRAFT_INVOICES_SELECT = 'select-draft-invoices'
+FUNCTION_NO_DRAFT_INVOICES_SELECT = 'select-no-draft-invoices'
+FUNCTION_INVOICES_SEARCH = 'search-invoices'
+FUNCTION_INVOICES_REVIEW = 'review-invoices' ##HID
+FUNCTION_INVOICES_UPDATE = 'update-invoices' ##HID
+
+FUNCTION_INVOICEITEM_INSERT = 'insert-invoiceitem'
+FUNCTION_INVOICEITEM_SELECT = 'select-invoiceitem'
+FUNCTION_INVOICEITEM_UPDATE = 'update-invoiceitem'
+FUNCTION_INVOICEITEMS_SELECT = 'select-invoiceitems'
+
+FUNCTION_INVOICES_AUTHOR_SEARCH = 'search-author-invoices'
+FUNCTION_INVOICES_GLOBAL_SELECT = 'select-global-invoices'
+
+FUNCTION_PAYMENT_INSERT = 'insert-payment'
+FUNCTION_PAYMENT_SELECT = 'select-payment'
+FUNCTION_PAYMENT_UPDATE = 'update-payment'
+FUNCTION_PAYMENT_UPGRADE = 'upgrade-payment' ## HID
+FUNCTION_PAYMENTS_SELECT = 'select-payments'
+FUNCTION_PAYMENTS_REVIEW = 'review-payments'
+FUNCTION_PAYMENTS_SEARCH = 'search-payments' ## HID
+FUNCTION_DRAFT_PAYMENTS_SELECT = 'select-draft-payments'
+FUNCTION_NO_DRAFT_PAYMENTS_SELECT = 'select-no-draft-payments'
+
+FUNCTION_TAX_COLLECT = 'collect-tax'
+FUNCTION_TAX_AGGREGATE = 'aggregate-tax' ## HID
+FUNCTION_INVOICES_POPUP = 'popup-invoices'
+FUNCTION_TYPE_POPUP = 'popup-type'
+
+auth_functions |= {
+  FUNCTION_INVOICE_INSERT: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICE_SELECT: {"func": check_author_login, "args": {"model": "Invoices", "id": ["id"]}},
+  FUNCTION_INVOICE_NOTE_UPDATE: {"func": check_author_login, "args": {"model": "Invoices", "id": ["id"]}},
+  FUNCTION_INVOICE_UPDATE: {"func": check_author_login, "args": {"model": "Invoices", "id": ["id"]}},
+  FUNCTION_INVOICE_UPGRADE: {"func": check_author_login, "args": {"model": "Invoices", "id": ["id"]}},
+  FUNCTION_INVOICES_SELECT: {"func": check_staff_login, "args": {}},
+  FUNCTION_DRAFT_INVOICES_SELECT: {"func": check_staff_login, "args": {}},
+  FUNCTION_NO_DRAFT_INVOICES_SELECT: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICES_SEARCH: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICES_REVIEW: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICES_UPDATE: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICEITEM_INSERT: {"func": check_author_login, "args": {"model": "Invoices", "id": ["invoice_id"]}},
+  FUNCTION_INVOICEITEM_SELECT: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICEITEM_UPDATE: {"func": check_supervisor_login, "args": {}},
+  FUNCTION_INVOICEITEMS_SELECT: {"func": check_author_login, "args": {"model": "Invoices", "id": ["invoice_id"]}},
+  FUNCTION_INVOICES_AUTHOR_SEARCH: {"func": check_staff_login, "args": {}},
+  FUNCTION_INVOICES_GLOBAL_SELECT: {"func": check_staff_login, "args": {}},
+  FUNCTION_PAYMENT_INSERT: {"func": check_finance_staff_login, "args": {}},
+  FUNCTION_PAYMENT_SELECT: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_PAYMENT_UPDATE: {"func": check_finance_supervisor_login, "args": {}},
+  FUNCTION_PAYMENT_UPGRADE: {"func": check_finance_staff_login, "args": {}},
+  FUNCTION_PAYMENTS_SELECT: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_PAYMENTS_REVIEW: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_PAYMENTS_SEARCH: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_DRAFT_PAYMENTS_SELECT: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_NO_DRAFT_PAYMENTS_SELECT: {"func": [check_finance_staff_login, check_staff_login], "args": [{}, {}]},
+  FUNCTION_TAX_COLLECT: {"func": check_finance_staff_login, "args": {}},
+  FUNCTION_TAX_AGGREGATE: {"func": check_finance_supervisor_login, "args": {}},
+  FUNCTION_INVOICES_POPUP: {"func": check_finance_staff_login, "args": {}},
+  FUNCTION_TYPE_POPUP: {"func": check_finance_staff_login, "args": {}},
+}

invoiceum/task.py

@@ -0,0 +1,301 @@
+from tagrepo.database import _log_insert, _log_update
+from tagrepo.format import escape_punctuation_for_title_list
+from tagrepo.param import refresh_form_data_tax
+
+from orderum.task import *
+
+from .param import adjust_invoice_listing_options, adjust_payment_listing_options
+from .template import _selecting_page_, _picking_page_
+
+from .data import *
+from .template import *
+
+def insert_invoice_page(request, **form) -> str:
+  if not form.get(NAME):
+    return invoice_creating_page()
+  elif not check_record_exist(form.get(CUSTOMER_ID), model="Customers", field=ID):
+    return WRONG_CUSTOMER_ID
+  elif check_record_exist(form[NAME], model="Invoices"):
+    return INVOICE_ALREADY_EXISTS
+  elif not valid_percent(numfloat(form.get(DISCOUNT))) or not valid_percent(numfloat(form.get(TAXRATE))):
+    return BAD_INPUT_DATA
+  else:
+    form[AUTHOR_ID] = request.session.get(SESSION_USER)
+    refresh_form_data_tax(form)
+    insert = safe_avro_file_insert("Invoices", multi=True, **form)
+    if not insert: return FAILED_SAVE_DATA
+    _log_insert(request, form, "Invoices")
+    return CALLBACK
+
+def select_invoices_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = INVOICE_NOT_CLOSED if status not in INVOICE_STATUS_LIST else f"status IN ('{status}')"
+  where, sort, asc, limit = adjust_invoice_listing_options(where, author, sort, asc, limit, request=request)
+  return invoices_listing_page(
+    title=INVOICES_LISTING_TITLE,
+    action=f"{FUNCTION_INVOICES_SELECT}&status={status}&author={request.session.get(SESSION_USER)}",
+    content=list_invoices(where=where, sort=sort, asc=asc, limit=limit))
+
+def select_draft_invoices_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = INVOICE_IS_UPDATABLE
+  where, sort, asc, limit = adjust_invoice_listing_options(where, author, sort, asc, limit, request=request)
+  return draft_invoices_listing_page(
+    title=DRAFT_INVOICES_LISTING_TITLE,
+    action=f"{FUNCTION_DRAFT_INVOICES_SELECT}&author={request.session.get(SESSION_USER)}",
+    content=list_invoices_to_insert_invoiceitem(where=where, sort=sort, asc=asc, limit=limit))
+
+def select_no_draft_invoices_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = INVOICE_IS_LISTABLE
+  where, sort, asc, limit = adjust_invoice_listing_options(where, author, sort, asc, limit, request=request)
+  return no_draft_invoices_listing_page(
+    title=NO_DRAFT_INVOICES_LISTING_TITLE,
+    action=f"{FUNCTION_NO_DRAFT_INVOICES_SELECT}&author={request.session.get(SESSION_USER)}",
+    content=list_invoices(where=where, sort=sort, asc=asc, limit=limit))
+
+def select_invoice_page(request, invoice_id: str) -> str:
+  ## <request> is reserved
+  return invoice_selecting_page(
+    (select_invoice(invoice_id) or NO_DATA_AVAILABLE)
+    + html_link_buttons([call_function(f"{FUNCTION_INVOICEITEM_INSERT}&invoice_id={invoice_id}")], [LABEL_CREATE_INVOICEITEM_BUTTON], [STYLE_SUBMIT_BUTTON])
+    + html_link_buttons([call_function(f"{FUNCTION_INVOICEITEMS_SELECT}&invoice_id={invoice_id}")], [LABEL_SELECT_INVOICEITEM_BUTTON], [STYLE_SUBMIT_BUTTON])
+    + html_link_buttons([call_function(f"{FUNCTION_INVOICE_UPGRADE}&id={invoice_id}")], [LABEL_UPGRADE_INVOICE_BUTTON], [STYLE_CANCEL_BUTTON]))
+
+def update_invoice_note_page(request, invoice_id: str, **form) -> str:
+  data = get_invoice(invoice_id)
+  if not data: return NO_DATA_AVAILABLE
+  if not len(form):
+    return invoice_updating_page(
+      title=item_content_title(INVOICE_UPDATING_TITLE, data[NAME]),
+      action=f"{FUNCTION_INVOICE_NOTE_UPDATE}&id={invoice_id}",
+      content=dictfilter(data, UPDATE_INPUTS["Invoices"])) ## notes updated only
+  update = safe_avro_file_update("Invoices", id=invoice_id, **form)
+  if not update: return FAILED_SAVE_DATA
+  _log_update(request, form, "Invoices", id=invoice_id)
+  return CALLBACK
+
+def update_invoice_page(request, invoice_id: str, **form) -> str:
+  data = get_invoice(invoice_id)
+  if not data: return NO_DATA_AVAILABLE
+  if invoice_not_updatable(data): return BAD_INVOICE_ID
+  if not len(form):
+    return invoice_updating_page(
+      title=item_content_title(INVOICE_UPDATING_TITLE, data[NAME]),
+      action=f"{FUNCTION_INVOICE_UPDATE}&id={invoice_id}",
+      content=dictfilter(data, UPDATE_INPUTS[Invoices]))
+  refresh_form_data_tax(form)
+  update = safe_avro_file_update("Invoices", id=invoice_id, **form)
+  if not update: return FAILED_SAVE_DATA
+  _log_update(request, form, "Invoices", id=invoice_id)
+  return CALLBACK
+
+def upgrade_invoice_page(request, invoice_id: str, status: str=None) -> str:
+  if not status:
+    data = get_invoice(invoice_id)
+    if not data: return NO_DATA_AVAILABLE
+    return invoice_upgrading_page(
+      title=item_content_title(INVOICE_UPDATING_TITLE, data[NAME]),
+      current_status=data[STATUS])
+  upgrade = update_close_invoice_page(request, invoice_id, complete_status=status)
+  return upgrade if upgrade not in [DONE_SAVE_DATA] else CALLBACK
+
+def update_close_invoice_page(request, invoice_id: str, complete_status: str=None) -> str:
+  data = get_invoice(invoice_id)
+  if not data: return NO_DATA_AVAILABLE
+  if invoice_closed(data): return INVOICE_NOT_EXIST_OR_CLOSED
+  if complete_status not in INVOICE_STATUS_LIST:
+    status = INVOICE_CANCELLED
+  else:
+    status = complete_status
+  if status in UPDATABLE_INVOICES: return INVOICE_NO_REVERSE_TO_DRAFT
+  amount = calculate_invoice_amount(invoice_id=invoice_id)
+  data[AMOUNT] = amount
+  refresh_form_data_tax(data)
+  tax = data[TAX]
+  update = safe_avro_file_update("Invoices", id=invoice_id, status=status, amount=amount, tax=tax)
+  if not update: return FAILED_SAVE_DATA
+  insert = safe_avro_file_insert("InvoicesStatus", multi=False, id=invoice_id, status=status)
+  if not insert: return FAILED_COMMIT_TRANSACTION
+  return DONE_SAVE_DATA ## dont edit this return
+
+## short form of <orderum.select_product_page>
+def select_product_page(request, product_id: str) -> str:
+  return product_selecting_page(select_product(product_id) or NO_DATA_AVAILABLE)
+
+def insert_invoiceitem_page(request, invoice_id: str, **form) -> str:
+  if invoice_not_updatable(invoice_id): return BAD_INVOICE_ID
+  if not form.get(NAME):
+    invoice_name = get_invoice_name(invoice_id)
+    return invoiceitem_creating_page(
+      title=sub_item_content_title(INVOICEITEMS_CREATING_TITLE, invoice_name, f"{FUNCTION_INVOICE_SELECT}&id={invoice_id}"),
+      action=f"{FUNCTION_INVOICEITEM_INSERT}&invoice_id={invoice_id}")
+  elif invoice_item_duplicated(form.get(NAME), invoice_id):
+    return INVOICE_ITEM_DUPLICATED
+  else:
+    form[INVOICE_ID] = invoice_id
+    refresh_form_data_subtotal(form)
+    insert = safe_avro_file_insert("Invoiceitems", multi=True, **form)
+    if not insert: return FAILED_SAVE_DATA
+    _log_insert(request, form, "Invoiceitems")
+    return CALLBACK
+
+def select_invoiceitems_page(request, invoice_id: str) -> str:
+  ## <request> is reserved
+  if valid_uuid(invoice_id):
+    invoice_name = get_invoice_name(invoice_id)
+    if not invoice_name: return INVOICE_NOT_EXIST
+    return invoiceitems_listing_page(
+      title=sub_item_content_title(INVOICEITEMS_LISTING_TITLE, invoice_name, f"{FUNCTION_INVOICE_SELECT}&id={invoice_id}"),
+      action=f"{FUNCTION_INVOICEITEM_INSERT}&invoice_id={invoice_id}",
+      content=list_invoiceitems(invoice_id))
+  return MISSING_INPUT_DATA
+
+def select_invoiceitem_page(request, invoiceitem_id: str) -> str:
+  ## <request> is reserved
+  return invoiceitem_selecting_page(select_invoiceitem(invoiceitem_id) or NO_DATA_AVAILABLE)
+
+def update_invoiceitem_page(request, invoiceitem_id: str, **form) -> str:
+  data = get_invoiceitem(invoiceitem_id)
+  if not data: return NO_DATA_AVAILABLE
+  if invoice_not_updatable(data[INVOICE_ID]): return BAD_INVOICE_ID
+  if not len(form):
+    invoice_name = get_invoice_name(data[INVOICE_ID])
+    return invoiceitem_updating_page(
+      title=sub_item_content_title(INVOICEITEM_UPDATING_TITLE, invoice_name, f"{FUNCTION_INVOICE_SELECT}&id={data[INVOICE_ID]}"),
+      action=f"{FUNCTION_INVOICEITEM_UPDATE}&id={invoiceitem_id}",
+      content=dictfilter(data, UPDATE_INPUTS[Invoiceitems]))
+  refresh_form_data_subtotal(form)
+  update = safe_avro_file_update("Invoiceitems", id=invoiceitem_id, **form)
+  if not update: return FAILED_SAVE_DATA
+  _log_update(request, form, "Invoiceitems", id=invoiceitem_id)
+  return CALLBACK
+
+def review_invoices_page(request) -> str:
+  ## <request> is reserved
+  return invoices_reviewing_page(INVOICES_LISTING_TITLE)
+
+def search_invoices_page(request, search: str=None, reset=False, seek: str="", author: str="") -> str:
+  if not search:
+    return invoices_searching_page()
+  return invoices_fetching_page(request, search, reset=reset, seek=seek, author=author)
+
+def search_invoices_author_page(request, search: str=None, reset=False, seek: str="") -> str:
+  if not search:
+    return invoices_author_searching_page()
+  return invoices_author_fetching_page(request, search, reset=reset, seek=seek)
+
+def insert_payment_page(request, **form) -> str:
+  if not form.get(NAME) or numfloat(form.get(AMOUNT)) <= 0:
+    return payment_creating_page()
+  elif not check_record_exist(form.get(INVOICE_ID), model="Invoices", field=ID):
+    return WRONG_INVOICE_ID
+  elif check_record_exist(form[NAME], model="Payments"):
+    return PAYMENT_ALREADY_EXISTS
+  else:
+    form[AUTHOR_ID] = request.session.get(SESSION_USER)
+    insert = safe_avro_file_insert("Payments", multi=True, **form)
+    if not insert: return FAILED_SAVE_DATA
+    _log_insert(request, form, "Payments")
+    return CALLBACK
+
+def compact_select_invoices_page() -> str:
+  return _selecting_page_(INVOICES_LISTING_TITLE,
+    list_pick_invoices(where=INVOICE_IS_USABLE, sort=NAME, limit=LIST_MAX_ROWS)
+    + select_invoice_button())
+
+def compact_fetch_invoices_page(search: str) -> str:
+  return _selecting_page_(INVOICES_SEARCHING_TITLE,
+    vector_select_search(search, SEARCH_INPUTS, SEARCH_RESULTS, model="Invoices")
+    + select_invoice_button())
+
+def popup_invoices_page(request, search: str) -> str:
+  ## <request> is reserved
+  if search: return compact_fetch_invoices_page(search)
+  return compact_select_invoices_page()
+
+def select_payments_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = PAYMENT_NOT_CLOSED if status not in PAYMENT_STATUS_LIST else f"status IN ('{status}')"
+  where, sort, asc, limit = adjust_payment_listing_options(where, author, sort, asc, limit, request=request)
+  return payments_listing_page(
+    title=PAYMENTS_LISTING_TITLE,
+    action=f"{FUNCTION_PAYMENTS_SELECT}&status={status}&author={request.session.get(SESSION_USER)}",
+    content=list_payments(where=where, sort=sort, asc=asc, limit=limit))
+
+def select_payment_page(request, payment_id: str) -> str:
+  ## <request> is reserved
+  return payment_selecting_page(
+    (select_payment(payment_id) or NO_DATA_AVAILABLE)
+    + html_link_buttons([call_function(f"{FUNCTION_PAYMENT_UPGRADE}&id={payment_id}")], [LABEL_UPGRADE_PAYMENT_BUTTON], [STYLE_CANCEL_BUTTON]))
+
+def update_payment_page(request, payment_id: str, **form) -> str:
+  data = get_payment(payment_id)
+  if not data: return NO_DATA_AVAILABLE
+  if payment_not_updatable(data): return BAD_PAYMENT_ID
+  if not len(form):
+    return payment_updating_page(
+      title=item_content_title(PAYMENT_UPDATING_TITLE, data[NAME]),
+      action=f"{FUNCTION_PAYMENT_UPDATE}&id={payment_id}",
+      content=dictfilter(data, UPDATE_INPUTS[Payments]))
+  update = safe_avro_file_update("Payments", id=payment_id, **form)
+  if not update: return FAILED_SAVE_DATA
+  _log_update(request, form, "Payments", id=payment_id)
+  return CALLBACK
+
+def upgrade_payment_page(request, payment_id: str, status: str=None) -> str:
+  if not status:
+    data = get_payment(payment_id)
+    if not data: return NO_DATA_AVAILABLE
+    return payment_upgrading_page(
+      title=item_content_title(PAYMENT_UPDATING_TITLE, data[NAME]),
+      current_status=data[STATUS])
+  upgrade = update_close_payment_page(request, payment_id, complete_status=status)
+  return upgrade if upgrade not in [DONE_SAVE_DATA] else CALLBACK
+
+def update_close_payment_page(request, payment_id: str, complete_status: str=None) -> str:
+  data = get_payment(payment_id)
+  if not data: return NO_DATA_AVAILABLE
+  if payment_closed(data): return PAYMENT_NOT_EXIST_OR_CLOSED
+  if complete_status not in PAYMENT_STATUS_LIST:
+    status = PAYMENT_CANCELLED
+  else:
+    status = complete_status
+  update = safe_avro_file_update("Payments", id=payment_id, status=status)
+  if not update: return FAILED_SAVE_DATA
+  insert = safe_avro_file_insert("PaymentsStatus", multi=False, id=payment_id, status=status)
+  if not insert: return FAILED_COMMIT_TRANSACTION
+  return DONE_SAVE_DATA ## dont edit this return
+
+def popup_type_page(request) -> str:
+  ## <request> is reserved
+  return compact_select_type_page(TYPE_PICKING_TITLE, LABEL_TYPE_PICKING_BUTTON)
+
+def compact_select_type_page(title, pick_button, picker=TYPE, pick_data=PAYMENT_TYPE_LIST, opener_getter="") -> str:
+  data = escape_punctuation_for_title_list(pick_data)
+  ## module <tagrepo.datatemp> must be upgraded to use <schema15> libs
+  return _picking_page_(title, data, pick_button, picker=picker, getter=opener_getter)
+
+def select_draft_payments_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = PAYMENT_IS_UPDATABLE
+  where, sort, asc, limit = adjust_payment_listing_options(where, author, sort, asc, limit, request=request)
+  return draft_payments_listing_page(
+    title=DRAFT_PAYMENTS_LISTING_TITLE,
+    action=f"{FUNCTION_DRAFT_PAYMENTS_SELECT}&author={request.session.get(SESSION_USER)}",
+    content=list_payments(where=where, sort=sort, asc=asc, limit=limit))
+
+def select_no_draft_payments_page(request, status: str="", sort: str="", asc: str="", limit: str="", author: str="") -> str:
+  where = PAYMENT_IS_LISTABLE
+  where, sort, asc, limit = adjust_payment_listing_options(where, author, sort, asc, limit, request=request)
+  return no_draft_payments_listing_page(
+    title=NO_DRAFT_PAYMENTS_LISTING_TITLE,
+    action=f"{FUNCTION_NO_DRAFT_PAYMENTS_SELECT}&author={request.session.get(SESSION_USER)}",
+    content=list_payments(where=where, sort=sort, asc=asc, limit=limit))
+
+def review_payments_page(request) -> str:
+  ## <request> is reserved
+  return payments_reviewing_page(PAYMENTS_LISTING_TITLE)
+
+def _date_range_fieldset(labels: list=[LABEL_TAX_START, LABEL_TAX_END], legend: str=LABEL_TAX_RANGE_INPUT_PARAMS) -> str:
+  return html_input_date_range_fieldset(DATED, DATED, labels=labels, legend=legend)
+
+def collect_tax_invoices_page(request, dated: str=None, dated_end: str=None) -> str:
+  ## <request> is reserved
+  if not dated: return tax_invoices_collecting_open_page(_date_range_fieldset())
+  return tax_invoices_collecting_page(list_tax_invoices(dated=dated, dated_end=dated_end))

invoiceum/template.py

@@ -0,0 +1,140 @@
+from tagrepo.datatemp import _creating_page, _selecting_page, _listing_page, _updating_page, _searching_page, _upgrading_page, _reviewing_page, _fetching_page, _picking_page
+
+from orderum.template import *
+
+from .data import *
+from .title import *
+
+## private functions
+
+def _upgrading_page_(title, current_status, status_id="INVOICE_STATUS_LIST") -> str:
+  return _upgrading_page(title, current_status, status_id, app_desc=APP_DESC)
+
+def _reviewing_page_(title, status_id="INVOICE_STATUS_LIST") -> str:
+  return _reviewing_page(title, status_id=status_id, app_desc=APP_DESC)
+
+def _fetching_page_(request, search: str, reset: bool=False, title: str=INVOICES_SEARCHING_TITLE, model: str="Invoices", callfunction: str=FUNCTION_INVOICE_SELECT, seek: str="", app_desc: str=APP_DESC, search_inputs: dict=SEARCH_INPUTS, search_results: int=SEARCH_RESULTS, search_option=get_search_author_option) -> str:
+  return _fetching_page(request, search, reset=reset, title=title, model=model, callfunction=callfunction, seek=seek, app_desc=app_desc, search_inputs=search_inputs, search_results=search_results, search_option=search_option)
+
+def _selecting_page_(title, content) -> str:
+  return _selecting_page(title, content, app_desc=APP_DESC)
+
+def _listing_page_(title, action, content, submit_button) -> str:
+  return _listing_page(title, action, content, submit_button, app_desc=APP_DESC)
+
+def _updating_page_(title, action, content: dict) -> str:
+  return _updating_page(title, action, content, app_desc=APP_DESC)
+
+def _searching_page_(title, search_id="AUTHOR_SEARCH_OPTIONS") -> str:
+  return _searching_page(title, search_id, app_desc=APP_DESC)
+
+def _picking_page_(title: str, content: list[dict], pick_button: str, picker: str, getter=NAME) -> str:
+  return _picking_page(title=title, content=content, pick_button=pick_button, picker=picker, getter=getter, app_desc=APP_DESC)
+
+## public functions
+
+def invoice_creating_page() -> str:
+  return _creating_page(
+    title=INVOICES_CREATING_TITLE,
+    action=FUNCTION_INVOICE_INSERT,
+    model="Invoices",
+    input_label=LABEL_INVOICE_INPUT_PARAMS,
+    input_fields=INVOICE_INSERT_FIELDS,
+    app_desc=APP_DESC,
+    onsubmit=html_form_onsubmit(ARE_YOU_SURE),
+    customer_id=html_popup_input_wide_text(CUSTOMER_ID, CUSTOMER_ID, "customer_id", label=LABEL_INVOICE_CUSTOMER_ID, popup_page=FUNCTION_CUSTOMERS_POPUP),
+    dated=html_input_date(DATED, DATED, LABEL_INVOICE_DATED),
+    due=html_input_date(DUE, DUE, LABEL_INVOICE_DUE),
+    note=html_input_textarea(NOTE, NOTE))
+
+def invoices_listing_page(title: str, action: str, content: str, label: str=LABEL_SELECT_OWN_INVOICE_BUTTON) -> str:
+  return _listing_page_(title, action, content, submit_button=label)
+
+draft_invoices_listing_page = invoices_listing_page
+no_draft_invoices_listing_page = invoices_listing_page
+
+def invoice_selecting_page(content: str) -> str:
+  return _selecting_page_(title=INVOICE_INFO_TITLE, content=content)
+
+invoice_updating_page = _updating_page_
+
+def invoice_upgrading_page(title: str, current_status: str) -> str:
+  return _upgrading_page_(title=title, current_status=current_status, status_id="INVOICE_STATUS_LIST")
+
+def invoiceitem_creating_page(title: str, action: str) -> str:
+  return _creating_page(
+    title=title,
+    action=action,
+    model="Invoiceitems",
+    input_label=LABEL_INVOICEITEM_INPUT_PARAMS,
+    input_fields=INVOICEITEM_INSERT_FIELDS,
+    app_desc=APP_DESC,
+    product_id=html_popup_input_wide_text(PRODUCT_ID, PRODUCT_ID, "product_id", label=LABEL_INVOICEITEM_PRODUCT_ID, popup_page=FUNCTION_PRODUCTS_POPUP),
+    note=html_input_textarea(NOTE, NOTE))
+
+def invoiceitems_listing_page(title: str, action: str, content: str, label: str=LABEL_CREATE_INVOICEITEM_BUTTON) -> str:
+  return _listing_page_(title, action, content, submit_button=label)
+
+def invoiceitem_selecting_page(content: str) -> str:
+  return _selecting_page_(title=INVOICEITEM_INFO_TITLE, content=content)
+
+invoiceitem_updating_page = _updating_page_
+
+def invoices_reviewing_page(title: str) -> str:
+  return _reviewing_page_(title)
+
+## vector search
+
+def invoices_searching_page() -> str:
+  return _searching_page_(title=INVOICES_SEARCHING_TITLE, search_id="INVOICE_SEARCH_OPTIONS")
+
+def invoices_fetching_page(request, search: str, reset: bool=False, seek: str="", author: str="") -> str:
+  return _fetching_page_(request, search, reset=reset, seek=seek, search_option=get_search_invoice_option(request, seek, author=author))
+
+def invoices_author_searching_page() -> str:
+  return _searching_page_(title=INVOICES_SEARCHING_TITLE)
+
+def invoices_author_fetching_page(request, search: str, reset: bool=False, seek: str="") -> str:
+  return _fetching_page_(request, search, reset=reset, seek=seek, title=INVOICES_SEARCHING_TITLE, model="Invoices", callfunction=FUNCTION_INVOICE_SELECT)
+
+## invoice payments
+
+def payment_creating_page() -> str:
+  return _creating_page(
+    title=PAYMENTS_CREATING_TITLE,
+    action=FUNCTION_PAYMENT_INSERT,
+    model="Payments",
+    input_label=LABEL_PAYMENT_INPUT_PARAMS,
+    input_fields=PAYMENT_INSERT_FIELDS,
+    app_desc=APP_DESC,
+    onsubmit=html_form_onsubmit(ARE_YOU_SURE),
+    invoice_id=html_popup_input_wide_text(INVOICE_ID, INVOICE_ID, "invoice_id", label=LABEL_PAYMENT_INVOICE_ID, popup_page=FUNCTION_INVOICES_POPUP),
+    type=html_select_options(TYPE, PAYMENT_TYPES, list_captioning("PAYMENT_TYPES")),
+    dated=html_input_date(DATED, DATED, LABEL_PAYMENT_DATED),
+    note=html_input_textarea(NOTE, NOTE))
+
+def select_invoice_button() -> str:
+  return html_pass_buttons([INVOICE_ID], [ID], [LABEL_SELECT_INVOICE_BUTTON], [STYLE_SUBMIT_BUTTON])
+
+def payments_listing_page(title: str, action: str, content: str, label: str=LABEL_SELECT_OWN_PAYMENT_BUTTON) -> str:
+  return _listing_page_(title, action, content, submit_button=label)
+
+def payment_selecting_page(content: str) -> str:
+  return _selecting_page_(title=PAYMENT_INFO_TITLE, content=content)
+
+payment_updating_page = _updating_page_
+
+def payment_upgrading_page(title: str, current_status: str) -> str:
+  return _upgrading_page_(title=title, current_status=current_status, status_id="PAYMENT_STATUS_LIST")
+
+draft_payments_listing_page = payments_listing_page
+no_draft_payments_listing_page = payments_listing_page
+
+def payments_reviewing_page(title: str) -> str:
+  return _reviewing_page_(title, status_id="PAYMENT_STATUS_LIST")
+
+def tax_invoices_collecting_open_page(content: str) -> str:
+  return _listing_page_(INVOICES_TAX_LISTING_TITLE, FUNCTION_TAX_COLLECT, content, LABEL_SUBMIT_BUTTON)
+
+def tax_invoices_collecting_page(content: str) -> str:
+  return _selecting_page_(title=INVOICES_TAX_TITLE, content=content)

invoiceum/title.py

@@ -0,0 +1,70 @@
+from orderum.title import *
+
+APP_DESC = 'Literp Invoicing Management'
+
+set_environ('FORM_TITLE', 'Invoicing Management')
+
+set_environ('LABEL_INVOICE_INSERT', 'Add Invoice')
+set_environ('LABEL_INVOICES_SELECT', 'List Invoices')
+set_environ('LABEL_DRAFT_INVOICES_SELECT', 'Fill Invoices')
+set_environ('LABEL_NO_DRAFT_INVOICES_SELECT', 'Browse Invoices')
+set_environ('LABEL_INVOICES_REVIEW', 'Review Invoices')
+set_environ('LABEL_PAYMENT_INSERT', 'Add Payment')
+set_environ('LABEL_PAYMENTS_SELECT', 'List Payments')
+set_environ('LABEL_DRAFT_PAYMENTS_SELECT', 'Approve Payments')
+set_environ('LABEL_NO_DRAFT_PAYMENTS_SELECT', 'Browse Payments')
+set_environ('LABEL_PAYMENTS_REVIEW', 'Review Payments')
+set_environ('LABEL_TAX_COLLECT', 'Taxes Payable')
+set_environ('LABEL_INVOICES_SEARCH', 'Invoices')
+
+set_environ('LABEL_UPGRADE_INVOICE_BUTTON', 'Update Invoice Status')
+set_environ('LABEL_SELECT_OWN_INVOICE_BUTTON', 'List My Invoices')
+set_environ('LABEL_CREATE_INVOICEITEM_BUTTON', 'Add Invoice Item')
+set_environ('LABEL_SELECT_INVOICEITEM_BUTTON', 'List Invoice Items')
+set_environ('LABEL_SELECT_INVOICE_BUTTON', 'Pick Selected')
+
+set_environ('LABEL_INVOICE_INPUT_PARAMS', 'Invoice metadata')
+set_environ('LABEL_INVOICE_CUSTOMER_ID', 'Customer ID')
+set_environ('LABEL_INVOICE_DATED', 'Issue Date')
+set_environ('LABEL_INVOICE_DUE', 'Due Date')
+set_environ('LABEL_INVOICEITEM_PRODUCT_ID', 'Product ID')
+set_environ('LABEL_INVOICEITEM_INPUT_PARAMS', 'Invoice item info')
+
+set_environ('INVOICES_CREATING_TITLE', 'Invoices Creating')
+set_environ('INVOICES_LISTING_TITLE', 'Invoices Listing')
+set_environ('DRAFT_INVOICES_LISTING_TITLE', 'Draft Invoices Listing')
+set_environ('NO_DRAFT_INVOICES_LISTING_TITLE', 'Live Invoices Listing')
+
+set_environ('INVOICES_SEARCHING_TITLE', 'Invoices Searching')
+set_environ('INVOICE_INFO_TITLE', 'Invoice Detailed Information')
+set_environ('INVOICE_UPDATING_TITLE', 'Invoice Info Update')
+
+set_environ('INVOICEITEMS_CREATING_TITLE', 'Invoice Items Creating')
+set_environ('INVOICEITEMS_LISTING_TITLE', 'Invoice Items Listing')
+set_environ('INVOICEITEM_INFO_TITLE', 'Invoice Item Information')
+set_environ('INVOICEITEM_UPDATING_TITLE', 'Invoice Item Update')
+
+set_environ('LABEL_PAYMENT_INPUT_PARAMS', 'Payment metadata')
+set_environ('LABEL_PAYMENT_INVOICE_ID', 'Invoice ID')
+set_environ('LABEL_PAYMENT_DATED', 'Payment Date')
+
+set_environ('LABEL_UPGRADE_PAYMENT_BUTTON', 'Update Payment Status')
+set_environ('LABEL_SELECT_OWN_PAYMENT_BUTTON', 'List My Payments')
+
+set_environ('PAYMENTS_CREATING_TITLE', 'Payments Creating')
+set_environ('PAYMENTS_LISTING_TITLE', 'Payments Listing')
+set_environ('DRAFT_PAYMENTS_LISTING_TITLE', 'Draft Payments Listing')
+set_environ('NO_DRAFT_PAYMENTS_LISTING_TITLE', 'Live Payments Listing')
+
+set_environ('PAYMENT_INFO_TITLE', 'Payment Detailed Information')
+set_environ('PAYMENT_UPDATING_TITLE', 'Payment Info Update')
+
+set_environ('TYPE_PICKING_TITLE', 'Payment Type Picking')
+set_environ('LABEL_TYPE_PICKING_BUTTON', 'Pick Selected Payment Type')
+
+set_environ('LABEL_TAX_RANGE_INPUT_PARAMS', 'Taxable invoice date range')
+set_environ('LABEL_TAX_START', 'Starting')
+set_environ('LABEL_TAX_END', 'Ending')
+
+set_environ('INVOICES_TAX_LISTING_TITLE', 'Taxes Payable Listing')
+set_environ('INVOICES_TAX_TITLE', 'Taxes Payable')

invoiceum-1.0.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: invoiceum
+Version: 1.0.0
+Summary: Literp Invoicing Web Tool
+Home-page: https://github.com/asinerum/invoiceum
+Author: Asinerum Conlang Project
+Author-email: asinerum.com@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tagrepo>=1.0.15
+Requires-Dist: orderum>=1.0.1
+Dynamic: license-file
+
+# Literp Invoicing Tool
+
+## Installation
+```bash
+pip install invoiceum
+```
+
+## Sample Usage [Nov 1, 2026]
+```bash
+## nano invoiceum.sh
+export LLM_TRANSFORMER_MODEL="./all-MiniLM-L6-v2"
+export SETUPKEY_ENCRYPT_SECRET="very-strong-password"
+export JWT_SECRET="very-strong-password"
+export TOKEN_EXPIRE_MINUTES=30
+export ADMIN_AUTHENTICATOR_EMAIL_LIST=someone@company.com
+export SUPERVISOR_AUTHENTICATOR_EMAIL_LIST=""
+export STAFF_AUTHENTICATOR_EMAIL_LIST=""
+export FINANCE_SUPERVISOR_AUTHENTICATOR_EMAIL_LIST=""
+export FINANCE_STAFF_AUTHENTICATOR_EMAIL_LIST=""
+export FILE_AVRO_DATA="./users/setupkeys.avro"
+export FILE_AVRO_FINANCE_SUPERVISORS="./users/rolefbksupervisors.avro"
+export FILE_AVRO_FINANCE_STAFF="./users/rolefbkstaff.avro"
+export FILE_AVRO_SUPERVISORS="./users/rolecrmsupervisors.avro"
+export FILE_AVRO_STAFF="./users/rolecrmstaff.avro"
+export FILE_DUCKDB_VECTOR="./temp.db"
+uvia -a vapp -m invoiceum [-p <PORT>] [-H <HOST>]
+## The <PORT> is 21911 by default, but can be edited
+## The <HOST> should be 127.0.0.1 for security reason
+## chmod +x invoiceum.sh
+## ./invoiceum.sh
+```
+
+Detailed tips, tricks, and examples, can be found at project's repository
+https://github.com/asinerum/invoiceum
+
+(C) 2026 Asinerum Conlang Project

invoiceum-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+invoiceum/__init__.py,sha256=XZXKnUj-WIqOvYMHiMmi_SSuRP7Ff9v4XgUo81k0EzI,50
+invoiceum/cinvoice.py,sha256=sH72ZSZ9qYIXa-Q0bzB9CDYPqq8MIrYr65F3G2qi85o,12173
+invoiceum/data.py,sha256=Km2dFJOjCrk1D6rRYdU-zlgCW1_MkX3Z2DFNhLICD2o,5493
+invoiceum/environ.py,sha256=ZDAM6lXdI2DYYyUrG-m9W3FHZ2Fn1b5SIHg34eUbjJM,1033
+invoiceum/param.py,sha256=srLjVRdi-9Y4BEbo7xoL-uEC8f6pyfydhXyTQoSgATo,1043
+invoiceum/schema.py,sha256=N-_wNLS9aZ4NxB8UiFqMdP8pUI9p_h09DPvkcEZQTGY,3272
+invoiceum/syslogin.py,sha256=KgTyO9ienMwkRRsC1Zt7X7D5VrlVTPt0Y1x3QzSGOZU,4232
+invoiceum/task.py,sha256=4qv9GMkCvCBElcWMoqDzS5I23qLJBP2_UstED18pAlo,15245
+invoiceum/template.py,sha256=yo1XxRzDJ2rXmflBcXuqTCepFkV-n97K5Zju3RabssA,6775
+invoiceum/title.py,sha256=VUzS8YJsUMpFCMqi-49NHSS5KDYaDF_HF11pumpkf3A,3356
+invoiceum-1.0.0.dist-info/licenses/LICENSE,sha256=4npUbkrpgB6lqMiYYeUxZAP4SOkjVSwK8-7jW60mxvw,1081
+invoiceum-1.0.0.dist-info/METADATA,sha256=-nonKPqvUuIJvSuXx_YaOgWN-56Fi5yFht4m_WVf_0Y,1829
+invoiceum-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+invoiceum-1.0.0.dist-info/top_level.txt,sha256=v0vVcB4W2i919Js9YPoXrS9XnS3lB1AvHiwklTYgXSA,10
+invoiceum-1.0.0.dist-info/RECORD,,

invoiceum-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

invoiceum-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Asinerum Conlang Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

invoiceum-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+invoiceum