X-Git-Url: https://plomlompom.com/repos/feed.xml?a=blobdiff_plain;f=ledger.py;h=c004d22126846415a916e02a6bc4aad6052df9bf;hb=75169bb51854ec32d147976ac4381c6011c5320d;hp=640c63afca0a601488ca55fce96a311cec60aa89;hpb=ed21ddf65324afb6cdce3aec0b97449e6c5c2829;p=misc diff --git a/ledger.py b/ledger.py index 640c63a..c004d22 100755 --- a/ledger.py +++ b/ledger.py @@ -1,7 +1,9 @@ from http.server import BaseHTTPRequestHandler, HTTPServer -import sys import os import html +import jinja2 +import decimal +from datetime import datetime, timedelta from urllib.parse import parse_qs, urlparse hostName = "localhost" serverPort = 8082 @@ -11,11 +13,6 @@ class HandledException(Exception): pass -def handled_error_exit(msg): - print(f"ERROR: {msg}") - sys.exit(1) - - def apply_booking_to_account_balances(account_sums, account, currency, amount): if not account in account_sums: account_sums[account] = {currency: amount} @@ -25,16 +22,59 @@ def apply_booking_to_account_balances(account_sums, account, currency, amount): account_sums[account][currency] += amount -def parse_lines(lines): - import datetime - import decimal +def bookings_to_account_tree(bookings): + account_sums = {} + for booking in bookings: + for account, changes in booking.account_changes.items(): + for currency, amount in changes.items(): + apply_booking_to_account_balances(account_sums, account, currency, amount) + account_tree = {} + def collect_branches(account_name, path): + node = account_tree + path_copy = path[:] + while len(path_copy) > 0: + step = path_copy.pop(0) + node = node[step] + toks = account_name.split(":", maxsplit=1) + parent = toks[0] + if parent in node.keys(): + child = node[parent] + else: + child = {} + node[parent] = child + if len(toks) == 2: + k, v = collect_branches(toks[1], path + [parent]) + if k not in child.keys(): + child[k] = v + else: + child[k].update(v) + return parent, child + for account_name in sorted(account_sums.keys()): + k, v = collect_branches(account_name, []) + if k not in account_tree.keys(): + account_tree[k] = v + else: + account_tree[k].update(v) + def collect_totals(parent_path, tree_node): + for k, v in tree_node.items(): + child_path = parent_path + ":" + k + for currency, amount in collect_totals(child_path, v).items(): + apply_booking_to_account_balances(account_sums, parent_path, currency, amount) + return account_sums[parent_path] + for account_name in account_tree.keys(): + account_sums[account_name] = collect_totals(account_name, account_tree[account_name]) + return account_tree, account_sums + + +def parse_lines(lines, validate_bookings=True): inside_booking = False date_string, description = None, None booking_lines = [] start_line = 0 bookings = [] comments = [] - lines += [''] # to ensure a booking-ending last line + lines = lines.copy() + [''] # to ensure a booking-ending last line + last_date = '' for i, line in enumerate(lines): prefix = f"line {i}" # we start with the case of an utterly empty line @@ -45,7 +85,7 @@ def parse_lines(lines): # assume we finished a booking, finalize, and commit to DB if len(booking_lines) < 2: raise HandledException(f"{prefix} booking ends to early") - booking = Booking(date_string, description, booking_lines, start_line) + booking = Booking(date_string, description, booking_lines, start_line, validate_bookings) bookings += [booking] # expect new booking to follow so re-zeroall booking data inside_booking = False @@ -55,7 +95,7 @@ def parse_lines(lines): # if non-empty line, first get comment if any, and commit to DB split_by_comment = stripped_line.split(sep=";", maxsplit=1) if len(split_by_comment) == 2: - comments[i] = split_by_comment[1] + comments[i] = split_by_comment[1].lstrip() # if pre-comment empty: if inside_booking, this must be a comment-only line so we keep it for later ledger-output to capture those comments; otherwise, no more to process for this line non_comment = split_by_comment[0].rstrip() if non_comment.rstrip() == '': @@ -68,9 +108,12 @@ def parse_lines(lines): toks = non_comment.split(maxsplit=1) date_string = toks[0] try: - datetime.datetime.strptime(date_string, '%Y-%m-%d') + datetime.strptime(date_string, '%Y-%m-%d') except ValueError: raise HandledException(f"{prefix} bad date string: {date_string}") + if last_date > date_string: + raise HandledException(f"{prefix} out-of-order-date") + last_date = date_string try: description = toks[1] except IndexError: @@ -136,25 +179,27 @@ def parse_lines(lines): raise HandledException(f"{prefix} amount has multiple dots: {value}") dots_counted += 1 amount_string += c - if len(amount_string) == 0: - raise HandledException(f"{prefix} amount missing: {value}") if len(currency) == 0: raise HandledException(f"{prefix} currency missing: {value}") - amount = decimal.Decimal(amount_string) + if len(amount_string) > 0: + amount = decimal.Decimal(amount_string) booking_lines += [(account_name, amount, currency)] if inside_booking: raise HandledException(f"{prefix} last booking unfinished") return bookings, comments + class Booking: - def __init__(self, date_string, description, booking_lines, start_line): + def __init__(self, date_string, description, booking_lines, start_line, process=True): self.date_string = date_string self.description = description self.lines = booking_lines self.start_line = start_line - self.validate_booking_lines() - self.account_changes = self.parse_booking_lines_to_account_changes() + if process: + self.validate_booking_lines() + self.sink = {} + self.account_changes = self.parse_booking_lines_to_account_changes() def validate_booking_lines(self): prefix = f"booking at line {self.start_line}" @@ -175,7 +220,7 @@ class Booking: if empty_values == 0: for k, v in sums.items(): if v != 0: - raise HandledException(f"{prefix} does not sum up to zero") + raise HandledException(f"{prefix} does not add up to zero / {k} {v}") else: sinkable = False for k, v in sums.items(): @@ -203,6 +248,7 @@ class Booking: if sink_account: for currency, amount in debt.items(): apply_booking_to_account_balances(account_changes, sink_account, currency, -amount) + self.sink[currency] = -amount return account_changes @@ -218,154 +264,432 @@ class Database: self.real_lines = [] if os.path.exists(self.db_file): with open(self.db_file, "r") as f: - self.real_lines += f.readlines() + self.real_lines += [l.rstrip() for l in f.readlines()] ret = parse_lines(self.real_lines) self.bookings += ret[0] self.comments += ret[1] def get_lines(self, start, end): - return db.real_lines[start:end] + return self.real_lines[start:end] - def replace(self, start, end, lines): + def write_db(self, text, mode='w'): import shutil if os.path.exists(self.lock_file): raise HandledException('Sorry, lock file!') - if os.path.exists(self.db_file): - shutil.copy(self.db_file, self.db_file + ".bak") f = open(self.lock_file, 'w+') f.close() - text = ''.join(self.real_lines[:start]) + '\n'.join(lines) + ''.join(self.real_lines[end:]) - with open(self.db_file, 'w') as f: + + # collect modification times of numbered .bak files + bak_prefix = f'{self.db_file}.bak.' + backup_dates = [] + i = 0 + bak_as = f'{bak_prefix}{i}' + while os.path.exists(bak_as): + mod_time = os.path.getmtime(bak_as) + backup_dates += [str(datetime.fromtimestamp(mod_time))] + i += 1 + bak_as = f'{bak_prefix}{i}' + + # collect what numbered .bak files to save: the older, the fewer; for each + # timedelta, keep the newest file that's older + ages_to_keep = [timedelta(minutes=4**i) for i in range(0, 8)] + now = datetime.now() + to_save = [] + for age in ages_to_keep: + limit = now - age + for i, date in enumerate(reversed(backup_dates)): + if datetime.strptime(date, '%Y-%m-%d %H:%M:%S.%f') < limit: + unreversed_i = len(backup_dates) - i - 1 + if unreversed_i not in to_save: + to_save += [unreversed_i] + break + + # remove redundant backup files + j = 0 + for i in to_save: + if i != j: + source = f'{bak_prefix}{i}' + target = f'{bak_prefix}{j}' + shutil.move(source, target) + j += 1 + for i in range(j, len(backup_dates)): + try: + os.remove(f'{bak_prefix}{i}') + except FileNotFoundError: + pass + + # put copy of current state at end of bak list + shutil.copy(self.db_file, f'{bak_prefix}{j}') + with open(self.db_file, mode) as f: f.write(text); os.remove(self.lock_file) - def append(self, lines): - import shutil - if os.path.exists(self.lock_file): - raise HandledException('Sorry, lock file!') - if os.path.exists(self.db_file): - shutil.copy(self.db_file, self.db_file + ".bak") - f = open(self.lock_file, 'w+') - f.close() - with open(self.db_file, 'a') as f: - f.write('\n' + '\n'.join(lines) + '\n'); - os.remove(self.lock_file) + def insert_at_date(self, lines, date): + start_at = len(self.real_lines) + for b in self.bookings: + if b.date_string == date: + start_at = b.start_line + break + elif b.date_string > date: + break + if start_at == len(self.real_lines): + lines = [''] + lines + return self.write_lines_in_total_lines_at(self.real_lines, start_at, lines) + + def update(self, start, end, lines, date): + total_lines = self.real_lines[:start] + self.real_lines[end:] + n_original_lines = end - start + start_at = len(total_lines) + for b in self.bookings: + if b.date_string == date: + if start_at == len(total_lines) or b.start_line == start: + start_at = b.start_line + if b.start_line > start: + start_at -= n_original_lines + elif b.date_string > date: + break + if start_at == len(total_lines): + lines = [''] + lines + return self.write_lines_in_total_lines_at(total_lines, start_at, lines) + + def write_lines_in_total_lines_at(self, total_lines, start_at, lines): + total_lines = total_lines[:start_at] + lines + [''] + total_lines[start_at:] + _, _ = parse_lines(lines) + text = '\n'.join(total_lines) + self.write_db(text) + return start_at + + def get_nth_for_booking_of_start_line(self, start_line): + nth = 0 + for b in self.bookings: + if b.start_line >= start_line: + break + nth += 1 + return nth + + def add_taxes(self, lines, finish=False): + ret = [] + bookings, _ = parse_lines(lines) + date = bookings[0].date_string + acc_kk_add = 'Reserves:KrankenkassenBeitragsWachstum' + acc_kk_minimum = 'Reserves:Month:KrankenkassenDefaultBeitrag' + acc_kk = 'Expenses:KrankenKasse' + acc_est = 'Reserves:Einkommenssteuer' + acc_assets = 'Assets' + acc_buffer = 'Reserves:NeuAnfangsPuffer:Ausgaben' + last_monthbreak_assets = 0 + last_monthbreak_est = 0 + last_monthbreak_kk_minimum = 0 + last_monthbreak_kk_add = 0 + buffer_expenses = 0 + kk_expenses = 0 + est_expenses = 0 + months_passed = -int(finish) + for b in self.bookings: + if date == b.date_string: + break + acc_keys = b.account_changes.keys() + if acc_buffer in acc_keys: + buffer_expenses -= b.account_changes[acc_buffer]['€'] + if acc_kk_add in acc_keys: + kk_expenses += b.account_changes[acc_kk_add]['€'] + if acc_kk in acc_keys: + kk_expenses += b.account_changes[acc_kk]['€'] + if acc_est in acc_keys: + est_expenses += b.account_changes[acc_est]['€'] + if acc_kk_add in acc_keys and acc_kk_minimum in acc_keys: + months_passed += 1 + if finish: + last_monthbreak_kk_add = b.account_changes[acc_kk_add]['€'] + last_monthbreak_est = b.account_changes[acc_est]['€'] + last_monthbreak_kk_minimum = b.account_changes[acc_kk_minimum]['€'] + last_monthbreak_assets = b.account_changes[acc_buffer]['€'] + old_needed_income_before_anything = - last_monthbreak_assets - last_monthbreak_kk_add - last_monthbreak_kk_minimum - last_monthbreak_est + if finish: + ret += [f' {acc_est} {-last_monthbreak_est}€ ; for old assumption of needed income: {old_needed_income_before_anything}€'] + _, account_sums = bookings_to_account_tree(bookings) + expenses_so_far = -1 * account_sums[acc_assets]['€'] + old_needed_income_before_anything + needed_income_before_kk = expenses_so_far + ESt_this_month = 0 + left_over = needed_income_before_kk - ESt_this_month + too_low = 0 + too_high = 2 * needed_income_before_kk + E0 = decimal.Decimal(10908) + E1 = decimal.Decimal(15999) + E2 = decimal.Decimal(62809) + E3 = decimal.Decimal(277825) + while True: + zvE = buffer_expenses - kk_expenses + (12 - months_passed) * needed_income_before_kk + if finish: + zvE += last_monthbreak_assets + last_monthbreak_kk_add + last_monthbreak_kk_minimum + if zvE < E0: + ESt = decimal.Decimal(0) + elif zvE < E1: + y = (zvE - E0)/10000 + ESt = (decimal.Decimal(979.18) * y + 1400) * y + elif zvE < E2: + y = (zvE - E1)/10000 + ESt = (decimal.Decimal(192.59) * y + 2397) * y + decimal.Decimal(966.53) + elif zvE < E3: + ESt = decimal.Decimal(0.42) * (zvE - decimal.Decimal(62809)) + decimal.Decimal(16405.54) + else: + ESt = decimal.Decimal(0.45) * (zvE - decimal.Decimal(277825)) + decimal.Decimal(106713.52) + ESt_this_month = (ESt + last_monthbreak_est - est_expenses) / (12 - months_passed) + left_over = needed_income_before_kk - ESt_this_month + if abs(left_over - expenses_so_far) < 0.001: + break + elif left_over < expenses_so_far: + too_low = needed_income_before_kk + elif left_over > expenses_so_far: + too_high = needed_income_before_kk + needed_income_before_kk = too_low + (too_high - too_low)/2 + ESt_this_month = ESt_this_month.quantize(decimal.Decimal('0.00')) + ret += [f' {acc_est} {ESt_this_month}€ ; expenses so far: {expenses_so_far:.2f}€; zvE: {zvE:.2f}€; ESt total: {ESt:.2f}€; needed before Krankenkasse: {needed_income_before_kk:.2f}€'] + kk_minimum_income = 1131.67 + if date < '2023-02-01': + kk_minimum_income = decimal.Decimal(1096.67) + kk_factor = decimal.Decimal(0.189) + kk_minimum_tax = decimal.Decimal(207.27).quantize(decimal.Decimal('0.00')) + elif date < '2023-08-01': + kk_factor = decimal.Decimal(0.191) + kk_minimum_tax = decimal.Decimal(216.15).quantize(decimal.Decimal('0.00')) + else: + kk_factor = decimal.Decimal(0.197) + kk_minimum_tax = decimal.Decimal(222.94).quantize(decimal.Decimal('0.00')) + kk_add_so_far = account_sums[acc_kk_add]['€'] if acc_kk_add in account_sums.keys() else 0 + kk_add = needed_income_before_kk / (1 - kk_factor) - needed_income_before_kk - kk_minimum_tax + hit_kk_minimum_income_limit = False + if kk_add_so_far + kk_add < 0: + hit_kk_minimum_income_limit = True + kk_add_uncorrect = kk_add + kk_add = -(kk_add + kk_add_so_far) + kk_add = decimal.Decimal(kk_add).quantize(decimal.Decimal('0.00')) + if finish: + ret += [f' {acc_kk_add} {-last_monthbreak_kk_add}€ ; for old assumption of needed income'] + else: + ret += [f' {acc_kk_minimum} {kk_minimum_tax}€ ; assumed minimum income {kk_minimum_income:.2f}€ * {kk_factor:.3f}'] + if hit_kk_minimum_income_limit: + ret += [f' {acc_kk_add} {kk_add}€ ; {needed_income_before_kk:.2f}€ / (1 - {kk_factor:.3f}) - {needed_income_before_kk:.2f}€ - {kk_minimum_tax}€ = {kk_add_uncorrect:.2f}€ would reduce current {acc_kk_dd} ({kk_add_so_far:.2f}€) below 0'] + else: + ret += [f' {acc_kk_add} {kk_add}€ ; {needed_income_before_kk:.2f}€ / (1 - {kk_factor:.3f}) - {needed_income_before_kk:.2f}€ - {kk_minimum_tax}€'] + diff = - last_monthbreak_est + ESt_this_month - last_monthbreak_kk_add + kk_add + if not finish: + diff += kk_minimum_tax + final_minus = expenses_so_far - old_needed_income_before_anything + diff + ret += [f' {acc_assets} {-diff} €'] + ret += [f' {acc_assets} {final_minus} €'] + year_needed = buffer_expenses + final_minus + (12 - months_passed - 1) * final_minus + if finish: + ret += [f' {acc_buffer} {-final_minus} €'] + else: + ret += [f' {acc_buffer} {-final_minus} € ; assume as to earn in year: {acc_buffer} + {12 - months_passed - 1} * this = {year_needed}'] + return ret class MyServer(BaseHTTPRequestHandler): header = """ + -ledger +ledger balance add free add structured
+""" + booking_tmpl = jinja2.Template(""" +

{{date}} {{desc}} {{head_comment|e}}
+[edit: structured +/ free +| copy:structured +/ free +| move {% if move_up %}up{% else %}up{% endif %}/{% if move_down %}down{% else %}down{% endif %} +| balance after +] + +{% for l in booking_lines %} +{% if l.acc %} + +{% else %} + +{% endif %} +{% endfor %} +
{{l.acc|e}}{{l.money|e}}{{l.comment|e}}
{{l.comment|e}}

+""") + add_form_header = """
+ + +""" + add_form_footer = """ + + + +
""" footer = "\n" def do_POST(self): - length = int(self.headers['content-length']) - postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1) - parsed_url = urlparse(self.path) - if '/add_structured' == parsed_url.path: - n_lines = int(len(postvars) / 4) - date = postvars['date'][0] - description = postvars['description'][0] - start_comment = postvars['line_0_comment'][0] - lines = [f'{date} {description} ; {start_comment}'] - for i in range(1, n_lines): - account = postvars[f'line_{i}_account'][0] - amount = postvars[f'line_{i}_amount'][0] - currency = postvars[f'line_{i}_currency'][0] - comment = postvars[f'line_{i}_comment'][0] - new_main = f'{account} {amount} {currency}' - if '' == new_main.rstrip() == comment.rstrip(): # don't write empty lines - continue - lines += [f'{new_main} ; {comment}'] - elif '/add_free' == parsed_url.path: - lines = postvars['booking'][0].splitlines() - start = int(postvars['start'][0]) - end = int(postvars['end'][0]) try: - _, _ = parse_lines(lines) - if start == end == 0: - db.append(lines) + parsed_url = urlparse(self.path) + length = int(self.headers['content-length']) + postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1) + start = int(postvars['start'][0]) + end = int(postvars['end'][0]) + db = Database() + add_empty_line = None + lines = [] + # get inputs + if '/add_structured' == parsed_url.path and not 'revert' in postvars.keys(): + lines, add_empty_line = self.booking_lines_from_postvars(postvars, db) + elif '/add_free' == parsed_url.path and not 'revert' in postvars.keys(): + lines = postvars['booking'][0].splitlines() + # validate where appropriate + if ('save' in postvars.keys()) or ('check' in postvars.keys()): + _, _ = parse_lines(lines) + # if saving, process where to and where to redirect after + if 'save' in postvars.keys(): + last_date = str(datetime.now())[:10] + if len(db.bookings) > 0: + last_date = db.bookings[-1].date_string + target_date = last_date[:] + first_line_tokens = lines[0].split() if len(lines) > 0 else '' + first_token = first_line_tokens[0] if len(first_line_tokens) > 0 else '' + try: + datetime.strptime(first_token, '%Y-%m-%d') + target_date = first_token + except ValueError: + pass + if start == end == 0: + start = db.insert_at_date(lines, target_date) + nth = db.get_nth_for_booking_of_start_line(start) + else: + new_start = db.update(start, end, lines, target_date) + nth = db.get_nth_for_booking_of_start_line(new_start) + if new_start > start: + nth -= 1 + redir_url = f'/#{nth}' + self.send_code_and_headers(302, [('Location', redir_url)]) + # otherwise just re-build editing form else: - db.replace(start, end, lines) - self.send_response(301) - self.send_header('Location', '/') - self.end_headers() + if '/add_structured' == parsed_url.path: + edit_content = self.add_structured(db, start, end, temp_lines=lines, add_empty_line=add_empty_line) + else: + edit_content = self.add_free(db, start, end) + self.send_HTML(self.header + edit_content + self.footer) except HandledException as e: - self.send_response(400) - self.end_headers() - page = f'{self.header}ERROR: {e}{self.footer}' - self.wfile.write(bytes(page, "utf-8")) + self.fail_400(e) def do_GET(self): - self.send_response(200) - self.send_header("Content-type", "text/html") - self.end_headers() - db = Database() - parsed_url = urlparse(self.path) - page = self.header + '' - params = parse_qs(parsed_url.query) - start = int(params.get('start', ['0'])[0]) - end = int(params.get('end', ['0'])[0]) - if parsed_url.path == '/balance': - page += self.balance_as_html(db) - elif parsed_url.path == '/add_free': - page += self.add_free(db, start, end) - elif parsed_url.path == '/add_structured': - bonus_lines = int(params.get('bonus_lines', ['0'])[0]) - page += self.add_structured(db, start, end) - else: - page += self.ledger_as_html(db) - page += self.footer - self.wfile.write(bytes(page, "utf-8")) - - def balance_as_html(self, db): - account_sums = {} - for booking in db.bookings: - for account, changes in booking.account_changes.items(): - for currency, amount in changes.items(): - apply_booking_to_account_balances(account_sums, account, currency, amount) - account_tree = {} - def collect_branches(account_name, path): - node = account_tree - path_copy = path[:] - while len(path_copy) > 0: - step = path_copy.pop(0) - node = node[step] - toks = account_name.split(":", maxsplit=1) - parent = toks[0] - if parent in node.keys(): - child = node[parent] - else: - child = {} - node[parent] = child - if len(toks) == 2: - k, v = collect_branches(toks[1], path + [parent]) - if k not in child.keys(): - child[k] = v - else: - child[k].update(v) - return parent, child - for account_name in sorted(account_sums.keys()): - k, v = collect_branches(account_name, []) - if k not in account_tree.keys(): - account_tree[k] = v + try: + parsed_url = urlparse(self.path) + params = parse_qs(parsed_url.query) + start = int(params.get('start', ['0'])[0]) + end = int(params.get('end', ['0'])[0]) + db = Database() + page = self.header + if parsed_url.path == '/balance': + stop = params.get('stop', [None])[0] + page += self.balance_as_html(db, stop) + elif parsed_url.path == '/add_free': + page += self.add_free(db, start, end) + elif parsed_url.path == '/add_structured': + page += self.add_structured(db, start, end) + elif parsed_url.path == '/copy_free': + page += self.add_free(db, start, end, copy=True) + elif parsed_url.path == '/copy_structured': + page += self.add_structured(db, start, end, copy=True) + elif parsed_url.path == '/move_up': + nth = self.move_up(db, start, end) + self.send_code_and_headers(302, [('Location', f'/#{nth}')]) + return + elif parsed_url.path == '/move_down': + nth = self.move_down(db, start, end) + self.send_code_and_headers(302, [('Location', f'/#{nth}')]) + return else: - account_tree[k].update(v) - def collect_totals(parent_path, tree_node): - for k, v in tree_node.items(): - child_path = parent_path + ":" + k - for currency, amount in collect_totals(child_path, v).items(): - apply_booking_to_account_balances(account_sums, parent_path, currency, amount) - return account_sums[parent_path] - for account_name in account_tree.keys(): - account_sums[account_name] = collect_totals(account_name, account_tree[account_name]) + page += self.ledger_as_html(db) + page += self.footer + self.send_HTML(page) + except HandledException as e: + self.fail_400(e) + + def fail_400(self, e): + page = f'{self.header}ERROR: {e}{self.footer}' + self.send_HTML(page, 400) + + def send_HTML(self, html, code=200): + self.send_code_and_headers(code, [('Content-type', 'text/html')]) + self.wfile.write(bytes(html, "utf-8")) + + def send_code_and_headers(self, code, headers=[]): + self.send_response(code) + for fieldname, content in headers: + self.send_header(fieldname, content) + self.end_headers() + + def booking_lines_from_postvars(self, postvars, db): + add_empty_line = None + date = postvars['date'][0] + description = postvars['description'][0] + start_comment = postvars['line_0_comment'][0] + start_line = f'{date} {description}' + if start_comment.rstrip() != '': + start_line += f' ; {start_comment}' + lines = [start_line] + if 'line_0_add' in postvars.keys(): + add_empty_line = 0 + i = j = 1 + while f'line_{i}_comment' in postvars.keys(): + if f'line_{i}_delete' in postvars.keys(): + i += 1 + continue + elif f'line_{i}_delete_after' in postvars.keys(): + break + elif f'line_{i}_add' in postvars.keys(): + add_empty_line = j + account = postvars[f'line_{i}_account'][0] + amount = postvars[f'line_{i}_amount'][0] + currency = postvars[f'line_{i}_currency'][0] + comment = postvars[f'line_{i}_comment'][0] + i += 1 + new_main = f' {account} {amount}' + if '' == new_main.rstrip() == comment.rstrip(): # don't write empty lines, ignore currency if nothing else set + continue + if len(amount.rstrip()) > 0: + new_main += f' {currency}' + j += 1 + new_line = new_main + if comment.rstrip() != '': + new_line += f' ; {comment}' + lines += [new_line] + if 'add_sink' in postvars.keys(): + temp_lines = lines.copy() + ['_'] + try: + temp_bookings, _ = parse_lines(temp_lines) + for currency in temp_bookings[0].sink: + amount = temp_bookings[0].sink[currency] + lines += [f'Assets {amount:.2f} {currency}'] + except HandledException: + pass + if 'add_taxes' in postvars.keys(): + lines += db.add_taxes(lines, finish=False) + elif 'add_taxes2' in postvars.keys(): + lines += db.add_taxes(lines, finish=True) + return lines, add_empty_line + + def balance_as_html(self, db, until=None): + bookings = db.bookings[:until if until is None else int(until)] lines = [] + account_tree, account_sums = bookings_to_account_tree(bookings) def print_subtree(lines, indent, node, subtree, path): line = f"{indent}{node}" n_tabs = 5 - (len(line) // 8) @@ -388,75 +712,164 @@ class MyServer(BaseHTTPRequestHandler): return f"
{content}
" def ledger_as_html(self, db): - lines = [] - line_sep = '
' - for comment in db.comments: - line = f'; {comment}' if comment != '' else '' - lines += [line + line_sep] - for booking in db.bookings: - i = booking.start_line - suffix = lines[i] - lines[i] = f'

{booking.date_string} {booking.description}{suffix}' + single_c_tmpl = jinja2.Template('{{c|e}}
') ## + elements_to_write = [] + last_i = i = 0 ## + for nth, booking in enumerate(db.bookings): + move_up = nth > 0 and db.bookings[nth - 1].date_string == booking.date_string + move_down = nth < len(db.bookings) - 1 and db.bookings[nth + 1].date_string == booking.date_string + booking_end = last_i = booking.start_line + len(booking.lines) + booking_lines = [] + i = booking.start_line ## + elements_to_write += [single_c_tmpl.render(c=c) for c in db.comments[last_i:i] if c != ''] ## for booking_line in booking.lines[1:]: - i += 1 - if booking_line == '': - continue - suffix = f' {lines[i]}' if len(lines[i]) > 0 else '' - value = f' {booking_line[1]} {booking_line[2]}' if booking_line[1] else '' - lines[i] = f'{booking_line[0]}{value}{suffix}' - lines[i] = lines[i][:-len(line_sep)] + f"""

-edit: -structured -/ free -
""" - return '\n'.join(lines) - - def header_add_form(self, action): - return f"
\n" - - def footer_add_form(self, start, end): - return f""" - - - -
""" - - def add_free(self, db, start=0, end=0): - content = html.escape(''.join(db.get_lines(start, end))) - return f'{self.header_add_form("add_free")}{self.footer_add_form(start, end)}' - - def add_structured(self, db, start=0, end=0, bonus_lines=10): - lines = db.get_lines(start, end) - bookings, comments = parse_lines(lines) + i += 1 ## + comment = db.comments[i] ## + if booking_line == '': + booking_lines += [{'acc': None, 'money': None, 'comment': comment}] ## + continue + account = booking_line[0] + money = '' + if booking_line[1] is not None: + money = f'{booking_line[1]} {booking_line[2]}' + booking_lines += [{'acc': booking_line[0], 'money':money, 'comment':comment}] ## + elements_to_write += [self.booking_tmpl.render( + nth=nth, + start=booking.start_line, + end=booking_end, + date=booking.date_string, + desc=booking.description, + head_comment=db.comments[booking.start_line], + move_up=move_up, + move_down=move_down, + booking_lines = booking_lines)] + elements_to_write += [single_c_tmpl.render(c=c) for c in db.comments[last_i:] if c != ''] # + return '\n'.join(elements_to_write) + + def add_free(self, db, start=0, end=0, copy=False): + tmpl = jinja2.Template(self.add_form_header + """
+ +""" + self.add_form_footer) + lines = db.get_lines(start, end) + if copy: + start = end = 0 + return tmpl.render(action='add_free', start=start, end=end, lines=lines) + + def add_structured(self, db, start=0, end=0, copy=False, temp_lines=[], add_empty_line=None): + tmpl = jinja2.Template(self.add_form_header + """ + + + +
+ + + + +
+{% for line in booking_lines %} + + + + + + + +
+{% endfor %} +{% for name, items in datalist_sets.items() %} + +{% for item in items %} + +{% endfor %} + +{% endfor %} +""" + self.add_form_footer) + lines = temp_lines if len(''.join(temp_lines)) > 0 else db.get_lines(start, end) + bookings, comments = parse_lines(lines, validate_bookings=False) if len(bookings) > 1: - raise HandledException('can only edit single Booking') - input_lines = '' - last_line = 0 - def inpu(name, val=""): - safe_val = html.escape(str(val)) - return f'' + raise HandledException('can only structurally edit single Booking') + if add_empty_line is not None: + comments = comments[:add_empty_line+1] + [''] + comments[add_empty_line+1:] + booking = bookings[0] + booking.lines = booking.lines[:add_empty_line+1] + [''] + booking.lines[add_empty_line+1:] + action = 'add_structured' + datalist_sets = {'descriptions': set(), 'accounts': set(), 'currencies': set()} + for b in db.bookings: + datalist_sets['descriptions'].add(b.description) + for account, moneys in b.account_changes.items(): + datalist_sets['accounts'].add(account) + for currency in moneys.keys(): + datalist_sets['currencies'].add(currency) + content = '' + today = str(datetime.now())[:10] + booking_lines = [] + if copy: + start = end = 0 + desc = head_comment = '' if len(bookings) == 0: - input_lines += f'{inpu("date")} {inpu("description")} ; {inpu("comment")}
' - last_line = 1 + for i in range(1, 3): + booking_lines += [{'i': i, 'acc': '', 'amt': '', 'curr': '€', 'comment': ''}] + date=today else: booking = bookings[0] - last_line = len(comments) - input_lines += f'{inpu("date", booking.date_string)} {inpu("description", booking.description)} ; {inpu("comment", comments[0])}
' + desc = booking.description + date = today if copy else booking.date_string + head_comment=comments[0] + last_line = len(comments) for i in range(1, len(comments)): account = amount = currency = '' if i < len(booking.lines) and booking.lines[i] != '': account = booking.lines[i][0] amount = booking.lines[i][1] currency = booking.lines[i][2] - input_lines += f'{inpu("line_{i}_account", account)} {inpu("line_{i}_amount", amount)} {inpu("line_{i}_currency", currency)} ; {inpu("line_{i}_comment", comments[i])}
' - for j in range(bonus_lines): - i = j + last_line - input_lines += f'{inpu("line_{i}_account")} {inpu("line_{i}_amount")} {inpu("line_{i}_currency")} ; {inpu("line_{i}_comment")}
' - return f'{self.header_add_form("add_structured")}{input_lines}{self.footer_add_form(start, end)}' + booking_lines += [{ + 'i': i, + 'acc': account, + 'amt': amount, + 'curr': currency if currency else '€', + 'comment': comments[i], + 'comm_cols': len(comments[i])}] + content += tmpl.render( + action=action, + date=date, + desc=desc, + head_comment=head_comment, + booking_lines=booking_lines, + datalist_sets=datalist_sets, + start=start, + end=end) + return content + + def move_up(self, db, start, end): + prev_booking = None + for redir_nth, b in enumerate(db.bookings): + if b.start_line >= start: + break + prev_booking = b + start_at = prev_booking.start_line + self.make_move(db, start, end, start_at) + return redir_nth - 1 + + def move_down(self, db, start, end): + next_booking = None + for redir_nth, b in enumerate(db.bookings): + if b.start_line > start: + next_booking = b + break + start_at = next_booking.start_line + len(next_booking.lines) - (end - start) + 1 + self.make_move(db, start, end, start_at) + return redir_nth + + def make_move(self, db, start, end, start_at): + lines = db.get_lines(start, end) + total_lines = db.real_lines[:start] + db.real_lines[end:] + db.write_lines_in_total_lines_at(total_lines, start_at, lines) -db = Database() -if __name__ == "__main__": +if __name__ == "__main__": webServer = HTTPServer((hostName, serverPort), MyServer) print(f"Server started http://{hostName}:{serverPort}") try: