X-Git-Url: https://plomlompom.com/repos/berlin_corona.txt?a=blobdiff_plain;f=ledger.py;h=f7f722c56cfb930d91f33183dffac2dde1868068;hb=140e8f039bef05db2511f54f8fa923fb3a4a066a;hp=334318ff301eb186efa6684809c9ebac1807d177;hpb=c3b5860ae1ca76c2a1dc3b61d3c1242d581424f0;p=misc

diff --git a/ledger.py b/ledger.py
index 334318f..f7f722c 100755
--- a/ledger.py
+++ b/ledger.py
@@ -1,5 +1,10 @@
 from http.server import BaseHTTPRequestHandler, HTTPServer
 import sys
+import os
+import html
+import jinja2 
+import decimal
+from urllib.parse import parse_qs, urlparse
 hostName = "localhost"
 serverPort = 8082
 
@@ -15,29 +20,196 @@ def handled_error_exit(msg):
 
 def apply_booking_to_account_balances(account_sums, account, currency, amount):
     if not account in account_sums:
-        account_sums[account] = {currency: amount} 
+        account_sums[account] = {currency: amount}
     elif not currency in account_sums[account].keys():
         account_sums[account][currency] = amount
     else:
         account_sums[account][currency] += amount
 
 
+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):
+    import datetime
+    inside_booking = False
+    date_string, description = None, None
+    booking_lines = []
+    start_line = 0
+    bookings = []
+    comments = []
+    lines = lines.copy() + [''] # to ensure a booking-ending last line
+    for i, line in enumerate(lines):
+        prefix = f"line {i}"
+        # we start with the case of an utterly empty line
+        comments += [""]
+        stripped_line = line.rstrip()
+        if stripped_line == '':
+            if inside_booking:
+                # 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, validate_bookings)
+                bookings += [booking]
+            # expect new booking to follow so re-zeroall booking data
+            inside_booking = False
+            date_string, description = None, None
+            booking_lines = []
+            continue
+        # 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].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() == '':
+             if inside_booking:
+                 booking_lines += ['']
+             continue
+        # if we're starting a booking, parse by first-line pattern
+        if not inside_booking:
+            start_line = i
+            toks = non_comment.split(maxsplit=1)
+            date_string = toks[0]
+            try:
+                datetime.datetime.strptime(date_string, '%Y-%m-%d')
+            except ValueError:
+                raise HandledException(f"{prefix} bad date string: {date_string}")
+            try:
+                description = toks[1]
+            except IndexError:
+                raise HandledException(f"{prefix} bad description: {description}")
+            inside_booking = True
+            booking_lines += [non_comment]
+            continue
+        # otherwise, read as transfer data
+        toks = non_comment.split()  # ignore specification's allowance of single spaces in names
+        if len(toks) > 3:
+            raise HandledException(f"{prefix} too many booking line tokens: {toks}")
+        amount, currency = None, None
+        account_name = toks[0]
+        if account_name[0] == '[' and account_name[-1] == ']':
+            # ignore specification's differentiation of "virtual" accounts
+            account_name = account_name[1:-1]
+        decimal_chars = ".-0123456789"
+        if len(toks) == 3:
+            i_currency = 1
+            try:
+                amount = decimal.Decimal(toks[1])
+                i_currency = 2
+            except decimal.InvalidOperation:
+                try:
+                    amount = decimal.Decimal(toks[2])
+                except decimal.InvalidOperation:
+                    raise HandledException(f"{prefix} no decimal number in: {toks[1:]}")
+            currency = toks[i_currency]
+            if currency[0] in decimal_chars:
+                raise HandledException(f"{prefix} currency starts with int, dot, or minus: {currency}")
+        elif len(toks) == 2:
+            value = toks[1]
+            inside_amount = False
+            inside_currency = False
+            amount_string = ""
+            currency = ""
+            dots_counted = 0
+            for i, c in enumerate(value):
+                if i == 0:
+                    if c in decimal_chars:
+                        inside_amount = True
+                    else:
+                        inside_currency = True
+                if inside_currency:
+                    if c in decimal_chars and len(amount_string) == 0:
+                        inside_currency = False
+                        inside_amount = True
+                    else:
+                        currency += c
+                        continue
+                if inside_amount:
+                    if c not in decimal_chars:
+                        if len(currency) > 0:
+                            raise HandledException(f"{prefix} amount has non-decimal chars: {value}")
+                        inside_currency = True
+                        inside_amount = False
+                        currency += c
+                        continue
+                    if c == '-' and len(amount_string) > 1:
+                        raise HandledException(f"{prefix} amount has non-start '-': {value}")
+                    if c == '.':
+                        if dots_counted > 1:
+                            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)
+        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.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}"
         sums = {}
         empty_values = 0
-        for line in self.lines:
-            if line == '': 
+        for line in self.lines[1:]:
+            if line == '':
                 continue
             _, amount, currency = line
             if amount is None:
@@ -51,12 +223,12 @@ 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():
                 if v != 0:
-                    sinkable = True 
+                    sinkable = True
             if not sinkable:
                 raise HandledException(f"{prefix} has empty value that cannot be filled")
 
@@ -64,8 +236,8 @@ class Booking:
         account_changes = {}
         debt = {}
         sink_account = None
-        for line in self.lines:
-            if line == '': 
+        for line in self.lines[1:]:
+            if line == '':
                 continue
             account, amount, currency = line
             if amount is None:
@@ -79,207 +251,297 @@ 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
 
 
 
 class Database:
 
-    def __init__(self, load_from_file=True):
-        import os
+    def __init__(self):
         db_name = "_ledger"
         self.db_file = db_name + ".json"
         self.lock_file = db_name+ ".lock"
         self.bookings = []
         self.comments = []
-        if load_from_file and os.path.exists(self.db_file):
+        self.real_lines = []
+        if os.path.exists(self.db_file):
             with open(self.db_file, "r") as f:
-                self.parse_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 parse_lines(self, lines): 
-        import datetime
-        import decimal 
-        inside_booking = False
-        date_string, description = None, None
-        booking_lines = []
-        start_line = 0
-        for i, line in enumerate(lines):
-            prefix = f"line {i}"
-            # we start with the case of an utterly empty line
-            self.comments += [""] 
-            stripped_line = line.rstrip()
-            if stripped_line == '':
-                if inside_booking:
-                    # 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)
-                    self.bookings += [booking]
-                # expect new booking to follow so re-zeroall booking data 
-                inside_booking = False
-                date_string, description = None, None
-                booking_lines = []
-                continue
-            # 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:
-                self.comments[i] = split_by_comment[1] 
-            # 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() == '': 
-                 if inside_booking: 
-                     booking_lines += ['']
-                 continue
-            # if we're starting a booking, parse by first-line pattern 
-            if not inside_booking:
-                start_line = i
-                toks = non_comment.split(maxsplit=1)
-                date_string = toks[0]
-                try:
-                    datetime.datetime.strptime(date_string, '%Y-%m-%d')
-                except ValueError:
-                    raise HandledException(f"{prefix} bad date string: {date_string}")
-                try:
-                    description = toks[1]
-                except IndexError:
-                    raise HandledException(f"{prefix} bad description: {description}")
-                inside_booking = True
-                continue
-            # otherwise, read as transfer data
-            toks = non_comment.split()  # ignore specification's allowance of single spaces in names
-            if len(toks) > 3:
-                raise HandledException(f"{prefix} too many booking line tokens: {toks}")
-            amount, currency = None, None
-            account_name = toks[0]
-            if account_name[0] == '[' and account_name[-1] == ']':
-                # ignore specification's differentiation of "virtual" accounts
-                account_name = account_name[1:-1]
-            decimal_chars = ".-0123456789"
-            if len(toks) == 3:
-                i_currency = 1 
-                try:
-                    amount = decimal.Decimal(toks[1])
-                    i_currency = 2
-                except decimal.InvalidOperation:
-                    try:
-                        amount = decimal.Decimal(toks[2])
-                    except decimal.InvalidOperation:
-                        raise HandledException(f"{prefix} no decimal number in: {toks[1:]}")
-                currency = toks[i_currency] 
-                if currency[0] in decimal_chars:
-                    raise HandledException(f"{prefix} currency starts with int, dot, or minus: {currency}")
-            elif len(toks) == 2:
-                value = toks[1]
-                inside_amount = False
-                inside_currency = False
-                amount_string = ""
-                currency = ""
-                dots_counted = 0
-                for i, c in enumerate(value):
-                    if i == 0:
-                        if c in decimal_chars: 
-                            inside_amount = True 
-                        else:
-                            inside_currency = True 
-                    if inside_currency:
-                        if c in decimal_chars and len(amount_string) == 0:
-                            inside_currency = False
-                            inside_amount = True 
-                        else:
-                            currency += c
-                            continue
-                    if inside_amount:
-                        if c not in decimal_chars:
-                            if len(currency) > 0:
-                                raise HandledException(f"{prefix} amount has non-decimal chars: {value}")
-                            inside_currency = True
-                            inside_amount = False 
-                            currency += c
-                            continue
-                        if c == '-' and len(amount_string) > 1:
-                            raise HandledException(f"{prefix} amount has non-start '-': {value}")
-                        if c == '.':
-                            if dots_counted > 1:
-                                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)
-            booking_lines += [(account_name, amount, currency)]
-
-    def ledger_as_html(self):
+    def get_lines(self, start, end):
+        return self.real_lines[start:end]
+
+    def replace(self, start, end, 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()
+        total_lines = self.real_lines[:start] + lines + self.real_lines[end:]
+        text = '\n'.join(total_lines)
+        with open(self.db_file, 'w') 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' + '\n'.join(lines) + '\n\n');
+        os.remove(self.lock_file)
+
+    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
+        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 finish and acc_kk_add in acc_keys and acc_kk_minimum in acc_keys:
+                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 = 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}€']
+        _, account_sums = bookings_to_account_tree(bookings)
+        expenses_so_far = -1 * account_sums[acc_assets]['€'] - old_needed_income 
+        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) 
+        months_passed = int(date[5:7]) - 1
+        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 = max(0, kk_factor * needed_income_before_kk - kk_minimum_tax)
+        kk_add = decimal.Decimal(kk_add).quantize(decimal.Decimal('0.00'))
+        if finish:
+            ret += [f'  {acc_kk_add}  {-last_monthbreak_kk_add}€  ; max(0, {kk_factor:.3f} * {-(old_needed_income - last_monthbreak_est):.2f}€ - {kk_minimum_tax}€)']
+        else:
+            ret += [f'  {acc_kk_minimum}  {kk_minimum_tax}€  ; assumed minimum income {kk_minimum_income:.2f}€ * {kk_factor:.3f}']
+        ret += [f'  {acc_kk_add}  {kk_add}€  ; max(0, {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 + diff
+        ret += [f'  {acc_assets}  {-diff} €']
+        ret += [f'  {acc_assets}  {final_minus} €']
+        ret += [f'  {acc_buffer}  {-final_minus} €']
+        return ret
+
+
+class MyServer(BaseHTTPRequestHandler):
+    header = """<html>
+<meta charset="UTF-8">
+<style>
+body { color: #000000; }
+table { margin-bottom: 2em; }
+th, td { text-align: left }
+input[type=number] { text-align: right; font-family: monospace; }
+.money { font-family: monospace; text-align: right; }
+.comment { font-style: italic; color: #777777; }
+.full_line_comment { display: block; white-space: nowrap; width: 0; }
+</style>
+<body>
+<a href="/ledger">ledger</a>
+<a href="/balance">balance</a>
+<a href="/add_free">add free</a>
+<a href="/add_structured">add structured</a>
+<hr />
+"""
+    footer = "</body>\n<html>"
+
+    def do_POST(self):
+        db = Database()
+        length = int(self.headers['content-length'])
+        postvars = parse_qs(self.rfile.read(length).decode(), keep_blank_values=1)
+        parsed_url = urlparse(self.path)
         lines = []
-        for comment in self.comments:
-            lines += [f"; {comment}" if comment != '' else '']
-        for booking in self.bookings:
-            i = booking.start_line
-            suffix = f" {lines[i]}" if len(lines[i]) > 0 else ""
-            lines[i] = f"{booking.date_string} {booking.description}{suffix}"
-            for booking_line in booking.lines:
+        add_empty_line = None 
+        start = int(postvars['start'][0])
+        end = int(postvars['end'][0])
+        if '/add_structured' == parsed_url.path and not 'revert' in postvars.keys():
+            date = postvars['date'][0]
+            description = postvars['description'][0]
+            start_comment = postvars['line_0_comment'][0]
+            lines = [f'{date} {description} ; {start_comment}']
+            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
+                if 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
-                if booking_line == '':
+                new_main = f'{account} {amount} {currency}'
+                if '' == new_main.rstrip() == comment.rstrip():  # don't write empty lines
                     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}"
-        content = "\n".join(lines)
-        return f"<html><meta charset=\"UTF-8\"><pre>{content}</pre></html>"
-
-    def balance_as_html(self):
-        account_sums = {}
-        for booking in self.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
+                j += 1
+                new_line = new_main
+                if comment.rstrip() != '':
+                    new_line += f' ; {comment}'
+                lines += [new_line]
+            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)
+        elif '/add_free' == parsed_url.path:
+            lines = postvars['booking'][0].splitlines()
+        try:
+            if ('save' in postvars.keys()) or ('check' in postvars.keys()):
+                _, _ = parse_lines(lines)
+            if 'save' in postvars.keys():
+                if start == end == 0:
+                    db.append(lines)
+                    redir_url = f'/#last'
                 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
+                    db.replace(start, end, lines)
+                    redir_url = f'/#{start}'
+                self.send_response(301)
+                self.send_header('Location', redir_url)
+                self.end_headers()
             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.header + self.add_structured(db, start, end, temp_lines=lines, add_empty_line=add_empty_line) + self.footer
+                self.send_response(200)
+                self.send_header("Content-type", "text/html")
+                self.end_headers()
+                self.wfile.write(bytes(page, "utf-8"))
+        except HandledException as e:
+            self.send_response(400)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            page = f'{self.header}ERROR: {e}{self.footer}'
+            self.wfile.write(bytes(page, "utf-8"))
+
+    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':
+            stop_date = params.get('stop', [None])[0]
+            page += self.balance_as_html(db, stop_date)
+        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 == '/ledger2':
+            page += self.ledger2_as_html(db)
+        else:
+            page += self.ledger_as_html(db)
+        page += self.footer
+        self.wfile.write(bytes(page, "utf-8"))
+
+    def balance_as_html(self, db, stop_date=None):
         lines = []
+        bookings = db.bookings
+        if stop_date:
+            bookings = [] 
+            for b in db.bookings:
+                if b.date_string == stop_date:
+                    break
+                bookings += [b]
+        account_tree, account_sums = bookings_to_account_tree(bookings)
         def print_subtree(lines, indent, node, subtree, path):
-            line = f"{indent}{node}" 
+            line = f"{indent}{node}"
             n_tabs = 5 - (len(line) // 8)
-            line += n_tabs * "\t" 
+            line += n_tabs * "\t"
             if "€" in account_sums[path + node].keys():
                 amount = account_sums[path + node]["€"]
                 line += f"{amount:9.2f} €\t"
             else:
                 line += f"\t\t"
-            for currency, amount in account_sums[path + node].items(): 
+            for currency, amount in account_sums[path + node].items():
                 if currency != '€' and amount > 0:
                     line += f"{amount:5.2f} {currency}\t"
             lines += [line]
@@ -289,23 +551,229 @@ class Database:
         for k, v in sorted(account_tree.items()):
             print_subtree(lines, "", k, v, "")
         content = "\n".join(lines)
-        return f"<html><meta charset=\"UTF-8\"><pre>{content}</pre></html>"
+        return f"<pre>{content}</pre>"
 
+    def ledger2_as_html(self, db):
+        single_c_tmpl = jinja2.Template('<span class="comment">{{c|e}}</span><br />')
+        booking_tmpl = jinja2.Template("""
+<p id="{{start}}"><a href="#{{start}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span>
+[edit: <a href="/add_structured?start={{start}}&end={{end}}">structured</a> 
+/ <a href="/add_free?start={{start}}&end={{end}}">free</a> 
+| copy:<a href="/copy_structured?start={{start}}&end={{end}}">structured</a>
+/ <a href="/copy_free?start={{start}}&end={{end}}">free</a>]
+<table>
+{% for l in booking_lines %}
+<tr><td>{{l.acc|e}}</td><td class="money">{{l.money|e}}</td><td class="money">{{l.balance|e}}</td></tr>
+{% endfor %}
+</table></p>
+""")
+        elements_to_write = []
+        account_sums = {}
+        for booking in db.bookings:
+            i = booking.start_line
+            booking_end = booking.start_line + len(booking.lines)
+            booking_lines = []
+            for booking_line in booking.lines[1:]:
+                if booking_line == '':
+                    continue
+                account = booking_line[0] 
+                account_toks = account.split(':') 
+                path = ''
+                for tok in account_toks:
+                    path += tok
+                    if not path in account_sums.keys():
+                        account_sums[path] = {}
+                    path += ':' 
+                moneys = []
+                money = ''
+                if booking_line[1] is not None:
+                    moneys += [(booking_line[1], booking_line[2])]
+                    money = f'{moneys[0][0]} {moneys[0][1]}'
+                else:
+                    for currency, amount in booking.sink.items():
+                        moneys += {(amount, currency)} 
+                    money = '['
+                    for m in moneys:
+                        money += f'{m[0]} {m[1]} '
+                    money += ']'
+                balance = ''
+                for amount, currency in moneys:
+                    path = ''
+                    for tok in account_toks:
+                        path += tok
+                        if not currency in account_sums[path].keys():
+                            account_sums[path][currency] = 0
+                        account_sums[path][currency] += amount 
+                        path += ':' 
+                    balance += f'{account_sums[account][currency]} {currency}' 
+                booking_lines += [{'acc': booking_line[0], 'money':money, 'balance':balance}] 
+            elements_to_write += [booking_tmpl.render(
+                start=booking.start_line,
+                end=booking_end,
+                date=booking.date_string,
+                desc=booking.description,
+                head_comment=db.comments[booking.start_line],
+                booking_lines = booking_lines)]
+        return '\n'.join(elements_to_write) 
 
-class MyServer(BaseHTTPRequestHandler):
+    def ledger_as_html(self, db):
+        single_c_tmpl = jinja2.Template('<span class="comment">{{c|e}}</span><br />')
+        booking_tmpl = jinja2.Template("""
+<p id="{{start}}"><a {% if last %}id="last"{% endif %} href="#{{start}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span>
+[edit: <a href="/add_structured?start={{start}}&end={{end}}">structured</a> 
+/ <a href="/add_free?start={{start}}&end={{end}}">free</a> 
+| copy:<a href="/copy_structured?start={{start}}&end={{end}}">structured</a>
+/ <a href="/copy_free?start={{start}}&end={{end}}">free</a>]
+<table>
+{% for l in booking_lines %}
+{% if l.acc %}
+<tr><td>{{l.acc|e}}</td><td class="money">{{l.money|e}}</td><td class="comment">{{l.comment|e}}</td></tr>
+{% else %}
+<tr><td><div class="comment full_line_comment">{{l.comment|e}}</div></td></tr>
+{% endif %}
+{% endfor %}
+</table></p>
+""")
+        elements_to_write = []
+        last_i = i = 0
+        last_start = db.bookings[-1].start_line
+        for booking in db.bookings:
+            i = booking.start_line
+            elements_to_write += [single_c_tmpl.render(c=c) for c in db.comments[last_i:i] if c != '']
+            booking_end = last_i = booking.start_line + len(booking.lines)
+            booking_lines = []
+            for booking_line in booking.lines[1:]:
+                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 += [booking_tmpl.render(
+                last=booking.start_line == last_start,
+                start=booking.start_line,
+                end=booking_end,
+                date=booking.date_string,
+                desc=booking.description,
+                head_comment=db.comments[booking.start_line],
+                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 do_GET(self):
-        self.send_response(200)
-        self.send_header("Content-type", "text/html")
-        self.end_headers()
-        db = Database()
-        # page = db.ledger_as_html()
-        page = db.balance_as_html()
-        self.wfile.write(bytes(page, "utf-8"))
+    def add_free(self, db, start=0, end=0, copy=False):
+        tmpl = jinja2.Template("""
+<form method="POST" action="{{action|e}}">
+<textarea name="booking" rows=10 cols=80>
+{% for line in lines %}{{ line }}
+{% endfor %}
+</textarea>
+<input type="hidden" name="start" value={{start}} />
+<input type="hidden" name="end" value={{end}} />
+<input type="submit" name="save" value="save!">
+</form>
+""")
+        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("""
+<form method="POST" action="{{action|e}}">
+<input type="submit" name="check" value="check" />
+<input type="submit" name="revert" value="revert" />
+<input type="submit" name="add_taxes" value="add taxes" />
+<input type="submit" name="add_taxes2" value="add taxes2" />
+<br />
+<input name="date" value="{{date|e}}" size=9 />
+<input name="description" value="{{desc|e}}" list="descriptions" />
+<textarea name="line_0_comment" rows=1 cols=20>{{head_comment|e}}</textarea>
+<input type="submit" name="line_0_add" value="[+]" />
+<br />
+{% for line in booking_lines %}
+<input name="line_{{line.i}}_account" value="{{line.acc|e}}" size=40 list="accounts" />
+<input type="number" name="line_{{line.i}}_amount" step=0.01 value="{{line.amt}}" size=10 />
+<input name="line_{{line.i}}_currency" value="{{line.curr|e}}" size=3 list="currencies" />
+<input type="submit" name="line_{{line.i}}_delete" value="[x]" />
+<input type="submit" name="line_{{line.i}}_add" value="[+]" />
+<textarea name="line_{{line.i}}_comment" rows=1 cols={% if line.comm_cols %}{{line.comm_cols}}{% else %}20{% endif %}>{{line.comment|e}}</textarea>
+<br />
+{% endfor %}
+{% for name, items in datalist_sets.items() %}
+<datalist id="{{name}}">
+{% for item in items %}
+  <option value="{{item|e}}">{{item|e}}</option>
+{% endfor %}
+</datalist>
+{% endfor %}
+<input type="hidden" name="start" value={{start}} />
+<input type="hidden" name="end" value={{end}} />
+<input type="submit" name="save" value="save!">
+</form>
+""")
+        import datetime
+        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')
+        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.datetime.now())[:10]
+        booking_lines = []
+        if copy:
+            start = end = 0
+        desc = head_comment = ''
+        if len(bookings) == 0:
+            for i in range(1, 3):
+                booking_lines += [{'i': i, 'acc': '', 'amt': '', 'curr': '', 'comment': ''}]
+            date=today 
+        else:
+            booking = bookings[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]
+                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 
 
 
-db = Database()
-if __name__ == "__main__":        
+if __name__ == "__main__":    
     webServer = HTTPServer((hostName, serverPort), MyServer)
     print(f"Server started http://{hostName}:{serverPort}")
     try: