修改尾数控制和状态监控逻辑

services/monitoring_service.py

@@ -7,6 +7,7 @@ from database.access_db import AccessDB
 from database.sql_server import SQLServerDB
 from config.settings import ACCESS_DB_PATH, ACCESS_DB_PASSWORD, MONITOR_INTERVAL
 from tcp.server import TCPServer
+from services.task_service import TaskService
 
 class MonitoringService:
     def __init__(self, tcp_server):
@@ -15,6 +16,7 @@ class MonitoringService:
         self.monitored_tasks = set()
         self.inserted_tasks = {}
         self.tasks_lock = threading.Lock()
+        self.task_service = TaskService(tcp_server)
 
     def monitor_access_flag_changes(self):
         """监控Access数据库中派发任务的Flag状态"""
@@ -44,8 +46,6 @@ class MonitoringService:
                 erp_ids_str = [str(erp_id) for erp_id in tasks_to_monitor]
                 deleted_from_sql_tasks = set(erp_ids_str) - existing_tasks_in_sql
 
-                print(f"SQL Server中仍存在的任务: {existing_tasks_in_sql}")
-                print(f"已从SQL Server删除的任务: {deleted_from_sql_tasks}")
 
                 # 只有已从SQL Server删除的任务才需要在Access中查找
                 if not deleted_from_sql_tasks:
@@ -75,8 +75,6 @@ class MonitoringService:
             current_flag = current_tasks.get(erp_id_str, "")
             previous_flag = self.task_flags.get(erp_id_str, "")
 
-            # 添加调试信息
-            print(f"检查任务 {erp_id} - 当前Flag: '{current_flag}', 之前Flag: '{previous_flag}'")
 
             # 如果状态发生变化
             if current_flag != previous_flag:
@@ -98,119 +96,114 @@ class MonitoringService:
     def _handle_flag_status_change(self, erp_id, current_flag, artifact_id):
         """处理标志状态变化"""
         if current_flag.endswith('d'):
-            self._handle_status_d(erp_id, artifact_id)
+            self._handle_status_d(erp_id,artifact_id)
         elif current_flag.endswith('w'):
-            self._handle_status_w(erp_id, artifact_id)
+            self._handle_status_w(erp_id,artifact_id)
         elif current_flag.endswith('n'):
-            self._handle_status_n(erp_id, artifact_id)
+            self._handle_status_n(erp_id,artifact_id)
         elif current_flag.endswith('p'):
-            self._handle_status_p(erp_id, artifact_id)
+            self._handle_status_p(erp_id,artifact_id)
         elif current_flag.endswith('x'):
-            self._handle_status_x(erp_id, artifact_id)
+            self._handle_status_x(erp_id,artifact_id)
 
-    def _handle_status_d(self, erp_id, artifact_id):
+    def _handle_status_d(self,erp_id, artifact_id):
         """处理状态'd' - 未进行生产"""
-        print(f"派发任务 ErpID {erp_id}: 未进行生产")
-        # 调用同事提供的状态更新函数
+        print(f"派发任务 artifact_id {artifact_id}: 未进行生产")
         try:
             print(1)
-            update_custom_table_status(erp_id, "未进行生产")
+            self.task_service.update_custom_table_status(artifact_id, "未进行生产")
         except Exception as e:
             print(f"更新状态时出错: {e}")
 
-        # 发送数据给TCP客户端（只发送erp_id和状态）
         try:
             status_data = {
-                "erp_id": erp_id,
-                "status": "未进行生产"
+                "erp_id":erp_id,
+                "artifact_id": artifact_id,
+                "flag": "未进行生产"
             }
             self.tcp_server.send_data(status_data)
         except Exception as e:
             print(f"发送状态数据给TCP客户端时出错: {e}")
 
-    def _handle_status_w(self, erp_id, artifact_id):
+    def _handle_status_w(self, erp_id,artifact_id):
         """处理状态'w' - 正在生产中"""
-        print(f"派发任务 ErpID {erp_id}: 正在生产中")
-        # 调用同事提供的状态更新函数
+        print(f"派发任务 artifact_id {artifact_id}: 正在生产中")
         try:
             print(2)
-            update_custom_table_status(erp_id, "正在生产中")
+            self.task_service.update_custom_table_status(artifact_id, "正在生产中")
         except Exception as e:
             print(f"更新状态时出错: {e}")
 
-        # 发送数据给TCP客户端（只发送erp_id和状态）
         try:
             status_data = {
-                "erp_id": erp_id,
-                "status": "正在生产中"
+                "erp_id":erp_id,
+                "artifact_id": artifact_id,
+                "flag": "正在生产中"
             }
             self.tcp_server.send_data(status_data)
         except Exception as e:
             print(f"发送状态数据给TCP客户端时出错: {e}")
 
-    def _handle_status_n(self, erp_id, artifact_id):
+    def _handle_status_n(self,erp_id, artifact_id):
         """处理状态'n' - 生产完毕"""
-        print(f"派发任务 ErpID {erp_id}: 生产完毕")
+        print(f"派发任务 artifact_id {artifact_id}: 生产完毕")
         # 任务完成，可以从监控列表中移除
         with self.tasks_lock:
-            self.monitored_tasks.discard(erp_id)
-        print(f"派发任务 ErpID {erp_id} 已完成，停止监控")
-        # 调用同事提供的状态更新函数
+            self.monitored_tasks.discard(artifact_id)
+        print(f"派发任务 artifact_id {artifact_id} 已完成，停止监控")
         try:
             print(3)
-            update_custom_table_status(erp_id, "生产完毕")
+            self.task_service.update_custom_table_status(artifact_id, "生产完毕")
         except Exception as e:
             print(f"更新状态时出错: {e}")
 
-        # 发送数据给TCP客户端（只发送erp_id和状态）
         try:
             status_data = {
-                "erp_id": erp_id,
-                "status": "生产完毕"
+                "erp_id":erp_id,
+                "artifact_id": artifact_id,
+                "flag": "生产完毕"
             }
             self.tcp_server.send_data(status_data)
         except Exception as e:
             print(f"发送状态数据给TCP客户端时出错: {e}")
 
-    def _handle_status_p(self, erp_id, artifact_id):
+    def _handle_status_p(self, erp_id,artifact_id):
         """处理状态'p' - 生产中断"""
-        print(f"派发任务 ErpID {erp_id}: 生产中断")
+        print(f"派发任务 ErpID {artifact_id}: 生产中断")
         # 任务中断，可以从监控列表中移除
         with self.tasks_lock:
-            self.monitored_tasks.discard(erp_id)
-        print(f"派发任务 ErpID {erp_id} 已中断，停止监控")
-        # 调用同事提供的状态更新函数
+            self.monitored_tasks.discard(artifact_id)
+        print(f"派发任务 ErpID {artifact_id} 已中断，停止监控")
         try:
             print(4)
-            update_custom_table_status(erp_id, "生产中断")
+            self.task_service.update_custom_table_status(artifact_id, "生产中断")
         except Exception as e:
             print(f"更新状态时出错: {e}")
 
-        # 发送数据给TCP客户端（只发送erp_id和状态）
         try:
             status_data = {
                 "erp_id": erp_id,
-                "status": "生产中断"
+                "artifact_id": artifact_id,
+                "flag": "生产中断"
             }
             self.tcp_server.send_data(status_data)
         except Exception as e:
             print(f"发送状态数据给TCP客户端时出错: {e}")
 
-    def _handle_status_x(self, erp_id, artifact_id):
+    def _handle_status_x(self, erp_id,artifact_id):
         """处理状态'x' - 数据已接收"""
-        print(f"派发任务 ErpID {erp_id}: 数据已接收")
-        # 调用同事提供的状态更新函数
+        print(f"派发任务 ErpID {artifact_id}: 已插入")
         try:
             print(5)
-            # update_custom_table_status(erp_id, "数据已接收")
+            self.task_service.update_custom_table_status(artifact_id, "已插入")
         except Exception as e:
             print(f"更新状态时出错: {e}")
 
-        # 发送数据给TCP客户端（只发送erp_id和状态）
         try:
             status_data = {
-                "erp_id": erp_id,
-                "status": "数据已接收"
+                "erp_id":erp_id,
+                "artifact_id": artifact_id,
+                "flag": "已插入"
             }
             self.tcp_server.send_data(status_data)
         except Exception as e:

services/task_service.py

@@ -5,14 +5,17 @@ from database.access_db import AccessDB
 from database.sql_server import SQLServerDB
 from config.settings import ACCESS_DB_PATH, ACCESS_DB_PASSWORD
 from utils.helpers import get_f_block_positions
+import threading
+import time
 
 
 class TaskService:
-    def __init__(self):
+    def __init__(self, tcp_server=None):
         self.api_client = APIClient()
         self.half_volume = [0, 0]
-        self.task_before = None
+        self.task_before = {"block_number":None, "beton_volume":None, "artifact_id":None}
         self.artifact_timestamps = {}
+        self.tcp_server = tcp_server
 
     def process_not_pour_info(self):
         """处理未浇筑信息"""
@@ -31,6 +34,11 @@ class TaskService:
         # 处理当前任务
         current_task = self._process_current_task(artifact_list[0])
 
+      # 根据F块情况处理任务
+        task_result = self._handle_tasks_by_f_blocks(
+            f_block_count, f_positions, current_task,
+            f_blocks, total_f_volume, artifact_list
+        )
         # 更新上一个任务信息
         self.task_before = {
             "beton_task_id": current_task["beton_task_id"],
@@ -38,13 +46,6 @@ class TaskService:
             "artifact_id": current_task["artifact_id"],
             "block_number": current_task["block_number"]
         }
-
-        # 根据F块情况处理任务
-        task_result = self._handle_tasks_by_f_blocks(
-            f_block_count, f_positions, current_task,
-            f_blocks, total_f_volume, artifact_list
-        )
-
         return task_result
 
     def _process_f_blocks(self, artifact_list):
@@ -98,41 +99,49 @@ class TaskService:
 
     def _handle_multiple_f_blocks(self, current_task, total_f_volume, artifact_list):
         """处理多个F块的情况"""
-        adjusted_volume = total_f_volume - self.half_volume[0]
+        if self.task_before.get("block_number") == "F":
+            print("报警:,超出正常补块逻辑")
+        else:
+            adjusted_volume = total_f_volume - self.half_volume[0]
 
-        tasks = [{
-            "beton_task_id": current_task["beton_task_id"],
-            "beton_volume": adjusted_volume,
-            "artifact_id": current_task["artifact_id"],
-            "block_number": current_task["block_number"],
-        }]
+            tasks = [{
+                "beton_task_id": current_task["beton_task_id"],
+                "beton_volume": adjusted_volume,
+                "artifact_id": current_task["artifact_id"],
+                "block_number": current_task["block_number"],
+            }]
 
-        send_list = [{
-            "beton_task_id": current_task["beton_task_id"],
-            "beton_volume": adjusted_volume,
-            "artifact_id": current_task["artifact_id"],
-            "block_number": current_task["block_number"],
-            "beton_grade": current_task["task_data"]["BetonGrade"],
-            "mix_id": current_task["task_data"]["MixID"],
-            "time": self.artifact_timestamps.get(current_task["artifact_id"], datetime.now())
-        }]
+            send_list = [{
+                "beton_task_id": current_task["beton_task_id"],
+                "beton_volume": adjusted_volume,
+                "artifact_id": current_task["artifact_id"],
+                "block_number": current_task["block_number"],
+                "beton_grade": current_task["task_data"]["BetonGrade"],
+                "mix_id": current_task["task_data"]["MixID"],
+                "time": self.artifact_timestamps.get(current_task["artifact_id"], datetime.now())
+            }]
 
-        # 处理后续任务
-        self._append_additional_tasks(send_list, artifact_list, [0, 0])
+            # 处理后续任务
+            self._append_additional_tasks(send_list, artifact_list, [0, 0])
 
-        # 更新时间戳
-        self._update_artifact_timestamps(send_list)
+            # 更新时间戳
+            self._update_artifact_timestamps(send_list)
 
-        return tasks, artifact_list, send_list, self.half_volume
+            return tasks, artifact_list, send_list, self.half_volume
 
     def _handle_two_f_blocks(self, f_positions, current_task, total_f_volume, artifact_list):
         """处理两个F块的情况"""
         if f_positions == [0, 1] and self.task_before.get("block_number") == "F":
             adjusted_volume = 0
             block_number = "补方"
-        else:
+        elif f_positions == [1, 2]:
+            adjusted_volume = artifact_list[0]["BetonVolume"]
+            block_number = current_task["block_number"]
+        elif f_positions == [0, 1] and self.task_before.get("block_number") != "F":
             adjusted_volume = total_f_volume - self.half_volume[0]
             block_number = current_task["block_number"]
+        else:
+            print("报警")
 
         tasks = [{
             "beton_task_id": current_task["beton_task_id"],
@@ -153,9 +162,7 @@ class TaskService:
 
         # 处理后续任务
         volumes = [adjusted_volume,
-                   artifact_list[2]["BetonVolume"] if len(artifact_list) > 2 else 0] if f_positions == [0,
-                                                                                                        1] and self.task_before.get(
-            "block_number") == "F" else [0, 0]
+                   artifact_list[2]["BetonVolume"] if len(artifact_list) > 2 else 0] if f_positions == [0, 1] and self.task_before.get("block_number") == "F" else [0, 0]
         self._append_additional_tasks(send_list, artifact_list, volumes)
 
         # 更新时间戳
@@ -305,7 +312,7 @@ class TaskService:
     def insert_into_produce_table(self, connection, task_info, beton_volume, erp_id, artifact_id, status):
         """插入数据到Produce表"""
         sql_db = SQLServerDB()
-        if status == "1":
+        if status == 1:
             # 准备插入数据
             insert_data = {
                 "ErpID": erp_id,
@@ -331,14 +338,14 @@ class TaskService:
             try:
                 # 假设同事提供的函数名为 save_to_custom_table
                 # 参数包括: MISID(即erp_id), Flag, TaskID, ProduceMixID, ProjectName, BetonGrade, 调整后的方量
-                save_to_custom_table(
+                self.save_to_custom_table(
                     misid=erp_id,
-                    flag="1",  # 初始Flag值
+                    flag="已插入",  # 初始Flag值
                     task_id=task_info["TaskID"],
                     produce_mix_id=task_info["ProduceMixID"],
                     project_name=task_info["ProjectName"],
                     beton_grade=task_info["BetonGrade"],
-                    adjusted_volume=beton_volume,
+                    adjusted_volume=round(beton_volume,2),
                     artifact_id=artifact_id
                     # 已经调整后的方量
                 )
@@ -346,21 +353,49 @@ class TaskService:
             except Exception as e:
                 print(f"调用保存函数时出错: {e}")
 
+            # 发送数据给TCP客户端
+            if self.tcp_server:
+                try:
+                    time.sleep(2)
+                    task_data = {
+                        "erp_id": erp_id,  # 车号，相当于序号
+                        "task_id": task_info["TaskID"],  # 任务单号
+                        "artifact_id": artifact_id,
+                        "produce_mix_id": task_info["ProduceMixID"],  # 配比号
+                        "project_name": task_info["ProjectName"],  # 任务名
+                        "beton_grade": task_info["BetonGrade"],  # 砼强度
+                        "adjusted_volume": round(beton_volume,2),  # 方量
+                        "flag": "已插入",  # 状态
+                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")  # 时间
+                    }
+                    self.tcp_server.send_data(task_data)
+                    print(f"任务 {artifact_id} 的数据已发送给TCP客户端")
+                except Exception as e:
+                    print(f"发送数据给TCP客户端时出错: {e}")
+
             return erp_id
         else:
             try:
-                # 假设同事提供的函数名为 save_to_custom_table
                 # 参数包括: MISID(即erp_id), Flag, TaskID, ProduceMixID, ProjectName, BetonGrade, 调整后的方量
-                save_to_custom_table(
+                self.save_to_custom_table(
                     misid=erp_id,
-                    flag="1",  # 初始Flag值
+                    flag="已插入",  # 初始Flag值
                     task_id=task_info["TaskID"],
                     produce_mix_id=task_info["ProduceMixID"],
                     project_name=task_info["ProjectName"],
                     beton_grade=task_info["BetonGrade"],
-                    adjusted_volume=beton_volume,
+                    adjusted_volume=round(beton_volume,2),
                     artifact_id=artifact_id
                 )
                 print(f"任务 {erp_id} 的数据已保存到自定义数据表")
             except Exception as e:
                 print(f"调用保存函数时出错: {e}")
+
+
+            return erp_id
+
+    def save_to_custom_table(self,misid, flag, task_id, produce_mix_id, project_name, beton_grade, adjusted_volume, artifact_id):
+        print(f"保存到自定义数据表: MISID={misid}, Flag={flag}, TaskID={task_id}, 调整后方量={adjusted_volume}")
+
+    def update_custom_table_status(self, erp_id, status):
+        print(f"更新自定义数据表状态: ERP ID={erp_id}, 状态={status}")