Merge pull request 'Statuszeile und filtern von aktiven Adressen' (#9) from statuszeile_und_filter into main

Reviewed-on: #9

deb-package/brovski-adressetiketten/DEBIAN/control

@@ -1,5 +1,5 @@
 Package: brovski-adressetiketten
-Version: 0.6a
+Version: 0.7a
 Maintainer: Ovski
 Architecture: all
 Description: manage csv files for glables address labels

src/brovski-adress-etiketten-verwaltung.py

@@ -5,10 +5,10 @@ import tkinter as tk
 from configparser import NoSectionError, NoOptionError
 from tkinter import messagebox
 from tkinter import ttk
-import json
 
 from config import Config
-from windows import SettingsWindow, EditRecord, Window, show_error
+from connector import JSONConnector
+from windows import SettingsWindow, EditRecord, show_error
 
 
 class Application:
@@ -18,7 +18,7 @@ class Application:
         y_offset = 200
         width = 1050
         height = 700
-        VERSION = '0.6a'
+        VERSION = '0.7a'
         title = f"Brovski Adress-Etiketten Verwaltung {VERSION}"
 
         self.root = tk.Tk(className="BrovskiAdressEtiketten")
@@ -32,14 +32,17 @@ class Application:
         self.address_list = []
         self.current_record: int | None = None
         self.sort_order = False
+        self.last_sort_field = "#3"
+        self.filter_active = tk.BooleanVar(value=False)
+
+        # model connector
+        self.model = JSONConnector()
 
         # init paths to json and csv file
         self.json_file_name = "brovski-adress-etiketten-verwaltung.json"
         self.csv_file_name = "brovski-adress-etiketten.csv"
-        self.json_path = ""
         self.csv_path = ""
         self.load_config()
-        self.json_file = os.path.join(self.json_path, self.json_file_name)
         self.csv_file = os.path.join(self.csv_path, self.csv_file_name)
 
         # status bar content
@@ -69,6 +72,8 @@ class Application:
         tk.Button(top_frame, text="Delete", command=self.delete_record, width=button_width).pack(side=tk.LEFT)
         tk.Button(top_frame, text="Export CSV", command=self.export_csv, width=button_width).pack(side=tk.LEFT)
         tk.Button(top_frame, text="Toggle Aktiv", command=self.toggle_active, width=button_width).pack(side=tk.LEFT)
+        tk.Checkbutton(top_frame, text="Filter aktiv", variable=self.filter_active, command=self.populate_table).pack(
+            side=tk.LEFT)
         tk.Button(top_frame, text="Quit", command=self.on_close, width=button_width).pack(side=tk.RIGHT)
         tk.Button(top_frame, text="Settings", command=self.show_settings, width=button_width).pack(side=tk.RIGHT)
 
@@ -87,21 +92,22 @@ class Application:
         scrollbar.pack(side=tk.LEFT, fill=tk.Y)
 
         self.table.bind("<ButtonRelease-1>", self.mouse_click)
-        self.table.bind("<Return>", self.mouse_click_double)
+        self.table.bind("<Return>", self.enter_button)
         self.table.bind("<Double-1>", self.mouse_click_double)
+        self.root.bind("<Up>", self.focus_table)
+        self.root.bind("<Down>", self.focus_table)
 
         # bottom status bar
         tk.Label(bottom_frame, textvariable=self.statusbar).pack(side=tk.LEFT)
 
-        self._load_json_file()
+        self.first_sort_after_start()
 
         self.root.mainloop()
 
     def load_config(self):
         try:
-            self.json_path = self.config.get("json", "path")
             self.csv_path = self.config.get("csv", "path")
-            if self.json_path == "" or self.csv_path == "":
+            if self.csv_path == "":
                 raise ValueError("Empty JSON or CSV path")
             self.config_good = True
         except NoSectionError:
@@ -127,55 +133,55 @@ class Application:
         settings.wait_window()
 
     def insert_record(self):
-        values = [
-            "x",
-            "Firma",
-            "Name",
-            "Strasse",
-            "Plz/Ort",
-        ]
-        last_iid = self.table.get_children()[-1]
-        next_iid = int(last_iid) + 1
-        self.table.insert('', 'end', iid=next_iid, values=values)
-        self._save_json_file()
+        values = {
+            "aktiv": "x",
+            "firma": "Firma",
+            "name": "Name",
+            "strasse": "Strasse",
+            "plzort": "Plz/Ort"
+        }
+        self.model.create_new(values)
+        self.populate_table()
         self.deselect_tree()
 
     def delete_record(self):
         if self.current_record is None:
             return
 
+        if len(self.table.selection()) > 1:
+            show_error(message_title="Mehrere Adressen ausgewählt",
+                       message="Es können nur einzelne Adressen gelöscht werden",
+                       parent=self.root)
+            return
+
         if messagebox.askyesno(
                 "Eintrag löschen?",
                 "Willst du diesen Eintrag wirklich löschen?\nDies kann nicht rückgängig gemacht werden"):
-            self.table.delete(self.current_record)
+            self.model.delete_by_id(self.current_record)
 
         self.deselect_tree()
-        self._save_json_file()
+        self.populate_table()
 
-    def update_record(self, data: list):
+    def update_record(self, record: dict):
         if self.current_record is None:
             return
-        values = {}
-        for idx, value in enumerate(data):
-            values[str(idx)] = value.get()
-
-        for key, value in values.items():
-            self.table.set(self.current_record, key, value)
-
-        self._save_json_file()
+        self.model.update_record(record)
+        self.populate_table()
 
     def toggle_active(self):
-        items = self.table.selection()
-        if len(items) == 0:
+        selection = self.table.selection()
+        if len(selection) == 0:
             return
 
-        for record_id in items:
-            values = self.table.item(record_id, "values")
-            active = values[0]
-            new_active = "x" if active == "" else ""
-            self.table.set(record_id, "0", new_active)
+        item_list = [int(x) for x in selection]
+        for address in self.address_list:
+            record_id = address.get("record_id")
+            if record_id in item_list:
+                address["aktiv"] = "x" if address["aktiv"] == "" else ""
+                self.model.update_record(address)
+                self.table.set(record_id, "0", address["aktiv"])
 
-        self._save_json_file()
+        self.update_status_bar()
 
     def deselect_tree(self):
         while len(self.table.selection()) > 0:
@@ -183,7 +189,11 @@ class Application:
         self.current_record = None
 
     def mouse_click(self, event):
-        self.current_record = self.table.focus()
+        id_string = self.table.focus()
+        if id_string is not None and id_string != "":
+            self.current_record = int(self.table.focus())
+        else:
+            self.current_record = None
         region = self.table.identify("region", event.x, event.y)
         match region:
             case "heading":
@@ -193,84 +203,77 @@ class Application:
         region = self.table.identify("region", event.x, event.y)
         match region:
             case "cell":
-                self.click_on_cell()
+                self.edit_selected_record()
+
+    def enter_button(self, event):
+       self.edit_selected_record()
 
     def click_on_header(self, event):
         column = self.table.identify_column(event.x)
+        if self.last_sort_field == column:
+            self.sort_order = False if self.sort_order else True
+        else:
+            self.sort_order = False
+            self.last_sort_field = column
+
         match column:
             case "#1":
-                self.address_list.sort(key=lambda x: x[int(column[-1]) - 1], reverse=self.sort_order)
-                self.populate_table()
+                field = "aktiv"
             case "#2":
-                self.address_list.sort(key=lambda x: x[int(column[-1]) - 1], reverse=self.sort_order)
-                self.populate_table()
+                field = "firma"
             case "#3":
-                self.address_list.sort(key=lambda x: x[int(column[-1]) - 1], reverse=self.sort_order)
-                self.populate_table()
+                field = "name"
             case "#4":
-                self.address_list.sort(key=lambda x: x[int(column[-1]) - 1], reverse=self.sort_order)
-                self.populate_table()
+                field = "strasse"
             case "#5":
-                self.address_list.sort(key=lambda x: x[int(column[-1]) - 1], reverse=self.sort_order)
-                self.populate_table()
+                field = "plzort"
             case _:
-                print(column)
-        self.sort_order = not self.sort_order
+                field = "name"
 
-    def click_on_cell(self):
-        self.current_record = self.table.focus()
-        values = self.table.item(self.current_record, "values")
-        self.open_window_edit_records(values)
+        self.address_list = self.model.get_all_sorted_by(field, self.sort_order)
+        self.populate_table(reload=False)
 
-    def _load_json_file(self):
-        try:
-            with open(self.json_file, "r", encoding="utf-8") as f:
-                self.address_list = json.load(f)
-                self.address_list.sort(key=lambda x: (x[0], x[1]))
-        except FileNotFoundError:
-            show_error(
-                message_title="Datei nicht gefunden",
-                message=f"{self.json_file_name} nicht gefunden, erstelle leere Datei unter {self.json_path}",
-                parent=self.root
-            )
-            self.address_list = [["", "firma", "name", "adresse", "plz/ort"]]
-            with open(self.json_file, "w", encoding="utf-8") as f:
-                json.dump(self.address_list, f)
-        self.populate_table()
+    def edit_selected_record(self):
+        if self.table.focus() is None or self.table.focus() == "":
+            return
+        self.current_record = int(self.table.focus())
+        self.open_window_edit_records(self.current_record)
 
-    def _save_json_file(self):
-        self.export_table_to_address_list()
-        try:
-            with open(self.json_file, "w", encoding="utf-8") as f:
-                json.dump(self.address_list, f, indent=4, sort_keys=True)
-        except FileNotFoundError:
-            show_error(
-                message_title="Unexpected Error: File not found?!",
-                message=f"{self.json_file_name} not found",
-                parent=self.root
-            )
 
     def export_csv(self):
         try:
             with open(self.csv_file, "w", encoding="utf-8") as f:
                 writer = csv.writer(f, delimiter=",")
                 for address in self.address_list:
-                    if address[0] != "x":
+                    if address["aktiv"] != "x":
                         continue
-                    if address[1] == "":
-                        writer.writerow(address[2:])
-                    else:
-                        writer.writerow(address[1:])
+                    line = []
+                    if address["firma"] != "":
+                        line.append(address["firma"])
+                    line.append(address["name"])
+                    line.append(address["strasse"])
+                    line.append(address["plzort"])
+                    writer.writerow(line)
         except FileNotFoundError:
             show_error(message_title="Unexpected error",
                        message=f"Could not write file {self.csv_file}",
                        parent=self.root
                        )
 
-    def populate_table(self):
+    def populate_table(self, reload=True):
+        if reload:
+            self.address_list = self.model.get_all()
+        if len(self.address_list) == 0:
+            return
         self.delete_all_table_items()
-        for index, item in enumerate(self.address_list):
-            self.table.insert('', 'end', iid=index, values=item)
+        for address in self.address_list:
+            # skip inactive records if filter is true
+            if self.filter_active.get() and address["aktiv"] != "x":
+                continue
+            self.table.insert('', 'end', iid=address["record_id"],
+                              values=(address["aktiv"], address["firma"], address["name"], address["strasse"],
+                                      address["plzort"])
+                              )
         self.update_status_bar()
 
     def export_table_to_address_list(self):
@@ -292,8 +295,8 @@ class Application:
         window.grab_set()
         return window
 
-    def open_window_edit_records(self, data):
-        window = EditRecord(self, self.root, data)
+    def open_window_edit_records(self, record_id: int):
+        window = EditRecord(self, self.root, record_id)
         window.wm_transient(self.root)
         window.wait_visibility()
         window.grab_set()
@@ -306,11 +309,23 @@ class Application:
         self.length_address_list = len(self.address_list)
         count = 0
         for address in self.address_list:
-            if address[0] == "x":
+            if address["aktiv"] == "x":
                 count += 1
         self.length_address_list_active = count
 
+    def first_sort_after_start(self):
+        self.address_list.sort(key=lambda x: (x["firma"], x["name"]))
+        self.populate_table()
 
+    def focus_table(self, event):
+        first = self.table.get_children()[0]
+        last = self.table.get_children()[-1]
+        goto = last if event.keysym == "Up" else first
+        if self.table.focus() == "":
+            self.table.selection_set(goto)
+            self.table.focus(goto)
+            self.table.see(goto)
+            self.table.focus_force()
 
 
 if __name__ == '__main__':

src/connector.py

@@ -0,0 +1,82 @@
+import json
+import os
+from abc import ABC, abstractmethod
+
+import config
+
+
+class Connector(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def get_all(self) -> list:
+        pass
+
+    @abstractmethod
+    def get_by_id(self, record_id: int) -> dict:
+        pass
+
+    @abstractmethod
+    def delete_by_id(self, record_id: int):
+        pass
+
+    @abstractmethod
+    def update_record(self, updated_record: dict):
+        pass
+
+    @abstractmethod
+    def create_new(self, values: dict) -> int:
+        pass
+
+
+class JSONConnector(Connector):
+    def __init__(self):
+        super().__init__()
+        self.config = config.Config()
+        self.json_path = self.config.get("json", "path")
+        self.json_file = os.path.join(self.json_path, "brovski-adress-etiketten-verwaltung-v7.json")
+
+    def get_all(self) -> list:
+        with open(self.json_file, "r") as f:
+            return json.load(f)
+
+    def get_all_sorted_by(self, field: str, reverse=False) -> list:
+        with open(self.json_file, "r") as f:
+            data = json.load(f)
+        return sorted(data, key=lambda k: k[field], reverse=reverse)
+
+    def get_by_id(self, record_id: int) -> dict:
+        data = self.get_all()
+        for record in data:
+            if record["record_id"] == record_id:
+                return record
+
+    def delete_by_id(self, record_id: int):
+        data = self.get_all()
+        for idx, record in enumerate(data):
+            if record["record_id"] == record_id:
+                del data[idx]
+        self._write_to_file(data)
+
+    def update_record(self, new_record: dict):
+        data = self.get_all()
+        for idx, record in enumerate(data):
+            if record["record_id"] == new_record["record_id"]:
+                data[idx] = new_record
+        self._write_to_file(data)
+
+    def create_new(self, record: dict) -> int:
+        data = self.get_all()
+        if len(data) == 0:
+            next_id = 0
+        else:
+            next_id = max(data, key=lambda x: x["record_id"])["record_id"] + 1
+        record["record_id"] = next_id
+        data.append(record)
+        self._write_to_file(data)
+        return next_id
+
+    def _write_to_file(self, data):
+        with open(self.json_file, "w") as f:
+            json.dump(data, f, indent=4)

src/windows.py

@@ -3,6 +3,7 @@ from configparser import NoSectionError, NoOptionError
 from tkinter import font, filedialog, messagebox
 
 from config import Config
+from connector import JSONConnector
 
 
 def show_error(message_title: str, message: str, parent: tk.Tk | tk.Toplevel):
@@ -25,27 +26,28 @@ class Window(tk.Toplevel):
         self._destroy_window()
 
     def _destroy_window(self):
+        self.parent.populate_table()
         self.root.update()
         self.destroy()
 
 
 class EditRecord(Window):
-    def __init__(self, parent, root: tk.Tk, data: tuple):
+    def __init__(self, parent, root: tk.Tk, record_id: int):
         super().__init__(parent, root)
         self.bind("<Return>", self._update)
 
-        self.data = data
+        self.model = JSONConnector()
+
+        record = self.model.get_by_id(record_id)
+
         button_width = 8
         self.title("Adresse bearbeiten")
-        self.aktiv = tk.StringVar()
-        self.firma = tk.StringVar()
-        self.name = tk.StringVar()
-        self.strasse = tk.StringVar()
-        self.plz_ort = tk.StringVar()
-
-        self.field_list = [self.aktiv, self.firma, self.name, self.strasse, self.plz_ort]
-        for argument, field in zip(self.data, self.field_list):
-            field.set(argument)
+        self.record_id = tk.IntVar(value=record_id)
+        self.aktiv = tk.StringVar(value=record.get("aktiv"))
+        self.firma = tk.StringVar(value=record.get("firma"))
+        self.name = tk.StringVar(value=record.get("name"))
+        self.strasse = tk.StringVar(value=record.get("strasse"))
+        self.plz_ort = tk.StringVar(value=record.get("plzort"))
 
         edit_frame = tk.Frame(self)
         edit_frame.pack(side=tk.TOP, fill=tk.X, pady=20, padx=20)
@@ -71,7 +73,15 @@ class EditRecord(Window):
         tk.Button(button_frame, text="Abbrechen", command=self.close_window, width=button_width).pack(side=tk.LEFT)
 
     def _update(self, event = None):
-        self.parent.update_record(self.field_list)
+        new_record = {
+            "record_id": self.record_id.get(),
+            "aktiv": self.aktiv.get(),
+            "firma": self.firma.get(),
+            "name": self.name.get(),
+            "strasse": self.strasse.get(),
+            "plzort": self.plz_ort.get(),
+        }
+        self.model.update_record(new_record)
         self.close_window()
 
 

version.txt

@@ -1 +1 @@
-0.6a
+0.7a