X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=ledger.py;h=60bbf640a4d117ca548a407d727375cc60dbad1d;hb=6061ff7f1948b83dc601f52df1119a57b6e91649;hp=334318ff301eb186efa6684809c9ebac1807d177;hpb=c3b5860ae1ca76c2a1dc3b61d3c1242d581424f0;p=misc

diff --git a/ledger.py b/ledger.py
index 334318f..60bbf64 100755
--- a/ledger.py
+++ b/ledger.py
@@ -1,5 +1,8 @@
 from http.server import BaseHTTPRequestHandler, HTTPServer
 import sys
+import os
+import html
+from urllib.parse import parse_qs, urlparse
 hostName = "localhost"
 serverPort = 8082
 
@@ -15,19 +18,238 @@ 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 add_taxes(lines):
+    import decimal
+    bookings, _ = parse_lines(lines.copy())
+    _, account_sums = bookings_to_account_tree(bookings)
+    expenses_so_far = -1 * account_sums['Assets']['€']
+    needed_income_before_krankenkasse = expenses_so_far
+    ESt_this_month = 0
+    left_over = needed_income_before_krankenkasse - ESt_this_month
+    too_low = 0
+    too_high = 2 * needed_income_before_krankenkasse 
+    E0 = 10908
+    E1 = 15999 
+    E2 = 62809 
+    E3 = 277825 
+    while True:
+        zvE = 12 * needed_income_before_krankenkasse
+        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 / 12
+        left_over = needed_income_before_krankenkasse - ESt_this_month
+        if abs(left_over - expenses_so_far) < 0.1:
+            break
+        elif left_over < expenses_so_far:
+            too_low = needed_income_before_krankenkasse
+        elif left_over > expenses_so_far:
+            too_high = needed_income_before_krankenkasse
+        needed_income_before_krankenkasse = too_low + (too_high - too_low)/2
+    line_income_tax = f'  Reserves:Einkommenssteuer  {ESt_this_month:.2f}€ ; expenses so far: {expenses_so_far:.2f}€; zvE: {zvE:.2f}€; ESt total: {ESt:.2f}€; needed before Krankenkasse: {needed_income_before_krankenkasse:.2f}€'
+    kk_minimum_income = 1096.67 
+    kk_factor = decimal.Decimal(0.189) 
+    kk_minimum_tax = decimal.Decimal(207.27)
+    # kk_minimum_income = 1131.67 
+    # kk_factor = decimal.Decimal(0.191) 
+    # kk_minimum_tax = decimal.Decimal(216.15)
+    # kk_factor = decimal.Decimal(0.197) 
+    # kk_minimum_tax = decimal.Decimal(222.94)
+    kk_add = max(0, kk_factor * needed_income_before_krankenkasse - kk_minimum_tax)
+    line_kk_minimum = f'  Reserves:Month:Krankenkassendefaultbeitrag  {kk_minimum_tax:.2f}€  ; assed minimum income {kk_minimum_income:.2f}€ * {kk_factor:.3f}'
+    line_kk_add = f'  Reserves:Month:Krankenkassenbeitragswachstum {kk_add:.2f}€  ; max(0, {kk_factor:.3f} * {needed_income_before_krankenkasse:.2f}€ - {kk_minimum_tax:.2f}€)'
+    final_minus = expenses_so_far + ESt_this_month + kk_minimum_tax + kk_add 
+    line_finish = f'  Assets  -{final_minus:.2f}€'
+    return [line_income_tax, line_kk_minimum, line_kk_add, line_finish]
+
+
+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):
+    import datetime
+    import decimal
+    inside_booking = False
+    date_string, description = None, None
+    booking_lines = []
+    start_line = 0
+    bookings = []
+    comments = []
+    lines += [''] # 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)
+                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):
         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()
@@ -36,8 +258,8 @@ class Booking:
         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:
@@ -56,7 +278,7 @@ class Booking:
             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 +286,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:
@@ -85,201 +307,157 @@ class Booking:
 
 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 += 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):
-        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:
+    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()
+        text = ''.join(self.real_lines[:start]) + '\n'.join(lines) + ''.join(self.real_lines[end:])
+        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'.join(lines) + '\n');
+        os.remove(self.lock_file)
+
+
+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)
+        if '/add_structured' == parsed_url.path:
+            date = postvars['date'][0]
+            description = postvars['description'][0]
+            start_comment = postvars['line_0_comment'][0]
+            lines = [f'{date} {description} ; {start_comment}']
+            i = 1
+            while f'line_{i}_comment' in postvars.keys():
+                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]
+                new_line = new_main
+                if comment.rstrip() != '':
+                    new_line += f' ; {comment}'
+                lines += [new_line]
+            if 'add_income_tax' in postvars.keys():
+                lines += add_taxes(lines)
+        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)
             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])
+                db.replace(start, end, lines)
+            self.send_response(301)
+            redir_url = '/'
+            if 'add_income_tax' in postvars.keys():
+                redir_url = f'/add_structured?start={start}&end={start+len(lines)-1}'
+            self.send_header('Location', redir_url)
+            self.end_headers()
+        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"))
+
+    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])
+        bonus_lines = int(params.get('bonus_lines', ['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':
+            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)
+        else:
+            page += self.ledger_as_html(db)
+        page += self.footer
+        self.wfile.write(bytes(page, "utf-8"))
+
+    def balance_as_html(self, db):
         lines = []
+        account_tree, account_sums = bookings_to_account_tree(db.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 +467,113 @@ 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 ledger_as_html(self, db):
+        lines = []
+        for comment in db.comments:
+            lines += [f'<span class="comment">{comment}</span>' if comment != '' else '']
+        for booking in db.bookings:
+            i = booking.start_line
+            booking_end = booking.start_line + len(booking.lines)
+            lines[i] = f"""{booking.date_string} {booking.description} {lines[i]}
+[edit: <a href="/add_structured?start={booking.start_line}&end={booking_end}">structured</a> 
+/ <a href="/add_free?start={booking.start_line}&end={booking_end}">free</a> 
+| copy:<a href="/copy_structured?start={booking.start_line}&end={booking_end}">structured</a>
+/ <a href="/copy_free?start={booking.start_line}&end={booking_end}">free</a>]
+<table>"""
+            for booking_line in booking.lines[1:]:
+                i += 1
+                if booking_line == '':
+                    lines[i] = f'<tr><td><div class="full_line_comment">{lines[i]}</div></td></tr>'
+                    continue
+                comment = f' {lines[i]}' if len(lines[i]) > 0 else ''
+                money = ''
+                if booking_line[1]:
+                    money = f'{booking_line[1]} {booking_line[2]}'
+                account = booking_line[0] 
+                lines[i] = f'<tr><td>{booking_line[0]}</td><td class="money">{money}</td><td>{comment}</td></tr>'
+            lines[i] = lines[i] + "\n" + '</table>'
+        return '\n'.join(lines)
 
-class MyServer(BaseHTTPRequestHandler):
+    def header_add_form(self, action):
+        return f"<form method=\"POST\" action=\"/{action}\">\n"
 
-    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 footer_add_form(self, start, end, copy):
+        if copy:
+            start = end = 0
+        return f"""
+<input type="hidden" name="start" value={start} />
+<input type="hidden" name="end" value={end} />
+<input type="submit" name="default">
+</form>"""
+
+    def textarea(self, name, lines, min_rows=1, min_cols=80):
+        safe_content = html.escape(''.join(lines))
+        n_rows = max(min_rows, len(lines))
+        n_cols = min_cols
+        for line in lines:
+            n_cols = len(line) if len(line) > n_cols else n_cols 
+        return f'<textarea name="{name}" rows={n_rows} cols={n_cols}>{safe_content}</textarea>'
+
+    def add_free(self, db, start=0, end=0, copy=False):
+        lines = db.get_lines(start, end)
+        return f'{self.header_add_form("add_free")}{self.textarea("booking",lines,10)}{self.footer_add_form(start, end, copy)}'
+
+    def add_structured(self, db, start=0, end=0, bonus_lines=10, copy=False):
+        import datetime
+        lines = db.get_lines(start, end)
+        bookings, comments = parse_lines(lines)
+        if len(bookings) > 1:
+            raise HandledException('can only edit single Booking')
+        last_line = 0
+        def inpu(name, val="", datalist="", input_type='text', size=-1):
+            val = val if val is not None else ""
+            safe_val = html.escape(str(val))
+            datalist_string = '' if datalist == '' else f'list="{datalist}"'
+            number_step = '' if input_type != 'number' else ' step=0.01'
+            size_string = '' if size < 0 else f' size={size}' 
+            return f'<input type="{input_type}"{number_step} name="{name}"{size_string} value="{safe_val}" {datalist_string}/>'
+        input_lines = inpu('add_income_tax', 'add income tax', '', 'submit') + '<br />'
+        today = str(datetime.datetime.now())[:10]
+        if len(bookings) == 0:
+            input_lines += f'{inpu("date", today, size=9)} {inpu("description", "", "descriptions")} ; {inpu("line_0_comment")}<br />'
+            last_line = 1
+        else:
+            booking = bookings[0]
+            last_line = len(comments)
+            date_string = today if copy else booking.date_string
+            input_lines += f'{inpu("date", date_string, size=9)} {inpu("description", booking.description, "descriptions")} ; {self.textarea("line_0_comment", [comments[0]])}<br />'
+            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(f"line_{i}_account", account, "accounts", size=40)} {inpu(f"line_{i}_amount", amount, "", "number", size=10)} {inpu(f"line_{i}_currency", currency, "currencies", size=3)} ; {self.textarea(f"line_{i}_comment", [comments[i]])}<br />'
+        for j in range(bonus_lines):
+            i = j + last_line
+            input_lines += f'{inpu(f"line_{i}_account", "", "accounts", size=40)} {inpu(f"line_{i}_amount", "", "", "number", size=10)} {inpu(f"line_{i}_currency", "", "currencies", size=3)} ; {self.textarea(f"line_{i}_comment", [""])}<br />'
+        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)
+        def build_datalist(name):
+            datalist = f'<datalist id="{name}">' + "\n"
+            for item in datalist_sets[name]:
+                safe_item = html.escape(item)
+                datalist += f'<option value="{safe_item}">{safe_item}</option>' + "\n"
+            return f"{datalist}</datalist>\n"
+        datalists = build_datalist('descriptions')
+        datalists += build_datalist('accounts')
+        datalists += build_datalist('currencies')
+        return f'{self.header_add_form("add_structured")}{input_lines}{datalists}{self.footer_add_form(start, end, copy)}'
 
 
-db = Database()
-if __name__ == "__main__":        
+if __name__ == "__main__":    
     webServer = HTTPServer((hostName, serverPort), MyServer)
     print(f"Server started http://{hostName}:{serverPort}")
     try: