1131002-udpast-test10-增加文字功能

使用繁體中文，在W11環境下，使用pythone語言，使用UI界面， 希望在"# 建立傳輸檔案按鈕"右邊新增一個"傳送文字"按鈕，使用port號8520，伺服端使用者要先選至少一個以上的clinet端，才能按下傳送文字按鈕，按下後，希望彈出一個UI視窗300*300讓使用者可以輸入文字，超過UI畫面時能夠捲動，輸入的文字可以自動斷行，並有一個"送出"按鈕，把文字傳送到clinet端，送到client端後，client端電腦要彈出一個UI畫面，300*300，用message的方式在clinet端電腦右下方呈現，並有一個關閉UI的按鈕，在不更換伺服端程式及clinert端程式的狀況下，請協助俢正程試，以下是伺服端程式"

1131027-需再改進

-clinet端，接收到文字，希望出現在右下

-伺服端

--把PORT常數化

--把檔案可以選擇多個接連傳輸

--除了可以傳送開、關機，還需要可以傳指令開啟程式

--把各功能拆分，如選擇clinet端、選擇資料夾、選擇檔案、

--多線程處理

--UI界面優化

--廣播用途？

--

彈出文字訊息框，使用 grid 來控制布局 

# 添加送出按鈕

send_button = tk.Button(text_window, text="送出", command=lambda: self.send_text_to_clients(text_input.get("1.0", tk.END).strip(), selected_items))

send_button.grid(row=0, column=0, padx=(10, 0), pady=10)  # 送出按鈕在左側

# 添加關閉按鈕

close_button = tk.Button(text_window, text="關閉", command=text_window.destroy)

close_button.grid(row=0, column=1, padx=(0, 10), pady=10)  # 關閉按鈕在右側

方法：使用 pack 並設置 expand 和 fill

# 創建一個框架來放置按鈕

button_frame = tk.Frame(text_window)

button_frame.pack(pady=10)

# 添加送出按鈕

send_button = tk.Button(button_frame, text="送出", command=lambda: self.send_text_to_clients(text_input.get("1.0", tk.END).strip(), selected_items))

send_button.pack(side=tk.LEFT, padx=(10, 5))  # 送出按鈕在左側

# 添加關閉按鈕

close_button = tk.Button(button_frame, text="關閉", command=text_window.destroy)

close_button.pack(side=tk.LEFT, padx=(5, 10))  # 關閉按鈕在右側

clinet端建議

這段程式碼主要實現了一個使用 UDP 通訊的客戶端，能夠發送報告、接收檔案、執行命令以及接收文字訊息。以下是幾個需要注意的地方和建議：

1. 縮排問題：

   • 在 receive_text 方法的縮排上有誤，應該將其與其他方法的定義保持一致。

2. 方法調用錯誤：

   • receive_text 方法的定義缺少 self 參數，因為它應該是 Client 類的一部分。應該改為 def receive_text(self):。

3. 套接字關閉：

   • 在 receive_file_with_progress 中創建的 subprocess，若未正確處理進程的關閉，可能會導致資源泄漏。

4. 例外處理：

   • 在多處 except 中，建議可以詳細記錄錯誤訊息，並加入特定錯誤類型的處理，以便於除錯。

5. 進程管理：

   • 在 receive_file_with_progress 中，如果 subprocess 發生錯誤，應考慮加入檢查並處理的邏輯。

6. 多執行緒安全：

   • 如果有多個執行緒同時寫入 self.client_socket，可能需要對這部分進行適當的鎖定，以避免競爭條件。

7. GUI 隱藏：

   • 使用 root.withdraw() 隱藏主視窗時，應確保有合適的方式讓用戶能夠結束程序，或顯示錯誤訊息等。

8. 可讀性：

   • 建議將較長的行拆分為多行，這樣程式碼更易於閱讀

113.11.01-定義成常數的方式

# 定義常數 

UDP_PORT_SERVER = 37020 

UDP_PORT_CLIENT = 8500 

UDP_PORT_COMMAND = 8510 

UDP_PORT_TEXT = 8520 

這兩個表達的主要區別在於變數的範圍和定義方式：

1. self.server_socket.bind(("", self.BROADCAST_PORT))：

   • 這種寫法表示 BROADCAST_PORT 是 Server 類別中的一個屬性。使用 self 來引用類別實例的屬性，通常在 __init__ 方法中定義並賦值。例如，你可能會在 __init__ 中這樣寫：self.BROADCAST_PORT = 37020。

2. self.server_socket.bind(("", BROADCAST_PORT))：

   • 這種寫法表示 BROADCAST_PORT 是一個全域變數（global variable），即在類別之外定義的變數。這意味著它不屬於 Server 類別的任何實例，而是可以在整個程式中使用。

如果 BROADCAST_PORT 不是在類別外部定義的全域變數，第二種寫法會導致錯誤。因此，具體使用哪一種方式取決於你的設計需求和變數的定義範圍。

1131002udpcast-test10y

-可運行版

-送出文字的UI，缺一個關閉的按鈕

import socket

import threading

import tkinter as tk

from tkinter import filedialog, ttk, messagebox

import time

import os

import sys

import subprocess

import psutil  # 用於獲取網路卡資訊

import csv

class Server:

    def __init__(self, root):

        self.root = root

        self.root.title("Server端 UDP派送檔案 by WCS 2024.10.01")

        self.root.geometry("800x600")

        # 創建一個 Frame 用來放置標題和 IP 顯示

        header_frame = tk.Frame(self.root)

        header_frame.pack(pady=10)

        # 新增標題 "UDP派送檔案"

        self.title_label = tk.Label(header_frame, text="UDP派送檔案", font=("Arial", 18), fg="deepskyblue")

        self.title_label.pack(side=tk.LEFT)  # 將標題放在左側

        # 取得伺服端的本地 IP

        self.server_ip = None

        #self.server_ip = self.get_local_ip()

        # 顯示伺服器 IP 的 Label

        #self.ip_label = tk.Label(header_frame, text=f"伺服器 IP: {self.server_ip}", font=("Arial", 14), fg="blue")

        #self.ip_label.pack(side=tk.LEFT, padx=(10, 0))  

        # 顯示伺服器 IP 的 Label

        self.ip_label = tk.Label(header_frame, text="伺服器 IP: 尚未選擇網路卡", font=("Arial", 14), fg="blue")

        self.ip_label.pack(side=tk.LEFT, padx=(10, 0))  # 在標題和 IP 標籤之間加點距離

        # 新增標題 "UDP派送檔案"

        self.title_label = tk.Label(self.root, text="UDP派送檔案", font=("Arial", 18), fg="deepskyblue")

        self.title_label.pack(pady=10)

        # 建立標題

        #self.label_title = tk.Label(root, text="UDP派送檔案", bg="deepskyblue", fg="white", font=("Arial", 18))

        #self.label_title.pack(fill=tk.X)

        # 網路卡下拉選單

        self.network_card_label = tk.Label(self.root, text="選擇網路卡:", font=("Arial", 12))

        self.network_card_label.pack(pady=10)

        self.network_card_var = tk.StringVar(self.root)

        self.network_card_options = self.get_network_cards()

        self.network_card_dropdown = ttk.Combobox(self.root, textvariable=self.network_card_var, values=self.network_card_options)

        self.network_card_dropdown.pack(pady=10)    

        # 在選擇網路卡時更新 IP 標籤

        self.network_card_dropdown.bind("<<ComboboxSelected>>", self.update_ip_label)

        # 建立表格

        self.tree = ttk.Treeview(root, columns=("IP", "MAC", "Name", "Status"), show='headings')

        # 設定表格標題與資料置中

        self.tree.heading("IP", text="IP 位置", anchor="center")

        self.tree.heading("MAC", text="MAC 位置", anchor="center")

        self.tree.heading("Name", text="電腦名稱", anchor="center")

        self.tree.heading("Status", text="狀態", anchor="center")

        # 設定每個欄位的資料置中

        self.tree.column("IP", anchor="center")

        self.tree.column("MAC", anchor="center")

        self.tree.column("Name", anchor="center")

        self.tree.column("Status", anchor="center")

        self.tree.pack(fill=tk.BOTH, expand=True)

        # 儲存客戶端資料的字典

        self.client_data_dict = {}

        # 創建一個 Frame 用來放置按鈕

        button_frame = tk.Frame(self.root)

        button_frame.pack(pady=10)

        # 建立廣播按鈕

        self.broadcast_button = tk.Button(button_frame, text="手動廣播伺服器", command=self.start_broadcast_manually)

        self.broadcast_button.pack(side=tk.LEFT, padx=(0, 10))  # 在按鈕之間加點距離

        # 新增「匯出客戶端資料」按鈕

        self.export_button = tk.Button(button_frame, text="匯出客戶端資料", command=self.export_client_data, fg="orange")

        self.export_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 建立傳輸檔案按鈕

        self.transfer_button = tk.Button(button_frame, text="傳送檔案", command=self.select_client_and_file, fg="darkcyan")

        self.transfer_button.pack(side=tk.LEFT, padx=5, pady=10)  # 將按鈕放在左側

        # 新增「傳送文字」按鈕

        self.send_text_button = tk.Button(button_frame, text="傳送文字", command=self.show_text_input_window, fg="darkblue")

        self.send_text_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 建立重新開機按鈕

        self.reboot_button = tk.Button(button_frame, text="重新開機", command=self.reboot_selected_clients, fg="green")

        self.reboot_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 建立關機按鈕

        self.shutdown_button = tk.Button(button_frame, text="關機", command=self.shutdown_selected_clients, fg="red")

        self.shutdown_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 新增「全選 client 端」按鈕

        self.select_all_button = tk.Button(button_frame, text="全選 client 端", command=self.select_all_clients, fg="navy")

        self.select_all_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 新增「取消全選 client 端」按鈕

        self.deselect_all_button = tk.Button(button_frame, text="取消全選 client 端", command=self.deselect_all_clients, fg="purple")

        self.deselect_all_button.pack(side=tk.LEFT, padx=5, pady=10)

        # 新增檔案傳輸狀態顯示欄位，初始化為 "等待中"

        self.status_label = tk.Label(self.root, text="目前傳輸狀態：等待中", font=("Arial", 12), fg="black")

        self.status_label.pack(pady=10)

        # 在 Server 的 __init__ 方法中，添加進度條

        self.progress_bar = ttk.Progressbar(self.root, length=400, mode='determinate')

        self.progress_bar.pack(pady=10)

        # 新增備註區域，左右兩格

        self.footer_frame = tk.Frame(self.root)

        self.footer_frame.pack(pady=20, fill=tk.X)

        # 左邊格 - 跑馬燈效果，文字顏色改為orangered

        self.marquee_text = "感謝ChatGPT    感謝UDPcast https://www.udpcast.linux.lu/index.html    "

        self.marquee_label = tk.Label(self.footer_frame, text=self.marquee_text, font=("Arial", 12), fg="orangered")

        self.marquee_label.pack(side=tk.LEFT, padx=10)

        # 右邊格 - 固定文字，文字顏色改為orangered

        self.fixed_label = tk.Label(self.footer_frame, text="製作者：WCS    日期：2024.10.01", font=("Arial", 12), fg="orangered")

        self.fixed_label.pack(side=tk.RIGHT, padx=10)

        # 啟動跑馬燈

        self.move_text()

        # 取得伺服端的本地 IP

        #self.server_ip = self.get_local_ip()

        # 取得伺服端的本地 IP

        #self.server_ip = None

        # 啟動伺服器

        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

        self.server_socket.bind(("", 37020))

        # 啟動接收客戶端報到的線程

        threading.Thread(target=self.receive_clients, daemon=True).start()

        # 啟動時廣播30秒

        threading.Thread(target=self.broadcast_for_30_seconds, daemon=True).start()

    def show_text_input_window(self):

        selected_items = self.tree.selection()

        if not selected_items:

            messagebox.showwarning("警告", "請先選擇至少一個 client 電腦")

            return

        # 建立文字輸入視窗

        text_window = tk.Toplevel(self.root)

        text_window.title("輸入要傳送的文字")

        text_window.geometry("300x300")

        # 添加滾動文字輸入框

        text_input = tk.Text(text_window, wrap="word", width=40, height=15)

        text_input.pack(fill=tk.BOTH, expand=True)

        # 添加滾動條

        scroll = tk.Scrollbar(text_window, command=text_input.yview)

        text_input.config(yscrollcommand=scroll.set)

        scroll.pack(side=tk.RIGHT, fill=tk.Y)

        # 添加送出按鈕

        send_button = tk.Button(text_window, text="送出", command=lambda: self.send_text_to_clients(text_input.get("1.0", tk.END).strip(), selected_items))

        send_button.pack(pady=10)

    #功能，遠端開、關機

    def reboot_selected_clients(self):

        self.send_command_to_selected_clients("REBOOT")

    def shutdown_selected_clients(self):

        self.send_command_to_selected_clients("SHUTDOWN")

    def send_command_to_selected_clients(self, command):

        selected_items = self.tree.selection()  # 獲取選中的客戶端

        if not selected_items:

            messagebox.showwarning("警告", "請先選擇至少一個 client 電腦")

            return

        for item in selected_items:

            client_ip = self.tree.item(item, 'values')[0]  # 獲取客戶端 IP

            self.server_socket.sendto(command.encode(), (client_ip, 8500))

            print(f"發送指令 '{command}' 至 {client_ip}")

    # 新增選擇所有客戶端的函數

    def select_all_clients(self):

        self.tree.selection_set(self.tree.get_children())  # 選擇所有項目

    # 新增取消選擇所有客戶端的函數

    def deselect_all_clients(self):

        self.tree.selection_remove(self.tree.get_children())  # 取消選擇所有項目

    def get_network_cards(self):

        # 獲取網路卡列表

        interfaces = psutil.net_if_addrs()

        return [iface for iface in interfaces.keys()]

    def update_ip_label(self, event):

        # 更新 IP Label

        self.server_ip = self.get_local_ip()

        if self.server_ip:

            self.ip_label.config(text=f"伺服器 IP: {self.server_ip}")

        else:

            self.ip_label.config(text="伺服器 IP: 無法獲取")

    def get_local_ip(self):

        selected_interface = self.network_card_var.get()

        if selected_interface:

            # 獲取該網路卡的 IP

            interfaces = psutil.net_if_addrs()

            for addr in interfaces[selected_interface]:

                if addr.family == socket.AF_INET:  # 確保是 IPv4

                    print(f"伺服端 IP: {addr.address}")

                    return addr.address

        return None

    #def get_local_ip(self):

        hostname = socket.gethostname()

        local_ip = socket.gethostbyname(hostname)

        print(f"伺服端 IP: {local_ip}")

        return local_ip

    def move_text(self):

        # 跑馬燈效果，將字串每次往左移動一個字符

        self.marquee_text = self.marquee_text[1:] + self.marquee_text[0]

        self.marquee_label.config(text=self.marquee_text)

        self.root.after(200, self.move_text)  # 每200毫秒移動一次

    def receive_clients(self):

        while True:

            try:

                data, addr = self.server_socket.recvfrom(1024)

                client_data = data.decode().split(',')

                # 確認收到的資料是否完整

                if len(client_data) == 3:

                    client_ip, client_mac, client_name = client_data

                    # 排除伺服端自己的 IP，不顯示在表格中

                    if client_ip != self.server_ip:

                        self.update_or_insert_client(client_ip, client_mac, client_name, "Online")

                else:

                    print(f"接收到不完整的資料：{client_data}")

            except Exception as e:

                print(f"接收資料時發生錯誤: {e}")

                break  # 結束迴圈或進行其他處理

    def update_or_insert_client(self, ip, mac, name, status):

        if ip in self.client_data_dict or mac in self.client_data_dict:

            # 更新該行的資料

            item_id = self.client_data_dict.get(ip) or self.client_data_dict.get(mac)

            self.tree.item(item_id, values=(ip, mac, name, status))

        else:

            # 插入新行並保存該行的 ID

            item_id = self.tree.insert("", "end", values=(ip, mac, name, status))

            self.client_data_dict[ip] = item_id

            self.client_data_dict[mac] = item_id

    def broadcast_for_30_seconds(self):

        start_time = time.time()

        while time.time() - start_time < 30:

            try:

                self.server_socket.sendto(b"Server here", ('<broadcast>', 37020))

                time.sleep(5)

            except Exception as e:

                print(f"廣播時發生錯誤: {e}")

        print("廣播已停止")

    def export_client_data(self):

        # 獲取所有客戶端資料

        client_data = []

        for item in self.tree.get_children():

            client_info = self.tree.item(item, 'values')

            client_data.append(client_info)

        # 請求儲存檔案的路徑

        file_path = filedialog.asksaveasfilename(defaultextension=".csv",

                                                filetypes=[("CSV files", "*.csv"), ("All files", "*.*")])

        if not file_path:

            return  # 如果沒有選擇檔案，則直接返回

        # 寫入檔案

        try:

            with open(file_path, 'w', newline='') as file:

                writer = csv.writer(file)

                # 寫入表頭

                writer.writerow(["IP", "MAC", "Name", "Status"])

                # 寫入資料

                writer.writerows(client_data)

            messagebox.showinfo("匯出成功", "客戶端資料已成功匯出！")

        except Exception as e:

            messagebox.showerror("錯誤", f"匯出檔案時發生錯誤: {e}")

    def start_broadcast_manually(self):

        threading.Thread(target=self.broadcast_for_30_seconds, daemon=True).start()

    def select_client_and_file(self):

        selected_items = self.tree.selection()  # 可以選取多個客戶端

        if not selected_items:

            messagebox.showwarning("警告", "請先選擇至少一個 client 電腦")

            return  # 如果沒有選擇，直接返回

        if selected_items:

            client_ips = [self.tree.item(item, 'values')[0] for item in selected_items]  # 獲取所有選中的客戶端 IP

            # 選擇檔案或資料夾

            file_paths = filedialog.askopenfilenames(title="選擇檔案")

            if file_paths:

                # 更新狀態為正在準備傳送

                self.status_label.config(text="目前傳輸狀態：正在準備傳送檔案...")

                # 傳送檔案清單給每一個選中的客戶端

                for client_ip in client_ips:

                    self.prepare_file_transfer_list(client_ip, file_paths)

    def prepare_file_transfer_list(self, client_ip, file_paths):

        transfer_list = "\n".join(file_paths)

        print(f"準備傳輸檔案到 {client_ip}:\n{transfer_list}")

        # 傳送檔案清單給 client

        threading.Thread(target=self.send_file_list, args=(client_ip, file_paths), daemon=True).start()

    def send_file_list(self, client_ip, file_paths):

        # 禁用按鈕

        self.transfer_button.config(state=tk.DISABLED)

        self.broadcast_button.config(state=tk.DISABLED)

        # 建立檔案傳輸指令

        file_list_str = ",".join(file_paths)

        try:

            for idx, file_path in enumerate(file_paths):

                self.server_socket.sendto(file_list_str.encode(), (client_ip, 8500))

                print(f"檔案傳輸清單已傳送至 {client_ip}")

                # 等待2秒後再使用 udp-sender.exe 傳送檔案

                time.sleep(2)

                # 根據選取的客戶端數量，計算 min-receivers

                selected_clients = self.tree.selection()

                client_count = len(selected_clients)

                # 檢查當前目錄中是否存在 udp-sender.exe

                if getattr(sys, 'frozen', False):

                    # 如果是打包的可執行檔

                    current_dir = os.path.dirname(sys.executable)

                else:

                    # 如果是在開發環境中

                    current_dir = os.getcwd()

                udp_sender_path = os.path.join(current_dir, "udp-sender.exe")

                # 如果當前目錄中不存在，則使用預設路徑

                if not os.path.exists(udp_sender_path):

                    udp_sender_path = r"C:\Windows\System32\udp-sender.exe"

                # 使用 udp-sender.exe 傳送檔案

                for file_path in file_paths:

                    if os.path.exists(file_path):

                        file_size = os.path.getsize(file_path)  # 取得檔案大小

                        self.status_label.config(text=f"目前傳輸檔案：{os.path.basename(file_path)}，大小：{file_size // (1024 * 1024)} MB")

                        # 開始執行 udp-sender.exe

                        command = f"udp-sender.exe --file \"{file_path}\" --port 8500 --min-receivers {client_count} --nokbd  --autostart 5"

                        subprocess.run(command, shell=True)

                        # 更新進度條

                        self.progress_bar['value'] = idx + 1                  

                        self.root.update_idletasks()  # 刷新界面

                # 設定進度條的最大值為檔案總數

                self.progress_bar['maximum'] = len(file_paths)

                # 完成傳輸，更新狀態

                self.status_label.config(text="目前傳輸狀態：傳輸完成！")

                messagebox.showinfo("傳輸完成", "檔案傳輸已完成！")  # 顯示完成傳輸的訊息

        except Exception as e:

            messagebox.showerror("錯誤", f"傳送檔案時發生錯誤: {e}")    

            print(f"傳送檔案清單時發生錯誤: {e}")

            self.status_label.config(text="傳輸失敗！")

            messagebox.showinfo("傳輸失敗！", "傳輸失敗！")  # 顯示完成失敗的訊息

        finally:

            # 無論成功或失敗，重新啟用按鈕

            self.transfer_button.config(state=tk.NORMAL)

            self.broadcast_button.config(state=tk.NORMAL)

    def send_command_to_selected_clients(self, command):

        selected_items = self.tree.selection()  # 獲取選中的客戶端

        if not selected_items:

            messagebox.showwarning("警告", "請先選擇至少一個 client 電腦")

            return

        for item in selected_items:

            client_ip = self.tree.item(item, 'values')[0]  # 獲取客戶端 IP

            self.server_socket.sendto(command.encode(), (client_ip, 8510))  # 確保埠號是 8510

            print(f"發送指令 '{command}' 至 {client_ip}")

    # 新增發送重新開機或關機指令的函數

    def send_command_to_client(self, client_ip, command):

        try:

            client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

            client_socket.sendto(command.encode(), (client_ip, 8510))  # 使用 8510 端口發送指令

            print(f"已發送指令 '{command}' 給客戶端 {client_ip}")

        except Exception as e:

            print(f"發送指令時發生錯誤: {e}")

    def send_text_to_clients(self, message, selected_items):

        if not message:

            messagebox.showwarning("警告", "文字內容不可為空")

            return

        # 發送訊息給選中的 client

        for item in selected_items:

            client_ip = self.tree.item(item, 'values')[0]

            self.server_socket.sendto(message.encode(), (client_ip, 8520))

            print(f"發送文字 '{message}' 至 {client_ip}")

        messagebox.showinfo("訊息", "文字已成功傳送")

if __name__ == "__main__":

    root = tk.Tk()

    server_app = Server(root)

    root.mainloop()

1001udp-receiver07-01-03

-可呈現文字

-可接收檔案

-缺文字顏色、大小等

import socket

import threading

import time

import uuid

import os

import sys

import subprocess

import re

import tkinter as tk

from threading import Thread

class Client:

    def __init__(self):

        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        self.client_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

        self.base_path = self.get_base_path()

    @staticmethod

    def get_mac_address():

        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff) for elements in range(0, 2*6, 2)][::-1])

        return mac

    @staticmethod

    def get_computer_name():

        return socket.gethostname()

    def send_report(self):

        while True:

            try:

                report_msg = f"{socket.gethostbyname(socket.gethostname())},{self.get_mac_address()},{self.get_computer_name()}"

                self.client_socket.sendto(report_msg.encode(), ('<broadcast>', 37020))

            except Exception as e:

                print(f"發送報到時發生錯誤: {e}")

            time.sleep(5)

    def receive_file_list(self):

        self.client_socket.bind(("", 8500))

        local_receiver_path = os.path.join(self.base_path, 'udp-receiver.exe')

        system_receiver_path = r'C:\Windows\System32\udp-receiver.exe'

        if os.path.exists(local_receiver_path):

            receiver_path = local_receiver_path

        elif os.path.exists(system_receiver_path):

            receiver_path = system_receiver_path

        else:

            print("找不到 udp-receiver.exe，請確保它在當前資料夾或 System32 中。")

            return

        while True:

            try:

                data, addr = self.client_socket.recvfrom(1024)

                file_list = data.decode().split(",")

                print(f"接收到的檔案清單: {file_list}")

                os.makedirs("received_files", exist_ok=True)

                for file_name in file_list:

                    save_path = os.path.join("received_files", os.path.basename(file_name))

                    self.receive_file_with_progress(save_path, addr[0])

            except Exception as e:

                print(f"接收檔案清單時發生錯誤: {e}")

    def receive_file_with_progress(self, save_path, server_ip):

        process = subprocess.Popen(

            ['udp-receiver.exe', '--file', save_path, '--port', '8500'],

            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, creationflags=subprocess.CREATE_NO_WINDOW

        )

        for line in process.stdout:

            print(f"接收進度: {line.strip()}")

            if re.search(r'(\d+)%', line):

                self.client_socket.sendto(line.encode(), (server_ip, 8501))

        if process.wait() == 0:

            print("檔案接收完成")

            self.client_socket.sendto("傳輸完成".encode(), (server_ip, 8501))

        else:

            print("檔案接收失敗")

            self.client_socket.sendto("傳輸失敗".encode(), (server_ip, 8501))

    def receive_commands(self):

        command_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        command_socket.bind(("", 8510))

        while True:

            data, addr = command_socket.recvfrom(1024)

            command = data.decode()

            if command == "REBOOT":

                os.system("shutdown /r /t 0")

            elif command == "SHUTDOWN":

                os.system("shutdown /s /t 0")

    @staticmethod

    def get_base_path():

        if getattr(sys, 'frozen', False):

            return sys._MEIPASS  # PyInstaller 的臨時資料夾

        else:

            return os.path.dirname(os.path.abspath(__file__))

    def receive_text(self):

        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:

            sock.bind(("", 8520))  # 使用端口 8520

            while True:

                data, addr = sock.recvfrom(1024)

                message = data.decode()

                self.show_message_window(message)

    def show_message_window(self, message):

        message_window = tk.Toplevel()

        message_window.title("來自伺服端的訊息")

        message_window.geometry("300x300")

        # 顯示訊息

        message_label = tk.Message(message_window, text=message, width=280)

        message_label.pack(fill=tk.BOTH, expand=True)

        # 關閉按鈕

        close_button = tk.Button(message_window, text="關閉", command=message_window.destroy)

        close_button.pack(pady=10)

    def start(self):

        threading.Thread(target=self.send_report, daemon=True).start()

        threading.Thread(target=self.receive_file_list, daemon=True).start()

        threading.Thread(target=self.receive_commands, daemon=True).start()

        threading.Thread(target=self.receive_text, daemon=True).start()  # 開啟接收文字的線程

        # tkinter 主循環

        root = tk.Tk()

        root.withdraw()  # 隱藏主視窗

        root.mainloop()

if __name__ == "__main__":

    client = Client()

    client.start()