From 389620d37f697f869ed051071db5dead95a152fe Mon Sep 17 00:00:00 2001
From: Christian Heller <c.heller@plomlompom.de>
Date: Thu, 23 Nov 2023 04:37:01 +0100
Subject: [PATCH] Add script to unify all accounting servers into one.

---
 calories.py             |  26 ++-
 income_progress_bars.py |  25 ++-
 ledger.py               | 423 +++++++++++++++++++++-------------------
 plomlib.py              |  22 +--
 unite.py                |  62 ++++++
 5 files changed, 330 insertions(+), 228 deletions(-)
 create mode 100644 unite.py

diff --git a/calories.py b/calories.py
index 88165b8..4352567 100644
--- a/calories.py
+++ b/calories.py
@@ -2,7 +2,7 @@ import os
 import json
 import datetime
 import jinja2
-from plomlib import PlomDB, PlomException, run_server, run_server, PlomServer
+from plomlib import PlomDB, PlomException, run_server, PlomHandler 
 
 db_path = '/home/plom/org/calories_db.json'
 
@@ -16,7 +16,7 @@ td.number { text-align: right; }
 input[type="number"] { text-align: right; }
 </style>
 <body>
-<form action="/" method="POST">
+<form action="{{homepage}}" method="POST">
 <td><input name="update" type="submit" value="update" /></td>
 <table>
 <tr><th>eatable</th><th>unit count</th><th>unit weight (g)</th><th>calories</th><th>sugar (g)</th></tr>
@@ -224,9 +224,18 @@ class CaloriesDB(PlomDB):
         self.write_text_to_db(json.dumps(self.to_dict()))
 
 
-class CaloriesServer(PlomServer):
+class ConsumptionsHandler(PlomHandler):
+
+    def app_init(self, handler):
+        default_path = '/consumptions'
+        handler.add_route('GET', default_path, self.show_db) 
+        handler.add_route('POST', default_path, self.write_db) 
+        return 'consumptions', default_path 
 
     def do_POST(self):
+        self.write_db()
+
+    def write_db(self):
         from uuid import uuid4
         from urllib.parse import parse_qs
         length = int(self.headers['content-length'])
@@ -283,13 +292,16 @@ class CaloriesServer(PlomServer):
                     break
         try:
             db.write()
-            self.redirect()
+            homepage = self.apps['consumptions'] if hasattr(self, 'apps') else self.homepage
+            self.redirect(homepage)
         except PlomException as e:
             self.fail_400(e) 
 
     def do_GET(self):
+        self.show_db()
+
+    def show_db(self):
         db = CaloriesDB()
-        # eatables = ""
         eatable_rows = []
         for k,v in db.eatables.items():
             eatable_rows += [{
@@ -320,7 +332,9 @@ class CaloriesServer(PlomServer):
                 'cals': f'{day.calories:.1f}',
                 'sugar': f'{day.sugar_g:.1f}',
             }]
+        homepage = self.apps['consumptions'] if hasattr(self, 'apps') else self.homepage
         page = jinja2.Template(tmpl).render(
+                homepage = homepage,
                 db=db,
                 days=day_rows,
                 consumptions=consumption_rows,
@@ -330,4 +344,4 @@ class CaloriesServer(PlomServer):
 
 
 if __name__ == "__main__":  
-    run_server(server_port, CaloriesServer)
+    run_server(server_port, ConsumptionsHandler)
diff --git a/income_progress_bars.py b/income_progress_bars.py
index 553627d..60f7104 100644
--- a/income_progress_bars.py
+++ b/income_progress_bars.py
@@ -1,7 +1,7 @@
 import os
 import json
 import jinja2
-from plomlib import PlomDB, PlomException, run_server, run_server, PlomServer
+from plomlib import PlomDB, PlomException, run_server, PlomHandler 
 
 server_port = 8083
 db_path = '/home/plom/org/income.json'
@@ -84,7 +84,7 @@ table {
 <td class="progressbar surplusbar"><div class="diff_goal">{{p.diff_goal}}</div><div class="progressbar surplus" style="width: {{p.success_income_bonus}}px" ></div></td></tr>
 {% endfor %}</table>
 
-<form action="/" method="POST">
+<form action="{{homepage}}" method="POST">
 <table>
 <tr><th>hourly rate</th><th>worked today</th></tr>
 <tr><td class="input_container"><input type="number" min="1" class="rate" name="workday_hourly_rate_1" value="{{workday_hourly_rate_1}}"/>€</td><td><input type="number" min="0" class="minutes" name="workday_minutes_worked_1" value="{{workday_minutes_worked_1}}" step="5" /> minutes</td>
@@ -161,9 +161,18 @@ class ProgressBar:
                 self.success = success_income / time_progress
 
 
-class IncomeServer(PlomServer):
+class IncomeProgressHandler(PlomHandler):
+    
+    def app_init(self, handler):
+        default_path = '/income_progress'
+        handler.add_route('GET', default_path, self.display_income_progress) 
+        handler.add_route('POST', default_path, self.post_income_update) 
+        return 'income_progress', default_path 
 
     def do_POST(self):
+        self.post_income_update()
+
+    def post_income_update(self):
         from urllib.parse import parse_qs
         try:
             length = int(self.headers['content-length'])
@@ -188,11 +197,15 @@ class IncomeServer(PlomServer):
                 db.workday_minutes_worked_2 = 0
                 db.workday_minutes_worked_3 = 0
             db.write_db()
-            self.redirect()
+            homepage = self.apps['income_progress'] if hasattr(self, 'apps') else self.homepage
+            self.redirect(homepage)
         except PlomException as e:
             self.fail_400(e) 
 
     def do_GET(self):
+        self.display_income_progress()
+
+    def display_income_progress(self):
         import datetime
         import calendar
         try:
@@ -235,7 +248,9 @@ class IncomeServer(PlomServer):
                              ProgressBar("month", month_plus, month_goal, progress_time_month),
                              ProgressBar("week", week_plus, week_goal, progress_time_week),
                              ProgressBar("workday", day_income, workday_goal)]
+            homepage = self.apps['income_progress'] if hasattr(self, 'apps') else self.homepage
             page = jinja2.Template(tmpl).render(
+                    homepage = homepage,
                     progress_bars = progress_bars,
                     workday_hourly_rate_1 = db.workday_hourly_rate_1,
                     workday_minutes_worked_1 = db.workday_minutes_worked_1,
@@ -256,4 +271,4 @@ class IncomeServer(PlomServer):
 
 
 if __name__ == "__main__":       
-    run_server(server_port, IncomeServer)
+    run_server(server_port, IncomeProgressHandler)
diff --git a/ledger.py b/ledger.py
index 244a684..87d219e 100755
--- a/ledger.py
+++ b/ledger.py
@@ -3,7 +3,7 @@ import jinja2
 import decimal
 from datetime import datetime, timedelta
 from urllib.parse import parse_qs, urlparse
-from plomlib import PlomDB, PlomException, run_server, run_server, PlomServer
+from plomlib import PlomDB, PlomException, run_server, PlomHandler 
 
 server_port = 8082
 db_path = '/home/plom/org/ledger2023.dat'
@@ -20,20 +20,20 @@ input[type=number] { text-align: right; font-family: monospace; }
 .full_line_comment { display: block; white-space: nowrap; width: 0; }
 </style>
 <body>
-<a href="/">ledger</a>
-<a href="/balance">balance</a>
-<a href="/add_free">add free</a>
-<a href="/add_structured">add structured</a>
+<a href="{{prefix}}/ledger">ledger</a>
+<a href="{{prefix}}/balance">balance</a>
+<a href="{{prefix}}/add_free">add free</a>
+<a href="{{prefix}}/add_structured">add structured</a>
 <hr />
 """
 booking_html = """
-<p id="{{nth}}"><a href="#{{nth}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span><br />
-<span class="meta">[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>
-| move {% if move_up %}<a href="/move_up?start={{start}}&end={{end}}">up</a>{% else %}up{% endif %}/{% if move_down %}<a href="/move_down?start={{start}}&end={{end}}">down</a>{% else %}down{% endif %}
-| <a href="/balance?stop={{nth+1}}">balance after</a>
+<p id="{{nth}}"><a href="{{prefix}}#{{nth}}">{{date}}</a> {{desc}} <span class="comment">{{head_comment|e}}</span><br />
+<span class="meta">[edit: <a href="{{prefix}}/add_structured?start={{start}}&end={{end}}">structured</a>
+/ <a href="{{prefix}}/add_free?start={{start}}&end={{end}}">free</a>
+| copy:<a href="{{prefix}}/copy_structured?start={{start}}&end={{end}}">structured</a>
+/ <a href="{{prefix}}/copy_free?start={{start}}&end={{end}}">free</a>
+| move {% if move_up %}<a href="{{prefix}}/move_up?start={{start}}&end={{end}}">up</a>{% else %}up{% endif %}/{% if move_down %}<a href="{{prefix}}/move_down?start={{start}}&end={{end}}">down</a>{% else %}down{% endif %}
+| <a href="{{prefix}}/balance?stop={{nth+1}}">balance after</a>
 ]</span>
 <table>
 {% for l in booking_lines %}
@@ -333,7 +333,8 @@ class Booking:
 
 class LedgerDB(PlomDB):
 
-    def __init__(self):
+    def __init__(self, prefix):
+        self.prefix = prefix 
         self.bookings = []
         self.comments = []
         self.real_lines = []
@@ -353,9 +354,11 @@ class LedgerDB(PlomDB):
 
     def insert_at_date(self, lines, date):
         start_at = len(self.real_lines)
+        print("DEBUG triggered insert_at_date", date, start_at)
         for b in self.bookings:
             if b.date_string == date:
                 start_at = b.start_line 
+                print("DEBUG setting start_at to", start_at)
                 break
             elif b.date_string > date:
                 break
@@ -364,6 +367,7 @@ class LedgerDB(PlomDB):
         return self.write_lines_in_total_lines_at(self.real_lines, start_at, lines)
 
     def update(self, start, end, lines, date):
+        print("DEBUG update", date)
         total_lines = self.real_lines[:start] + self.real_lines[end:]
         n_original_lines = end - start
         start_at = len(total_lines)
@@ -512,184 +516,21 @@ class LedgerDB(PlomDB):
             ret += [f'  {acc_buffer}  {-final_minus} € ; assume as to earn in year: {acc_buffer} + {12 - months_passed - 1} * this = {year_needed}']
         return ret
 
-
-class LedgerServer(PlomServer):
-
-    def pre_init(self):
-        self.html_head += [html_head]
-
-    def do_POST(self):
-        try:
-            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 = LedgerDB()
-            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 
-                self.redirect( f'/#{nth}')
-            # otherwise just re-build editing form
-            else:
-                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(edit_content)
-        except PlomException as e:
-            self.fail_400(e)
-
-    def do_GET(self):
-        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 = LedgerDB()
-            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.redirect(f'/#{nth}')
-                return
-            elif parsed_url.path == '/move_down':
-                nth = self.move_down(db, start, end)
-                self.redirect(f'/#{nth}')
-                return
-            else:
-                page = self.ledger_as_html(db)
-            self.send_HTML(page)
-        except PlomException as e:
-            self.fail_400(e)
-
-    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 PlomException:
-                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)
-            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():
-                if currency != '€' and amount > 0:
-                    line += f"{amount:5.2f} {currency}\t"
-            lines += [line]
-            indent += "  "
-            for k, v in sorted(subtree.items()):
-                print_subtree(lines, indent, k, v, path + node + ":")
-        for k, v in sorted(account_tree.items()):
-            print_subtree(lines, "", k, v, "")
-        content = "\n".join(lines)
-        return f"<pre>{content}</pre>"
-
-    def ledger_as_html(self, db):
+    def ledger_as_html(self):
         booking_tmpl = jinja2.Template(booking_html)
         single_c_tmpl = jinja2.Template('<span class="comment">{{c|e}}</span><br />')  ##
         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
+        for nth, booking in enumerate(self.bookings):
+            move_up = nth > 0 and self.bookings[nth - 1].date_string == booking.date_string
+            move_down = nth < len(self.bookings) - 1 and self.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 != '']  ##
+            elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:i] if c != '']  ##
             for booking_line in booking.lines[1:]:
                  i += 1  ##
-                 comment = db.comments[i]  ##
+                 comment = self.comments[i]  ##
                  if booking_line == '':
                      booking_lines += [{'acc': None, 'money': None, 'comment': comment}]  ##
                      continue
@@ -699,28 +540,54 @@ class LedgerServer(PlomServer):
                      money = f'{booking_line[1]} {booking_line[2]}'
                  booking_lines += [{'acc': booking_line[0], 'money':money, 'comment':comment}]  ##
             elements_to_write += [booking_tmpl.render(
+                prefix=self.prefix,
                 nth=nth,
                 start=booking.start_line,
                 end=booking_end,
                 date=booking.date_string,
                 desc=booking.description,
-                head_comment=db.comments[booking.start_line],
+                head_comment=self.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 != '']  #
+        elements_to_write += [single_c_tmpl.render(c=c) for c in self.comments[last_i:] if c != '']  #
         return '\n'.join(elements_to_write)
 
-    def add_free(self, db, start=0, end=0, copy=False):
+    def balance_as_html(self, until=None):
+        bookings = self.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)
+            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():
+                if currency != '€' and amount > 0:
+                    line += f"{amount:5.2f} {currency}\t"
+            lines += [line]
+            indent += "  "
+            for k, v in sorted(subtree.items()):
+                print_subtree(lines, indent, k, v, path + node + ":")
+        for k, v in sorted(account_tree.items()):
+            print_subtree(lines, "", k, v, "")
+        content = "\n".join(lines)
+        return f"<pre>{content}</pre>"
+
+    def add_free(self, start=0, end=0, copy=False):
         tmpl = jinja2.Template(add_form_header + add_free_html + add_form_footer) 
-        lines = db.get_lines(start, end)
+        lines = self.get_lines(start, end)
         if copy:
             start = end = 0
-        return tmpl.render(action='add_free', start=start, end=end, lines=lines)
+        return tmpl.render(action=self.prefix + '/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):
+    def add_structured(self, start=0, end=0, copy=False, temp_lines=[], add_empty_line=None):
         tmpl = jinja2.Template(add_form_header + add_structured_html + add_form_footer) 
-        lines = temp_lines if len(''.join(temp_lines)) > 0 else db.get_lines(start, end)
+        lines = temp_lines if len(''.join(temp_lines)) > 0 else self.get_lines(start, end)
         bookings, comments = parse_lines(lines, validate_bookings=False)
         if len(bookings) > 1:
             raise PlomException('can only structurally edit single Booking')
@@ -728,9 +595,9 @@ class LedgerServer(PlomServer):
             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'
+        action = self.prefix + '/add_structured'
         datalist_sets = {'descriptions': set(), 'accounts': set(), 'currencies': set()}
-        for b in db.bookings:
+        for b in self.bookings:
             datalist_sets['descriptions'].add(b.description)
             for account, moneys in b.account_changes.items():
                 datalist_sets['accounts'].add(account)
@@ -776,31 +643,183 @@ class LedgerServer(PlomServer):
                 end=end)
         return content
 
-    def move_up(self, db, start, end):
+    def move_up(self, start, end):
         prev_booking = None
-        for redir_nth, b in enumerate(db.bookings):
+        for redir_nth, b in enumerate(self.bookings):
             if b.start_line >= start:
                 break
             prev_booking = b
         start_at = prev_booking.start_line 
-        self.make_move(db, start, end, start_at)
+        self.make_move(start, end, start_at)
         return redir_nth - 1
 
-    def move_down(self, db, start, end):
+    def move_down(self, start, end):
         next_booking = None
-        for redir_nth, b in enumerate(db.bookings):
+        for redir_nth, b in enumerate(self.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)
+        self.make_move(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)
+    def make_move(self, start, end, start_at):
+        lines = self.get_lines(start, end)
+        total_lines = self.real_lines[:start] + self.real_lines[end:]
+        self.write_lines_in_total_lines_at(total_lines, start_at, lines)
+
+    def booking_lines_from_postvars(self, postvars):
+        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 PlomException:
+                pass
+        if 'add_taxes' in postvars.keys():
+            lines += self.add_taxes(lines, finish=False)
+        elif 'add_taxes2' in postvars.keys():
+            lines += self.add_taxes(lines, finish=True)
+        return lines, add_empty_line
+
+
+
+class LedgerHandler(PlomHandler):
+    
+    def app_init(self, handler):
+        default_path = '/ledger'
+        handler.add_route('GET', default_path, self.forward_gets) 
+        handler.add_route('POST', default_path, self.forward_posts) 
+        return 'ledger', default_path 
+
+    def do_POST(self):
+        self.forward_posts()
+
+    def forward_posts(self):
+        try:
+            prefix = self.apps['ledger'] if hasattr(self, 'apps') else '' 
+            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 = LedgerDB(prefix)
+            add_empty_line = None
+            lines = []
+            # get inputs
+            if prefix + '/add_structured' == parsed_url.path and not 'revert' in postvars.keys():
+                lines, add_empty_line = db.booking_lines_from_postvars(postvars) 
+            elif prefix + '/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 
+                self.redirect(prefix + f'/#{nth}')
+            # otherwise just re-build editing form
+            else:
+                if prefix + '/add_structured' == parsed_url.path: 
+                    edit_content = db.add_structured(db, start, end, temp_lines=lines, add_empty_line=add_empty_line)
+                else:
+                    edit_content = db.add_free(db, start, end)
+                self.send_HTML(edit_content)
+        except PlomException as e:
+            self.fail_400(e)
+
+    def do_GET(self):
+        self.forward_gets()
+
+    def forward_gets(self):
+        try:
+            prefix = self.apps['ledger'] if hasattr(self, 'apps') else '' 
+            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 = LedgerDB(prefix=prefix)
+            if parsed_url.path == prefix + '/balance':
+                stop = params.get('stop', [None])[0]
+                page = db.balance_as_html(stop)
+            elif parsed_url.path == prefix + '/add_free':
+                page = db.add_free(start, end)
+            elif parsed_url.path == prefix + '/add_structured':
+                page = db.add_structured(start, end)
+            elif parsed_url.path == prefix + '/copy_free':
+                page = db.add_free(start, end, copy=True)
+            elif parsed_url.path == prefix + '/copy_structured':
+                page = db.add_structured(start, end, copy=True)
+            elif parsed_url.path == prefix + '/move_up':
+                nth = db.move_up(start, end)
+                self.redirect(prefix + f'/#{nth}')
+                return
+            elif parsed_url.path == prefix + '/move_down':
+                nth = db.move_down(start, end)
+                self.redirect(prefix + f'/#{nth}')
+                return
+            else:
+                page = db.ledger_as_html()
+            header = jinja2.Template(html_head).render(prefix=prefix)
+            self.send_HTML(header+ page)
+        except PlomException as e:
+            self.fail_400(e)
+
 
 
 if __name__ == "__main__":  
-    run_server(server_port, LedgerServer)
+    run_server(server_port, LedgerHandler)
diff --git a/plomlib.py b/plomlib.py
index 92bfb85..6a13f05 100644
--- a/plomlib.py
+++ b/plomlib.py
@@ -77,25 +77,17 @@ class PlomDB:
         self.unlock()
 
 
-class PlomServer(BaseHTTPRequestHandler): 
+class PlomHandler(BaseHTTPRequestHandler): 
+    homepage = '/'
+    html_head = '<!DOCTYPE html>\n<html>\n<meta charset="UTF-8">'
+    html_foot = '</body>\n</html>'
     
-    def __init__(self, *args, **kwargs):
-        self.html_head = ['<!DOCTYPE html>\n<html>\n<meta charset="UTF-8">']
-        self.html_foot = ['</body>\n</html>']
-        self.pre_init()
-        super().__init__(*args, **kwargs)
-
-    def pre_init(self):
-        pass
-
     def fail_400(self, e):
         self.send_HTML(f'ERROR: {e}', 400)
 
     def send_HTML(self, html, code=200):
         self.send_code_and_headers(code, [('Content-type', 'text/html')])
-        header = '\n'.join(self.html_head)
-        footer = '\n'.join(self.html_foot)
-        self.wfile.write(bytes(f'{header}\n{html}\n{footer}', 'utf-8'))
+        self.wfile.write(bytes(f'{self.html_head}\n{html}\n{self.html_foot}', 'utf-8'))
 
     def send_code_and_headers(self, code, headers=[]):
         self.send_response(code)
@@ -108,9 +100,9 @@ class PlomServer(BaseHTTPRequestHandler):
 
 
 
-def run_server(port, server_class):
+def run_server(port, handler_class):
     from http.server import HTTPServer
-    webServer = HTTPServer(('localhost', port), server_class)
+    webServer = HTTPServer(('localhost', port), handler_class)
     print(f"Server started http://localhost:{port}")
     try:
         webServer.serve_forever()
diff --git a/unite.py b/unite.py
new file mode 100644
index 0000000..14a7e3c
--- /dev/null
+++ b/unite.py
@@ -0,0 +1,62 @@
+from plomlib import PlomException, run_server, PlomHandler 
+from urllib.parse import urlparse
+from income_progress_bars import IncomeProgressHandler 
+from calories import ConsumptionsHandler 
+from ledger import LedgerHandler 
+server_port = 8084
+
+
+class UnitedRequestHandler(PlomHandler):
+    routes = {'GET':{}, 'POST':{}}
+    apps = {}
+
+    @classmethod
+    def register_app(cls, app):
+        name, data = app.app_init(app, cls)
+        cls.apps[name] = data
+
+    @classmethod
+    def add_route(cls, method, path, service):
+        if not method in cls.routes.keys():
+            cls.routes[method] = {}
+        cls.routes[method][path] = service 
+
+    def do_POST(self):
+        try: 
+            parsed_url = urlparse(self.path)
+            path_toks = parsed_url.path.split('/')
+            while len(path_toks) > 0:
+                target_path = '/'.join(path_toks)
+                if target_path in self.routes['POST'].keys(): 
+                    self.routes['POST'][target_path](self)
+                    return 
+                path_toks.pop()
+            page = 'nothing to post?'
+            self.send_HTML(page)
+        except PlomException as e:
+            self.fail_400(e)
+
+    def do_GET(self):
+        try: 
+            parsed_url = urlparse(self.path)
+            path_toks = parsed_url.path.split('/')
+            while len(path_toks) > 0:
+                target_path = '/'.join(path_toks)
+                print(target_path)
+                if target_path in self.routes['GET'].keys():                
+                    self.routes['GET'][target_path](self)
+                    return 
+                path_toks.pop()
+            page = 'hi there!<br />'
+            for route in self.routes['GET']:
+                page += f'<a href="{route}"/>{route}</a><br />'
+            self.send_HTML(page)
+        except PlomException as e:
+            self.fail_400(e)
+
+
+if __name__ == "__main__":  
+    UnitedRequestHandler.register_app(IncomeProgressHandler)
+    UnitedRequestHandler.register_app(ConsumptionsHandler)
+    UnitedRequestHandler.register_app(LedgerHandler)
+    run_server(server_port, UnitedRequestHandler)
-- 
2.30.2