修改模块名字

jikimo_workorder_exception/controllers/main.py

@@ -43,7 +43,7 @@ class WorkorderExceptionConroller(http.Controller):
             })
  
         except Exception as e:
-            res = {'Succeed': False, 'ErrorCode': 202, 'Error': e}
+            res = {'Succeed': False, 'ErrorCode': 202, 'Error': str(e)}
             _logger.info('workder_exception error:%s' % e)
         return json.JSONEncoder().encode(res)
 

sf_bf_connect/models/process_status.py

@@ -36,6 +36,7 @@ class StatusChange(models.Model):
         # 使用super()来调用原始方法（在本例中为'sale.order'模型的'action_confirm'方法）
         try:
             res = super(StatusChange, self).action_confirm()
+            logging.info('原生方法返回结果:%s' % res)
             # 原有方法执行后，进行额外的操作（如调用外部API）
             process_start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
             config = self.env['res.config.settings'].get_values()
@@ -61,6 +62,7 @@ class StatusChange(models.Model):
             traceback_error = traceback.format_exc()
             logging.error("工厂加工同步订单状态失败:%s " % traceback_error)
             raise UserError(e)
+        logging.info('最终返回值:%s' % res)
         return res
 
     def action_cancel(self):

sf_message/models/sf_message_sale.py

@@ -39,6 +39,7 @@ class SFMessageSale(models.Model):
                             purchase_order_info.add_queue('坯料采购提醒')
             except Exception as e:
                 logging.info('add_queue error:%s' % e)
+        logging.info('action_confirm res:%s' % res)
         return res
 
     # 继承并重写jikimo.message.dispatch的_get_message()

sf_message/security/ir.model.access.csv

@@ -5,24 +5,28 @@ access_jikimo_message_template_group_purchase,jikimo_message_template,jikimo_mes
 access_jikimo_message_template_group_sf_stock_user,jikimo_message_template,jikimo_message_notify.model_jikimo_message_template,sf_base.group_sf_stock_user,1,1,1,0
 access_jikimo_message_template_group_sf_order_user,jikimo_message_template,jikimo_message_notify.model_jikimo_message_template,sf_base.group_sf_order_user,1,1,1,0
 access_jikimo_message_template_group_sf_tool_user,jikimo_message_template,jikimo_message_notify.model_jikimo_message_template,sf_base.group_sf_tool_user,1,1,1,0
+access_jikimo_message_template_group_purchase_director,jikimo_message_template,jikimo_message_notify.model_jikimo_message_template,sf_base.group_purchase_director,1,1,1,0
 
 access_jikimo_message_bussiness_node_group_sale_salemanager,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_sale_salemanager,1,1,1,0
 access_jikimo_message_bussiness_node_group_purchase,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_purchase,1,1,1,0
 access_jikimo_message_bussiness_node_group_sf_stock_user,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_sf_stock_user,1,1,1,0
 access_jikimo_message_bussiness_node_group_sf_order_user,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_sf_order_user,1,1,1,0
 access_jikimo_message_bussiness_node_group_sf_tool_user,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_sf_tool_user,1,1,1,0
+access_jikimo_message_bussiness_node_group_purchase_director,jikimo_message_bussiness_node,jikimo_message_notify.model_jikimo_message_bussiness_node,sf_base.group_purchase_director,1,1,1,0
 
 access_jikimo_message_queue_group_sale_salemanager,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_sale_salemanager,1,1,1,0
 access_jikimo_message_queue_group_purchase,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_purchase,1,1,1,0
 access_jikimo_message_queue_group_sf_stock_user,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_sf_stock_user,1,1,1,0
 access_jikimo_message_queue_group_sf_order_user,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_sf_order_user,1,1,1,0
 access_jikimo_message_queue_group_sf_tool_user,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_sf_tool_user,1,1,1,0
+access_jikimo_message_queue_group_purchase_director,jikimo_message_queue,jikimo_message_notify.model_jikimo_message_queue,sf_base.group_purchase_director,1,1,1,0
 
 access_jikimo_message_reminder_time_group_sale_salemanager,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_sale_salemanager,1,1,1,0
 access_jikimo_message_reminder_time_group_purchase,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_purchase,1,1,1,0
 access_jikimo_message_reminder_time_group_sf_stock_user,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_sf_stock_user,1,1,1,0
 access_jikimo_message_reminder_time_group_sf_order_user,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_sf_order_user,1,1,1,0
 access_jikimo_message_reminder_time_group_sf_tool_user,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_sf_tool_user,1,1,1,0
+access_jikimo_message_reminder_time_group_purchase_director,jikimo_message_reminder_time,jikimo_message_notify.model_jikimo_message_reminder_time,sf_base.group_purchase_director,1,1,1,0
 
 
 

sf_plan/models/custom_plan.py

@@ -219,7 +219,7 @@ class sf_production_plan(models.Model):
 
         return num
 
-    def do_production_schedule(self, count=1):
+    def do_production_schedule(self):
         """
         排程方法
         """
@@ -227,48 +227,46 @@ class sf_production_plan(models.Model):
             if not record.production_line_id:
                 raise ValidationError("未选择生产线")
             else:
-                is_schedule = self.deal_processing_schedule(record.date_planned_start, count)
-                if not is_schedule:
-                    raise ValidationError("排程失败")
-                workorder_id_list = record.production_id.workorder_ids.ids
-                if record.production_id:
-                    if record.production_id.workorder_ids:
-                        for item in record.production_id.workorder_ids:
-                            if item.name == 'CNC加工':
-                                item.date_planned_finished = datetime.now() + timedelta(days=100)
-                                item.date_planned_start = self.date_planned_start if self.date_planned_start else datetime.now()
-                                record.sudo().production_id.plan_start_processing_time = item.date_planned_start
-                                item.date_planned_finished = item.date_planned_start + timedelta(
-                                    minutes=record.env['mrp.routing.workcenter'].sudo().search(
-                                        [('name', '=', 'CNC加工')]).time_cycle)
-                                item.duration_expected = record.env['mrp.routing.workcenter'].sudo().search(
-                                    [('name', '=', 'CNC加工')]).time_cycle
-                                record.calculate_plan_time_before(item, workorder_id_list)
-                                record.calculate_plan_time_after(item, workorder_id_list)
-                                record.date_planned_start, record.date_planned_finished = \
-                                    item.date_planned_start, item.date_planned_finished
-                    record.state = 'done'
-                    record.date_planned_finished = record.date_planned_start + timedelta(
-                        minutes=60) if not record.date_planned_finished else record.date_planned_finished
-                    # record.production_id.schedule_state = '已排'
-                    record.sudo().production_id.schedule_state = '已排'
-                    record.sudo().production_id.process_state = '待装夹'
-                    # self.env['sale.order'].browse(record.production_id.origin).schedule_status = 'to process'
-                    # sale_obj = self.env['sale.order'].search([('name', '=', record.origin)])
-                    # if 'S' in sale_obj.name:
-                    #     sale_obj.schedule_status = 'to process'
-                    mrp_production_ids = record.production_id._get_children().ids
-                    print('mrp_production_ids', mrp_production_ids)
-                    for i in mrp_production_ids:
-                        record.env['mrp.production'].sudo().browse(i).schedule_state = '已排'
-                    # record.production_id.date_planned_start = record.date_planned_start
-                    # record.production_id.date_planned_finished = record.date_planned_finished
-                    record.sudo().production_id.production_line_id = record.production_line_id.id
-                    if record.production_id.workorder_ids:
-                        record.sudo().production_id.workorder_ids.filtered(
-                            lambda b: b.routing_type == "装夹预调").workpiece_delivery_ids.write(
-                            {'production_line_id': record.production_line_id.id,
-                             'plan_start_processing_time': record.date_planned_start})
+                if record.production_id.workorder_ids:
+                    last_cnc_start = record.date_planned_start if record.date_planned_start else datetime.now()
+                    for item in record.production_id.workorder_ids:
+                        if item.name == 'CNC加工':
+                            # 将同一个面的所有工单筛选出来
+                            workorder_list = record.production_id.workorder_ids.filtered(lambda x: x.processing_panel == item.processing_panel)
+                            routing_workcenter = record.env['mrp.routing.workcenter'].sudo().search(
+                                [('name', '=', 'CNC加工')], limit=1)
+                            # 设置一个小的开始时间
+                            item.date_planned_start = datetime.now() - timedelta(days=100)
+                            item.date_planned_finished = last_cnc_start + timedelta(
+                                minutes=routing_workcenter.time_cycle)
+                            item.date_planned_start = last_cnc_start
+                            record.sudo().production_id.plan_start_processing_time = item.date_planned_start
+                            item.duration_expected = routing_workcenter.time_cycle
+                            pre_duration , next_duration = record.calculate_plan_time(item, workorder_list)
+                            record.date_planned_finished = item.date_planned_finished
+                            # 计算下一个cnc工单的开始时间
+                            last_cnc_start = workorder_list[-1].date_planned_finished + timedelta(minutes=pre_duration)
+                    # 没有工单也能排程
+                record.state = 'done'
+                # record.production_id.schedule_state = '已排'
+                record.sudo().production_id.schedule_state = '已排'
+                record.sudo().production_id.process_state = '待装夹'
+                # self.env['sale.order'].browse(record.production_id.origin).schedule_status = 'to process'
+                # sale_obj = self.env['sale.order'].search([('name', '=', record.origin)])
+                # if 'S' in sale_obj.name:
+                #     sale_obj.schedule_status = 'to process'
+                mrp_production_ids = record.production_id._get_children().ids
+                print('mrp_production_ids', mrp_production_ids)
+                for i in mrp_production_ids:
+                    record.env['mrp.production'].sudo().browse(i).schedule_state = '已排'
+                # record.production_id.date_planned_start = record.date_planned_start
+                # record.production_id.date_planned_finished = record.date_planned_finished
+                record.sudo().production_id.production_line_id = record.production_line_id.id
+                if record.production_id.workorder_ids:
+                    record.sudo().production_id.workorder_ids.filtered(
+                        lambda b: b.routing_type == "装夹预调").workpiece_delivery_ids.write(
+                        {'production_line_id': record.production_line_id.id,
+                            'plan_start_processing_time': record.date_planned_start})
 
                     # record.date_planned_finished = record.date_planned_start + timedelta(days=3)
                     # record.state = 'done'
@@ -282,54 +280,66 @@ class sf_production_plan(models.Model):
         }
 
     # 处理是否可排程
-    def deal_processing_schedule(self, date_planned_start, count):
-        for record in self:
-            workcenter_ids = record.production_line_id.mrp_workcenter_ids
-            if not workcenter_ids:
-                raise UserError('生产线没有配置工作中心')
-            production_lines = workcenter_ids.filtered(lambda b: "自动生产线" in b.name)
-            if not production_lines:  # 判断是否配置了自动生产线
-                raise UserError('生产线没有配置自动生产线')
-            if date_planned_start < datetime.now():  # 判断计划开始时间是否小于当前时间
-                raise UserError('计划开始时间不能小于当前时间')
-            if all(not production_line.deal_with_workcenter_calendar(date_planned_start) for production_line in
-                   production_lines):  # 判断计划开始时间是否在配置的工作中心的工作日历内
-                raise UserError('当前计划开始时间不能预约排程，请在工作时间内排程')
-            if not production_lines.deal_available_default_capacity(date_planned_start):  # 判断生产线是否可排程
-                raise UserError('当前计划开始时间不能预约排程,生产线今日没有可排程的资源')
-            if not production_lines.deal_available_single_machine_capacity(date_planned_start, count):  # 判断生产线是否可排程
-                raise UserError('当前计划开始时间不能预约排程,生产线该时间段没有可排程的资源')
+    def deal_processing_schedule(self, date_planned_start,):
+        count = len(self)
+        workcenter_ids = self.production_line_id.mrp_workcenter_ids
+        if not workcenter_ids:
+            raise UserError('生产线没有配置工作中心')
+        production_lines = workcenter_ids.filtered(lambda b: "自动生产线" in b.name)
+        if not production_lines:  # 判断是否配置了自动生产线
+            raise UserError('生产线没有配置自动生产线')
+        if date_planned_start < datetime.now():  # 判断计划开始时间是否小于当前时间
+            raise UserError('计划开始时间不能小于当前时间')
+        if all(not production_line.deal_with_workcenter_calendar(date_planned_start) for production_line in
+                production_lines):  # 判断计划开始时间是否在配置的工作中心的工作日历内
+            raise UserError('当前计划开始时间不能预约排程，请在工作时间内排程')
+        if not production_lines.deal_available_default_capacity(date_planned_start):  # 判断生产线是否可排程
+            raise UserError('当前计划开始时间不能预约排程,生产线今日没有可排程的资源')
+        if not production_lines.deal_available_single_machine_capacity(date_planned_start, count):  # 判断生产线是否可排程
+            raise UserError('当前计划开始时间不能预约排程,生产线该时间段没有可排程的资源')
         return True
 
-    def calculate_plan_time_before(self, item, workorder_id_list):
+    def calculate_plan_time(self, item, workorder_list):
         """
         根据CNC工单的时间去计算之前的其他工单的开始结束时间
         """
-        sequence = workorder_id_list.index(item.id) - 1
-        # 计算CNC加工之前工单的开始结束时间
-        for i in range(1 if sequence == 0 else sequence):
-            current_workorder_id = (item.id - (i + 1))
-            current_workorder_obj = self.env['mrp.workorder'].sudo().search(
-                [('id', '=', current_workorder_id)])
-            old_workorder_obj = self.env['mrp.workorder'].sudo().search(
-                [('id', '=', (current_workorder_id + 1))])
-            work_order = self.env['mrp.workorder'].sudo().search(
-                [('production_id', '=', self.production_id.id), ('id', '=', current_workorder_id)])
-            work_order.date_planned_finished = datetime.now() + timedelta(days=100)
-            work_order.date_planned_start = old_workorder_obj.date_planned_start - timedelta(
-                minutes=self.env['mrp.routing.workcenter'].sudo().search(
-                    [('name', '=', current_workorder_obj.name)]).time_cycle)
-            work_order.date_planned_finished = old_workorder_obj.date_planned_start
-            work_order.duration_expected = self.env['mrp.routing.workcenter'].sudo().search(
-                [('name', '=', current_workorder_obj.name)]).time_cycle
-        first_workorder = self.env['mrp.workorder'].sudo().search([('id', '=', workorder_id_list[0])])
-        second_workorder = self.env['mrp.workorder'].sudo().search([('id', '=', workorder_id_list[1])])
-        if second_workorder.date_planned_start < first_workorder.date_planned_finished:
-            item.date_planned_start += timedelta(minutes=60)
-            item.date_planned_finished += timedelta(minutes=60)
-            item.duration_expected = self.env['mrp.routing.workcenter'].sudo().search(
-                [('name', '=', 'CNC加工')]).time_cycle
-            self.calculate_plan_time_before(item, workorder_id_list)
+        item_position = 0
+        for index, workorder in enumerate(workorder_list):
+            if workorder.id == item.id:
+                item_position = index
+                break
+        routing_workcenters = self.env['mrp.routing.workcenter'].sudo().search([])
+        # 记录所有前序工序时长
+        previous_workorder_duration = 0
+        for i in range(item_position, -1, -1):
+            if i < 1:
+                break
+            current_workorder = workorder_list[i]
+            next_workorder = workorder_list[i - 1]
+            routing_workcenter = routing_workcenters.filtered(lambda x: x.name == next_workorder.name)[0]
+            # 设置一个小的开始时间
+            next_workorder.date_planned_start = datetime.now() - timedelta(days=100)
+            next_workorder.date_planned_finished = current_workorder.date_planned_start
+            next_workorder.date_planned_start = next_workorder.date_planned_finished - timedelta(
+                minutes=routing_workcenter.time_cycle)
+            next_workorder.duration_expected = routing_workcenter.time_cycle
+            previous_workorder_duration += routing_workcenter.time_cycle
+        # 记录所有后续工序时长
+        next_workorder_duration = 0
+        for i in range(item_position, len(workorder_list) - 1):
+            if i > len(workorder_list) - 1:
+                break
+            current_workorder = workorder_list[i]   
+            next_workorder = workorder_list[i + 1]
+            routing_workcenter = routing_workcenters.filtered(lambda x: x.name == next_workorder.name)[0]
+            # 设置一个小的开始时间
+            next_workorder.date_planned_start = datetime.now() - timedelta(days=100)
+            next_workorder.date_planned_finished = current_workorder.date_planned_finished + timedelta(
+                minutes=routing_workcenter.time_cycle)
+            next_workorder.date_planned_start = current_workorder.date_planned_finished
+            next_workorder.duration_expected = routing_workcenter.time_cycle
+            next_workorder_duration += routing_workcenter.time_cycle
+        return previous_workorder_duration, next_workorder_duration
 
     def calculate_plan_time_after(self, item, workorder_id_list):
         """

sf_plan/wizard/action_plan_some.py

@@ -31,46 +31,10 @@ class Action_Plan_All_Wizard(models.TransientModel):
     # 确认排程按钮
     def action_plan_all(self):
         # 使用传递过来的计划ID
-        temp_plan_ids = self.plan_ids
+        self.plan_ids.production_line_id = self.production_line_id.id
+        self.plan_ids.date_planned_start = self.date_planned_start
         # 在这里添加您的逻辑来处理这些ID
-        count = len(temp_plan_ids) + 1
-        for plan in temp_plan_ids:
-            count = count - 1
-            # 处理每个计划
-            # 比如更新计划状态、分配资源等
-            # 示例：plan.state = 'scheduled'
-            print('处理计划:', plan.id)
-            # 拿到计划对象
-            plan_obj = self.env['sf.production.plan'].browse(plan.id)
-            plan_obj.production_line_id = self.production_line_id.id
-            plan.date_planned_start = self.date_planned_start
-            plan_obj.do_production_schedule(count)
-            # plan_obj.state = 'done'
-            print('处理计划:', plan.id, '完成')
-
-        # # 获取当前生产线
-        # production_line_id = self.production_line_id
-        # # 获取当前生产线的所有生产订单
-        # production_order_ids = self.env['mrp.production'].search([('production_line_id', '=', production_line_id.id)])
-        # # 获取当前生产线的所有生产订单的id
-        # production_order_id_list = []
-        # for production_order_id in production_order_ids:
-        #     production_order_id_list.append(production_order_id.id)
-        # # 获取当前生产线的所有生产订单的排程状态
-        # production_order_plan_state_list = []
-        # for production_order_id in production_order_ids:
-        #     production_order_plan_state_list.append(production_order_id.plan_state)
-        # # 如果当前生产线的所有生产订单的排程状态都是已排程，则报错
-        # if all(production_order_plan_state == '已排程' for production_order_plan_state in production_order_plan_state_list):
-        #     raise UserError('当前生产线的所有生产订单都已排程，请勿重复排程！')
-        # # 如果当前生产线的所有生产订单的排程状态都是未排程，则报错
-        # if all(production_order_plan_state == '未排程' for production_order_plan_state in production_order_plan_state_list):
-        #     raise UserError('当前生产线的所有生产订单都未排程，请先排程！')
-        # # 如果当前生产线的所有生产订单的排程状态都是已完成，则报错
-        # if all(production_order_plan_state == '已完成' for production_order_plan_state in production_order_plan_state_list):
-        #     raise UserError('当前生产线的所有生产订单都已完成，请勿重复排程！')
-        # # 如果当前生产线的所有生产订单的排程状态都是已取消，则报错
-        # if all(production_order_plan_state == '已取消' for production_order_plan_state in production_order_plan_state_list):
-        #     raise UserError('当前生产线的所有生产订单都已取消，请勿重复排程！')
-        # # 如果当前生产线的所有生产订单的排程状态都是已暂停，则报错
-        # if all(production_order_plan_state == '已暂停' for production_order_plan_state in production
+        # 判断能否排成
+        self.plan_ids.deal_processing_schedule(self.date_planned_start)
+        self.plan_ids.do_production_schedule()
+        _logger.info('处理计划: %s 完成', self.plan_ids.ids)

sf_stock/__manifest__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 {
-    'name': "sf_stock",
+    'name': "机企猫 库存/代发货",
 
     'summary': """
         处理仓库 -代发货业务""",