feat: 新增导出操作

control/admin.py

@@ -6,7 +6,7 @@ from tkinter import ttk
 import conf
 from core.garbage import GarbageBag
 from core.user import User
-from equipment.scan_garbage import write_gid_qr
+from equipment.scan_garbage import write_gid_qr, write_all_gid_qr
 from equipment.scan_user import write_uid_qr, write_all_uid_qr
 from event import TkEventMain
 from sql.db import DB, search_from_garbage_checker_user
@@ -59,6 +59,12 @@ class AdminStationBase(TkEventMain, metaclass=abc.ABCMeta):
                 re.append(("", gar))
         return re
 
+    def export_garbage_by_gid(self, path: Optional[str], gid: gid_t) -> Tuple[str, Optional[GarbageBag]]:
+        return write_gid_qr(gid, path, self._db)
+
+    def export_garbage(self, path: Optional[str], where: str) -> List[Tuple[str]]:
+        return write_all_gid_qr(path, self._db, where=where)
+
     def create_user(self, name: uname_t, passwd: passwd_t, phone: str, manager: bool) -> Optional[User]:
         return create_new_user(name, passwd, phone, manager, self._db)
 
@@ -71,16 +77,10 @@ class AdminStationBase(TkEventMain, metaclass=abc.ABCMeta):
             re.append(user)
         return re
 
-    def get_gid_qrcode(self, gid: gid_t, path: str) -> Tuple[str, Optional[GarbageBag]]:
-        return write_gid_qr(gid, path, self._db)
-
-    def get_all_gid_qrcode(self, path: str, where: str = "") -> List[str]:
-        return write_all_uid_qr(path, self._db, where=where)
-
-    def get_uid_qrcode(self, uid: uid_t, path: str) -> Tuple[str, Optional[User]]:
+    def export_user_by_uid(self, path: str, uid: uid_t) -> Tuple[str, Optional[User]]:
         return write_uid_qr(uid, path, self._db)
 
-    def get_all_uid_qrcode(self, path: str, where: str = "") -> List[str]:
+    def export_user(self, path: str, where) -> List[str]:
         return write_all_uid_qr(path, self._db, where=where)
 
     def del_garbage_not_use(self, gid: gid_t) -> bool:

control/admin_event.py

@@ -90,6 +90,80 @@ class CreateGarbageEvent(AdminEventBase):
         self.station.show_msg("CreateGarbage", f"create {len(res)} garbage finished.")
 
 
+class ExportGarbageByIDEvent(AdminEventBase):
+    def func(self, path, gid):
+        return self.station.export_garbage_by_gid(path, gid)
+
+    def __init__(self, station):
+        super(ExportGarbageByIDEvent, self).__init__(station)
+        self._name = None
+
+    def start(self, path, gid):
+        self.thread = TkThreading(self.func, path, gid)
+        return self
+
+    def done_after_event(self):
+        res: tuple[str, Optional[GarbageBag]] = self.thread.wait_event()
+        if res[1] is None:
+            self.station.show_msg("ExportError", f"Export garbage error.")
+        else:
+            self.station.show_msg("ExportSuccess", f"Export garbage finished.")
+
+
+class ExportGarbageAdvancedEvent(AdminEventBase):
+    def func(self, path, where):
+        return self.station.export_garbage(path, where)
+
+    def __init__(self, station):
+        super(ExportGarbageAdvancedEvent, self).__init__(station)
+        self._name = None
+
+    def start(self, path, where):
+        self.thread = TkThreading(self.func, path, where)
+        return self
+
+    def done_after_event(self):
+        res: list[tuple[str]] = self.thread.wait_event()
+        self.station.show_msg("Export", f"Export {len(res)} garbage finished.")
+
+
+class ExportUserByIDEvent(AdminEventBase):
+    def func(self, path, uid):
+        return self.station.export_user_by_uid(path, uid)
+
+    def __init__(self, station):
+        super(ExportUserByIDEvent, self).__init__(station)
+        self._name = None
+
+    def start(self, path, uid):
+        self.thread = TkThreading(self.func, path, uid)
+        return self
+
+    def done_after_event(self):
+        res: tuple[str, Optional[GarbageBag]] = self.thread.wait_event()
+        if res[1] is None:
+            self.station.show_msg("ExportError", f"Export user error.")
+        else:
+            self.station.show_msg("ExportSuccess", f"Export user finished.")
+
+
+class ExportUserAdvancedEvent(AdminEventBase):
+    def func(self, path, where):
+        return self.station.export_user(path, where)
+
+    def __init__(self, station):
+        super(ExportUserAdvancedEvent, self).__init__(station)
+        self._name = None
+
+    def start(self, path, where):
+        self.thread = TkThreading(self.func, path, where)
+        return self
+
+    def done_after_event(self):
+        res: list[tuple[str]] = self.thread.wait_event()
+        self.station.show_msg("Export", f"Export {len(res)} user finished.")
+
+
 class DelUserEvent(AdminEventBase):
     def func(self, uid):
         return self.station.del_user(uid)

control/admin_menu.py

@@ -87,6 +87,8 @@ class CreateMenu(AdminMenu):
         self.btn[1]['command'] = lambda: self.create_auto_user()
         self.btn[2]['command'] = lambda: self.create_manager_user()
         self.btn[3]['command'] = lambda: self.create_garbage()
+        self.btn[4]['command'] = lambda: self.export_user()
+        self.btn[5]['command'] = lambda: self.export_garbage()
 
     def create_normal_user(self):
         self.station.to_program("CreateNormalUser")
@@ -100,6 +102,12 @@ class CreateMenu(AdminMenu):
     def create_garbage(self):
         self.station.to_program("CreateGarbage")
 
+    def export_user(self):
+        self.station.to_program("ExportUser")
+
+    def export_garbage(self):
+        self.station.to_program("ExportGarbage")
+
 
 class DeleteMenu(AdminMenu):
     def __init__(self, station, win, color):

control/admin_program.py

@@ -217,7 +217,7 @@ class CreateAutoNormalUserProgram(AdminProgram):
         self.enter_frame['bg'] = "#bce672"
         self.enter_frame['bd'] = 5
         self.enter_frame['relief'] = "ridge"
-        self.enter_frame.place(relx=0.2, rely=0.3, relwidth=0.6, relheight=0.10)
+        self.enter_frame.place(relx=0.2, rely=0.3, relwidth=0.6, relheight=0.12)
 
         self.title['font'] = title_font
         self.title['text'] = "Phone:"
@@ -227,8 +227,8 @@ class CreateAutoNormalUserProgram(AdminProgram):
         self.enter['font'] = title_font
         self.enter['textvariable'] = self.var
 
-        self.title.place(relx=0.02, rely=0.2, relwidth=0.25, relheight=0.48)
-        self.enter.place(relx=0.30, rely=0.2, relwidth=0.60, relheight=0.48)
+        self.title.place(relx=0.02, rely=0.25, relwidth=0.25, relheight=0.50)
+        self.enter.place(relx=0.30, rely=0.25, relwidth=0.60, relheight=0.50)
 
         self.btn['font'] = btn_font
         self.btn['text'] = "Create"
@@ -333,6 +333,158 @@ class CreateGarbageProgram(AdminProgram):
         set_tk_disable_from_list(self.enter, flat='normal')
 
 
+class ExportProgramBase(AdminProgram):
+    def __init__(self, station, win, color, title: str):
+        super().__init__(station, win, color, title)
+
+        self.gid_frame = tk.Frame(self.frame)
+        self.gid_title: List[tk.Label] = [tk.Label(self.gid_frame), tk.Label(self.gid_frame)]
+        self.gid_enter: List[tk.Entry] = [tk.Entry(self.gid_frame), tk.Entry(self.gid_frame)]
+        self.gid_var: List[tk.Variable] = [tk.StringVar(), tk.StringVar()]
+
+        self.where_frame = tk.Frame(self.frame)
+        self.where_title: List[tk.Label] = [tk.Label(self.where_frame), tk.Label(self.where_frame)]
+        self.where_enter: List[tk.Entry] = [tk.Entry(self.where_frame), tk.Entry(self.where_frame)]
+        self.where_var: List[tk.Variable] = [tk.StringVar(), tk.StringVar()]
+
+        self.create_btn: List[tk.Button] = [tk.Button(self.frame), tk.Button(self.frame)]
+        self.file_btn: List[tk.Button] = [tk.Button(self.frame), tk.Button(self.frame)]
+
+        self._conf("", [], [], [])
+        self.__conf_font()
+
+    def _conf(self, bg_color: str, title_id, title_where, title_command):
+        self.bg_color = bg_color
+        self.title_id = title_id
+        self.title_where = title_where
+        self.title_command = title_command
+
+    def __conf_font(self, n: int = 1):
+        self.title_font_size = int(16 * n)
+        self.btn_font_size = int(14 * n)
+
+    def conf_gui(self, n: int = 1):
+        self.__conf_font(n)
+
+        title_font = make_font(size=self.title_font_size)
+        btn_font = make_font(size=self.btn_font_size)
+
+        self.where_frame['bg'] = self.bg_color
+        self.where_frame['bd'] = 5
+        self.where_frame['relief'] = "ridge"
+        self.where_frame.place(relx=0.2, rely=0.2, relwidth=0.6, relheight=0.17)
+
+        self.gid_frame['bg'] = self.bg_color
+        self.gid_frame['bd'] = 5
+        self.gid_frame['relief'] = "ridge"
+        self.gid_frame.place(relx=0.2, rely=0.6, relwidth=0.6, relheight=0.17)
+
+        height = 0.1
+        for lb, text, enter, var, lb_w, text_w, enter_w, var_w in zip(
+                self.gid_title, self.title_id, self.gid_enter, self.gid_var,
+                self.where_title, self.title_where, self.where_enter, self.where_var):
+            lb['font'] = title_font
+            lb['text'] = text
+            lb['bg'] = self.bg_color
+            lb['anchor'] = 'e'
+
+            lb_w['font'] = title_font
+            lb_w['text'] = text_w
+            lb_w['bg'] = self.bg_color
+            lb_w['anchor'] = 'e'
+
+            enter['textvariable'] = var
+            enter['font'] = title_font
+
+            enter_w['textvariable'] = var_w
+            enter_w['font'] = title_font
+
+            lb.place(relx=0.01, rely=height, relwidth=0.30, relheight=0.35)
+            enter.place(relx=0.35, rely=height, relwidth=0.60, relheight=0.35)
+
+            lb_w.place(relx=0.01, rely=height, relwidth=0.30, relheight=0.35)
+            enter_w.place(relx=0.35, rely=height, relwidth=0.60, relheight=0.35)
+
+            height += 0.43
+
+        for btn, text in zip(self.create_btn + self.file_btn, self.title_command):
+            btn['font'] = btn_font
+            btn['text'] = text
+            btn['bg'] = conf.tk_btn_bg
+
+        self.create_btn[1]['command'] = self.export_where
+        self.create_btn[0]['command'] = self.export_id
+        self.create_btn[1].place(relx=0.2, rely=0.39, relwidth=0.25, relheight=0.08)
+        self.create_btn[0].place(relx=0.2, rely=0.79, relwidth=0.25, relheight=0.08)
+
+        self.file_btn[1]['command'] = self.choose_file_where
+        self.file_btn[0]['command'] = self.choose_file_id
+        self.file_btn[1].place(relx=0.6, rely=0.39, relwidth=0.2, relheight=0.08)
+        self.file_btn[0].place(relx=0.6, rely=0.79, relwidth=0.2, relheight=0.08)
+
+    def choose_file_id(self):
+        path = askdirectory(title='path to save qr code')
+        self.gid_var[1].set(path)
+
+    def choose_file_where(self):
+        path = askdirectory(title='path to save qr code')
+        self.where_var[1].set(path)
+
+    def export_id(self):
+        ...
+
+    def export_where(self):
+        ...
+
+    def set_disable(self):
+        set_tk_disable_from_list(self.gid_enter)
+        set_tk_disable_from_list(self.create_btn)
+        set_tk_disable_from_list(self.file_btn)
+
+    def reset_disable(self):
+        set_tk_disable_from_list(self.gid_enter, flat='normal')
+        set_tk_disable_from_list(self.create_btn, flat='normal')
+        set_tk_disable_from_list(self.file_btn, flat='normal')
+
+
+class ExportGarbageProgram(ExportProgramBase):
+    def __init__(self, station, win, color):
+        super().__init__(station, win, color, "ExportGarbage")
+        self._conf("#afdfe4", ["GarbageID:", "Export:"], ["Where:", "Export:"],
+                   ["Export By GarbageID", "Export Advanced", "ChoosePath", "ChoosePath"])
+
+    def export_id(self):
+        gid = self.gid_var[0].get()
+        path = self.gid_var[1].get()
+        event = tk_event.ExportGarbageByIDEvent(self.station).start(path, gid)
+        self.station.push_event(event)
+
+    def export_where(self):
+        where = self.where_var[0].get()
+        path = self.where_var[1].get()
+        event = tk_event.ExportGarbageAdvancedEvent(self.station).start(path, where)
+        self.station.push_event(event)
+
+
+class ExportUserProgram(ExportProgramBase):
+    def __init__(self, station, win, color):
+        super().__init__(station, win, color, "ExportUser")
+        self._conf("#f69c9f", ["UserID:", "Export:"], ["Where:", "Export:"],
+                   ["Export By UserID", "Export Advanced", "ChoosePath", "ChoosePath"])
+
+    def export_id(self):
+        uid = self.gid_var[0].get()
+        path = self.gid_var[1].get()
+        event = tk_event.ExportUserByIDEvent(self.station).start(path, uid)
+        self.station.push_event(event)
+
+    def export_where(self):
+        where = self.where_var[0].get()
+        path = self.where_var[1].get()
+        event = tk_event.ExportUserAdvancedEvent(self.station).start(path, where)
+        self.station.push_event(event)
+
+
 class DeleteUserProgram(AdminProgram):
     def __init__(self, station, win, color):
         super().__init__(station, win, color, "DeleteUser")
@@ -1407,4 +1559,5 @@ all_program = [WelcomeProgram, CreateNormalUserProgram, CreateManagerUserProgram
                CreateGarbageProgram, DeleteUserProgram, DeleteUsersProgram, DeleteGarbageProgram,
                DeleteGarbageMoreProgram, DeleteAllGarbageProgram, SearchUserProgram, SearchUserAdvancedProgram,
                SearchGarbageProgram, SearchGarbageAdvancedProgram, SearchAdvancedProgram, UpdateUserScoreBase,
-               UpdateUserReputationBase, UpdateGarbageTypeProgram, UpdateGarbageCheckResultProgram]
+               UpdateUserReputationBase, UpdateGarbageTypeProgram, UpdateGarbageCheckResultProgram,
+               ExportGarbageProgram, ExportUserProgram]

equipment/scan_garbage.py

@@ -55,11 +55,11 @@ def write_gid_qr(gid: gid_t, path: str, db: DB) -> Tuple[str, Optional[GarbageBa
     return "", None
 
 
-def write_all_gid_qr(path: str, db: DB, where: str = "") -> List[Tuple[str,]]:
+def write_all_gid_qr(path: str, db: DB, where: str = "") -> List[Tuple[str]]:
     if len(where) > 0:
         where = f"WHERE {where}"
 
-    cur = db.search(f"SELECT gid FROM garbage {where};")
+    cur = db.search(f"SELECT GarbageID FROM garbage {where};")
     if cur is None:
         return []
 

equipment/scan_user.py

@@ -67,7 +67,7 @@ def write_all_uid_qr(path: str, db: DB, name="nu", where: str = "") -> List[str]
     if len(where) > 0:
         where = f"WHERE {where}"
 
-    cur = db.search(f"SELECT uid, name FROM user {where};")
+    cur = db.search(f"SELECT UserID, name FROM user {where};")
     if cur is None:
         return []