Merge branch refs/heads/develop into refs/heads/hotfix/功能刀具出入库处理

sf_tool_management/models/base.py

@@ -181,6 +181,7 @@ class MachineTableToolChangingApply(models.Model):
 
 class CAMWorkOrderProgramKnifePlan(models.Model):
     _name = 'sf.cam.work.order.program.knife.plan'
+    _inherit = ['mail.thread']
     _description = 'CAM工单程序用刀计划'
 
     name = fields.Char('工单任务编号')
@@ -228,7 +229,7 @@ class CAMWorkOrderProgramKnifePlan(models.Model):
     estimated_processing_time = fields.Char('预计加工时间')
 
     plan_execute_status = fields.Selection([('0', '待下发'), ('1', '执行中'), ('2', '已完成')],
-                                           string='计划执行状态', default='0', readonly=False)
+                                           string='计划执行状态', default='0', readonly=False, tracking=True)
 
     sf_functional_tool_assembly_id = fields.Many2one('sf.functional.tool.assembly', '功能刀具组装', readonly=True)
 
@@ -282,7 +283,8 @@ class CAMWorkOrderProgramKnifePlan(models.Model):
 
             'loading_task_source': '0',
             'applicant': self.env.user.name,
-            'use_tool_time': self.need_knife_time,
+            'use_tool_time': fields.Datetime.now() + timedelta(
+                hours=4) if not self.need_knife_time else self.need_knife_time,
             'reason_for_applying': '工单用刀',
 
             'sf_cam_work_order_program_knife_plan_id': self.id
@@ -362,6 +364,7 @@ class CAMWorkOrderProgramKnifePlan(models.Model):
 
 class FunctionalToolAssembly(models.Model):
     _name = 'sf.functional.tool.assembly'
+    _inherit = ['mail.thread']
     _description = '功能刀具组装'
     _order = 'assemble_status, use_tool_time asc'
 
@@ -396,7 +399,7 @@ class FunctionalToolAssembly(models.Model):
     applicant = fields.Char(string='申请人', readonly=True)
     apply_time = fields.Datetime(string='申请时间', default=fields.Datetime.now(), readonly=True)
     assemble_status = fields.Selection([('0', '待组装'), ('1', '已组装')], string='组装状态', default='0',
-                                       readonly=True)
+                                       tracking=True, readonly=True)
     cutter_spacing_code_id = fields.Many2one('maintenance.equipment.tool', string='刀位号', readonly=True)
     whether_standard_knife = fields.Boolean(string='是否标准刀', default=True, readonly=True)
     reason_for_applying = fields.Char(string='申请原因', readonly=True)
@@ -413,8 +416,9 @@ class FunctionalToolAssembly(models.Model):
         return categories.browse(functional_tool_type_ids)
 
     # 刀具物料信息
-    # ==============整体式刀具型号============
-    integral_freight_barcode = fields.Char('整体式刀具货位')
+    # ==============整体式刀具型号=============
+    integral_freight_barcode_id = fields.Many2one('sf.shelf.location', string='整体式刀具货位')
+    integral_lot_id = fields.Many2one('stock.lot', string='整体式刀具批次')
     integral_product_id = fields.Many2one('product.product', string='整体式刀具名称',
                                           compute='_compute_integral_product_id', store=True)
     cutting_tool_integral_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='整体式刀具型号',
@@ -424,19 +428,15 @@ class FunctionalToolAssembly(models.Model):
     sf_tool_brand_id_1 = fields.Many2one('sf.machine.brand', string='整体式刀具品牌',
                                          related='integral_product_id.brand_id')
 
-    @api.depends('integral_freight_barcode')
+    @api.depends('integral_lot_id')
     def _compute_integral_product_id(self):
         for item in self:
-            if item.integral_freight_barcode:
-                location = self.env['sf.shelf.location'].sudo().search(
-                    [('barcode', '=', item.integral_freight_barcode)])
-                if location:
-                    item.integral_product_id = location.product_id.id
-                else:
-                    item.integral_product_id = False
+            if item.integral_lot_id:
+                item.integral_product_id = item.integral_lot_id.product_id.id
 
     # =================刀片型号=============
-    blade_freight_barcode = fields.Char('刀片货位')
+    blade_freight_barcode_id = fields.Many2one('sf.shelf.location', string='刀片货位')
+    blade_lot_id = fields.Many2one('stock.lot', string='刀片批次')
     blade_product_id = fields.Many2one('product.product', string='刀片名称', compute='_compute_blade_product_id',
                                        store=True)
     cutting_tool_blade_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀片型号',
@@ -445,18 +445,15 @@ class FunctionalToolAssembly(models.Model):
                                              related='blade_product_id.specification_id')
     sf_tool_brand_id_2 = fields.Many2one('sf.machine.brand', '刀片品牌', related='blade_product_id.brand_id')
 
-    @api.depends('blade_freight_barcode')
+    @api.depends('blade_lot_id')
     def _compute_blade_product_id(self):
         for item in self:
-            if item.blade_freight_barcode:
-                location = self.env['sf.shelf.location'].sudo().search([('barcode', '=', item.blade_freight_barcode)])
-                if location:
-                    item.blade_product_id = location.product_id.id
-                else:
-                    item.blade_product_id = False
+            if item.blade_lot_id:
+                item.blade_product_id = item.blade_lot_id.product_id.id
 
     # ==============刀杆型号================
-    bar_freight_barcode = fields.Char('刀杆货位')
+    bar_freight_barcode_id = fields.Many2one('sf.shelf.location', string='刀杆货位')
+    bar_lot_id = fields.Many2one('stock.lot', string='刀杆批次')
     bar_product_id = fields.Many2one('product.product', string='刀杆名称', compute='_compute_bar_product_id',
                                      store=True)
     cutting_tool_cutterbar_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀杆型号',
@@ -465,18 +462,15 @@ class FunctionalToolAssembly(models.Model):
                                            related='bar_product_id.specification_id')
     sf_tool_brand_id_3 = fields.Many2one('sf.machine.brand', '刀杆品牌', related='bar_product_id.brand_id')
 
-    @api.depends('bar_freight_barcode')
+    @api.depends('bar_lot_id')
     def _compute_bar_product_id(self):
         for item in self:
-            if item.bar_freight_barcode:
-                location = self.env['sf.shelf.location'].sudo().search([('barcode', '=', item.bar_freight_barcode)])
-                if location:
-                    item.bar_product_id = location.product_id.id
-                else:
-                    item.bar_product_id = False
+            if item.bar_lot_id:
+                item.bar_product_id = item.bar_lot_id.product_id.id
 
     # =============刀盘型号================
-    pad_freight_barcode = fields.Char('刀盘货位')
+    pad_freight_barcode_id = fields.Many2one('sf.shelf.location', string='刀盘货位')
+    pad_lot_id = fields.Many2one('stock.lot', string='刀盘批次')
     pad_product_id = fields.Many2one('product.product', string='刀盘名称', compute='_compute_pad_product_id',
                                      store=True)
     cutting_tool_cutterpad_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀盘型号',
@@ -485,15 +479,11 @@ class FunctionalToolAssembly(models.Model):
                                            related='pad_product_id.specification_id')
     sf_tool_brand_id_4 = fields.Many2one('sf.machine.brand', '刀盘品牌', related='pad_product_id.brand_id')
 
-    @api.depends('pad_freight_barcode')
+    @api.depends('pad_lot_id')
     def _compute_pad_product_id(self):
         for item in self:
-            if item.pad_freight_barcode:
-                location = self.env['sf.shelf.location'].sudo().search([('barcode', '=', item.pad_freight_barcode)])
-                if location:
-                    item.pad_product_id = location.product_id.id
-                else:
-                    item.pad_product_id = False
+            if item.pad_lot_id:
+                item.pad_product_id = item.pad_lot_id.product_id.id
 
     # ==============刀柄型号==============
     handle_freight_rfid = fields.Char('刀柄Rfid', compute='_compute_handle_product_id', store=True)
@@ -517,7 +507,8 @@ class FunctionalToolAssembly(models.Model):
                 item.handle_freight_rfid = False
 
     # ==============夹头型号==============
-    chuck_freight_barcode = fields.Char('夹头货位')
+    chuck_freight_barcode_id = fields.Many2one('sf.shelf.location', string='夹头货位')
+    chuck_lot_id = fields.Many2one('stock.lot', string='夹头批次')
     chuck_product_id = fields.Many2one('product.product', string='夹头名称', compute='_compute_chuck_product_id',
                                        store=True)
     cutting_tool_cutterhead_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='夹头型号',
@@ -526,17 +517,18 @@ class FunctionalToolAssembly(models.Model):
                                              related='chuck_product_id.specification_id')
     sf_tool_brand_id_6 = fields.Many2one('sf.machine.brand', '夹头品牌', related='chuck_product_id.brand_id')
 
-    @api.depends('chuck_freight_barcode')
+    @api.depends('chuck_lot_id')
     def _compute_chuck_product_id(self):
         for item in self:
-            if item.chuck_freight_barcode:
-                location = self.env['sf.shelf.location'].sudo().search([('barcode', '=', item.chuck_freight_barcode)])
-                if location:
-                    item.chuck_product_id = location.product_id.id
-                else:
-                    item.chuck_product_id = False
+            if item.chuck_lot_id:
+                item.chuck_product_id = item.chuck_lot_id.product_id.id
 
     # ==================待删除字段==================
+    integral_freight_barcode = fields.Char('整体式刀具货位')
+    blade_freight_barcode = fields.Char('刀片货位')
+    bar_freight_barcode = fields.Char('刀杆货位')
+    pad_freight_barcode = fields.Char('刀盘货位')
+    chuck_freight_barcode = fields.Char('夹头货位')
     blade_name = fields.Char('')
     integral_name = fields.Char('')
     blade_code_id = fields.Many2one('stock.lot', '刀片序列号')
@@ -679,7 +671,7 @@ class FunctionalToolAssembly(models.Model):
 
 class FunctionalToolDismantle(models.Model):
     _name = 'sf.functional.tool.dismantle'
-    _inherit = ["barcodes.barcode_events_mixin"]
+    _inherit = ["barcodes.barcode_events_mixin", 'mail.thread']
     _description = '功能刀具拆解'
 
     def on_barcode_scanned(self, barcode):
@@ -740,6 +732,22 @@ class FunctionalToolDismantle(models.Model):
                 raise ValidationError('该功能刀具因为%s拆解，无需录入库位' % self.dismantle_cause)
 
     name = fields.Char('名称', related='functional_tool_id.name')
+    code = fields.Char('拆解单号', default=lambda self: self._get_code(), readonly=True)
+
+    def _get_code(self):
+        """
+        自动生成拆解单编码
+        """
+        new_time = str(fields.Date.today())
+        datetime = new_time[2:4] + new_time[5:7] + new_time[-2:]
+        functional_tool_dismantle = self.env['sf.functional.tool.dismantle'].sudo().search(
+            [('code', 'ilike', datetime)], limit=1, order="id desc")
+        if not functional_tool_dismantle:
+            num = "%03d" % 1
+        else:
+            m = int(functional_tool_dismantle.code[-3:]) + 1
+            num = "%03d" % m
+        return 'GNDJ-CJD-%s-%s' % (datetime, num)
 
     functional_tool_id = fields.Many2one('sf.functional.cutting.tool.entity', '功能刀具', required=True,
                                          domain=[('functional_tool_status', '!=', '已拆除')])
@@ -753,7 +761,7 @@ class FunctionalToolDismantle(models.Model):
 
     dismantle_cause = fields.Selection(
         [('寿命到期报废', '寿命到期报废'), ('崩刀报废', '崩刀报废'), ('更换为其他刀具', '更换为其他刀具'),
-         ('刀具需磨削', '刀具需磨削')], string='拆解原因', required=True)
+         ('刀具需磨削', '刀具需磨削')], string='拆解原因', required=True, tracking=True)
     dismantle_data = fields.Datetime('拆解日期', readonly=True)
     dismantle_person = fields.Char('拆解人', readonly=True)
     image = fields.Binary('图片', readonly=True)
@@ -761,7 +769,7 @@ class FunctionalToolDismantle(models.Model):
     scrap_id = fields.Char('报废单号', readonly=True)
     grinding_id = fields.Char('磨削单号', readonly=True)
 
-    state = fields.Selection([('待拆解', '待拆解'), ('已拆解', '已拆解')], default='待拆解')
+    state = fields.Selection([('待拆解', '待拆解'), ('已拆解', '已拆解')], default='待拆解', tracking=True)
     active = fields.Boolean('有效', default=True)
 
     # 刀柄
@@ -771,7 +779,9 @@ class FunctionalToolDismantle(models.Model):
                                      related='handle_product_id.cutting_tool_model_id')
     handle_brand_id = fields.Many2one('sf.machine.brand', string='刀柄品牌', related='handle_product_id.brand_id')
     handle_rfid = fields.Char(string='刀柄Rfid', compute='_compute_functional_tool_num', store=True)
-    scrap_boolean = fields.Boolean(string='刀柄是否报废', default=False)
+    handle_lot_id = fields.Many2one('stock.lot', string='刀柄序列号', compute='_compute_functional_tool_num',
+                                    store=True)
+    scrap_boolean = fields.Boolean(string='刀柄是否报废', default=False, tracking=True)
 
     # 整体式
     integral_product_id = fields.Many2one('product.product', string='整体式刀具',
@@ -780,6 +790,8 @@ class FunctionalToolDismantle(models.Model):
                                        related='integral_product_id.cutting_tool_model_id')
     integral_brand_id = fields.Many2one('sf.machine.brand', string='整体式刀具品牌',
                                         related='integral_product_id.brand_id')
+    integral_lot_id = fields.Many2one('stock.lot', string='整体式刀具批次', compute='_compute_functional_tool_num',
+                                      store=True)
     integral_freight_id = fields.Many2one('sf.shelf.location', '整体式刀具目标货位',
                                           domain="[('product_id', 'in', (integral_product_id, False))]")
 
@@ -789,6 +801,7 @@ class FunctionalToolDismantle(models.Model):
     blade_type_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀片型号',
                                     related='blade_product_id.cutting_tool_model_id')
     blade_brand_id = fields.Many2one('sf.machine.brand', string='刀片品牌', related='blade_product_id.brand_id')
+    blade_lot_id = fields.Many2one('stock.lot', string='刀片批次', compute='_compute_functional_tool_num', store=True)
     blade_freight_id = fields.Many2one('sf.shelf.location', '刀片目标货位',
                                        domain="[('product_id', 'in', (blade_product_id, False))]")
 
@@ -798,6 +811,7 @@ class FunctionalToolDismantle(models.Model):
     bar_type_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀杆型号',
                                   related='bar_product_id.cutting_tool_model_id')
     bar_brand_id = fields.Many2one('sf.machine.brand', string='刀杆品牌', related='bar_product_id.brand_id')
+    bar_lot_id = fields.Many2one('stock.lot', string='刀杆批次', compute='_compute_functional_tool_num', store=True)
     bar_freight_id = fields.Many2one('sf.shelf.location', '刀杆目标货位',
                                      domain="[('product_id', 'in', (bar_product_id, False))]")
 
@@ -807,6 +821,7 @@ class FunctionalToolDismantle(models.Model):
     pad_type_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀盘型号',
                                   related='pad_product_id.cutting_tool_model_id')
     pad_brand_id = fields.Many2one('sf.machine.brand', string='刀盘品牌', related='pad_product_id.brand_id')
+    pad_lot_id = fields.Many2one('stock.lot', string='刀盘批次', compute='_compute_functional_tool_num', store=True)
     pad_freight_id = fields.Many2one('sf.shelf.location', '刀盘目标货位',
                                      domain="[('product_id', 'in', (pad_product_id, False))]")
 
@@ -816,6 +831,7 @@ class FunctionalToolDismantle(models.Model):
     chuck_type_id = fields.Many2one('sf.cutting_tool.standard.library', string='夹头型号',
                                     related='chuck_product_id.cutting_tool_model_id')
     chuck_brand_id = fields.Many2one('sf.machine.brand', string='夹头品牌', related='chuck_product_id.brand_id')
+    chuck_lot_id = fields.Many2one('stock.lot', string='夹头批次', compute='_compute_functional_tool_num', store=True)
     chuck_freight_id = fields.Many2one('sf.shelf.location', '夹头目标货位',
                                        domain="[('product_id', 'in', (chuck_product_id, False))]")
 
@@ -839,12 +855,20 @@ class FunctionalToolDismantle(models.Model):
                 item.rfid = item.functional_tool_id.rfid
                 item.handle_rfid = item.functional_tool_id.rfid
 
+                # 产品
                 item.handle_product_id = item.functional_tool_id.functional_tool_name_id.handle_product_id.id
                 item.integral_product_id = item.functional_tool_id.functional_tool_name_id.integral_product_id.id
                 item.blade_product_id = item.functional_tool_id.functional_tool_name_id.blade_product_id.id
                 item.bar_product_id = item.functional_tool_id.functional_tool_name_id.bar_product_id.id
                 item.pad_product_id = item.functional_tool_id.functional_tool_name_id.pad_product_id.id
                 item.chuck_product_id = item.functional_tool_id.functional_tool_name_id.chuck_product_id.id
+                # 批次/序列号
+                item.handle_lot_id = item.functional_tool_id.functional_tool_name_id.handle_code_id.id
+                item.integral_lot_id = item.functional_tool_id.functional_tool_name_id.integral_lot_id.id
+                item.blade_lot_id = item.functional_tool_id.functional_tool_name_id.blade_lot_id.id
+                item.bar_lot_id = item.functional_tool_id.functional_tool_name_id.bar_lot_id.id
+                item.pad_lot_id = item.functional_tool_id.functional_tool_name_id.pad_lot_id.id
+                item.chuck_lot_id = item.functional_tool_id.functional_tool_name_id.chuck_lot_id.id
             else:
                 item.tool_groups_id = False
                 item.tool_type_id = False
@@ -860,14 +884,45 @@ class FunctionalToolDismantle(models.Model):
                 item.pad_product_id = False
                 item.chuck_product_id = False
 
+                item.handle_lot_id = False
+                item.integral_lot_id = False
+                item.blade_lot_id = False
+                item.bar_lot_id = False
+                item.pad_lot_id = False
+                item.chuck_lot_id = False
+
+    def location_duplicate_check(self):
+        """
+        目标货位去重校验
+        """
+        if self.blade_freight_id:
+            if self.bar_freight_id:
+                if self.blade_freight_id == self.bar_freight_id:
+                    raise ValidationError('【刀片】和【刀杆】的目标货位重复，请重新选择！')
+            elif self.pad_freight_id:
+                if self.blade_freight_id == self.pad_freight_id:
+                    raise ValidationError('【刀片】和【刀盘】的目标货位重复，请重新选择！')
+        if self.chuck_freight_id:
+            if self.chuck_freight_id == self.integral_freight_id:
+                raise ValidationError('【夹头】和【整体式刀具】的目标货位重复，请重新选择！')
+            if self.chuck_freight_id == self.blade_freight_id:
+                raise ValidationError('【夹头】和【刀片】的目标货位重复，请重新选择！')
+            if self.chuck_freight_id == self.bar_freight_id:
+                raise ValidationError('【夹头】和【刀杆】的目标货位重复，请重新选择！')
+            if self.chuck_freight_id == self.pad_freight_id:
+                raise ValidationError('【夹头】和【刀盘】的目标货位重复，请重新选择！')
+
     def confirmation_disassembly(self):
         logging.info('%s刀具确认开始拆解' % self.dismantle_cause)
+        code = self.code
         if self.functional_tool_id.functional_tool_status == '已拆除':
             raise ValidationError('Rfid为【%s】的功能刀具已经拆解，请勿重复操作！' % self.functional_tool_id.rfid_dismantle)
         # 对拆解的功能刀具进行校验，只有在刀具房的功能刀具才能拆解
         if self.functional_tool_id.tool_room_num == 0:
             raise ValidationError('Rfid为【%s】的功能刀具当前位置为【%s】，不能进行拆解！' % (
                 self.rfid, self.functional_tool_id.current_location))
+        # 目标重复校验
+        self.location_duplicate_check()
         location = self.env['stock.location'].search([('name', '=', '刀具组装位置')])
         location_dest = self.env['stock.location'].search([('name', '=', '刀具房')])
         # =================刀柄是否[报废]拆解=======
@@ -879,53 +934,62 @@ class FunctionalToolDismantle(models.Model):
             functional_tool_assembly = self.functional_tool_id.functional_tool_name_id
             if self.scrap_boolean:
                 # 刀柄报废 入库到Scrap
-                lot.create_stock_quant(location, location_dest_scrap, functional_tool_assembly.id, '功能刀具拆解',
+                lot.create_stock_quant(location, location_dest_scrap, functional_tool_assembly.id, code,
                                        functional_tool_assembly, functional_tool_assembly.tool_groups_id)
             else:
                 # 刀柄不报废 入库到刀具房
-                lot.create_stock_quant(location, location_dest, functional_tool_assembly.id, '功能刀具拆解',
+                lot.create_stock_quant(location, location_dest, functional_tool_assembly.id, code,
                                        functional_tool_assembly, functional_tool_assembly.tool_groups_id)
         # ==============功能刀具[报废]拆解================
         if self.dismantle_cause in ['寿命到期报废', '崩刀报废']:
             # 除刀柄外物料报废 入库到Scrap
             if self.integral_product_id:
-                self.integral_product_id.dismantle_stock_moves(False, location, location_dest_scrap)
+                self.integral_product_id.dismantle_stock_moves(False, self.integral_lot_id, location,
+                                                               location_dest_scrap, code)
             elif self.blade_product_id:
-                self.blade_product_id.dismantle_stock_moves(False, location, location_dest_scrap)
+                self.blade_product_id.dismantle_stock_moves(False, self.blade_lot_id, location, location_dest_scrap,
+                                                            code)
                 if self.bar_product_id:
-                    self.bar_product_id.dismantle_stock_moves(False, location, location_dest_scrap)
+                    self.bar_product_id.dismantle_stock_moves(False, self.bar_lot_id, location, location_dest_scrap,
+                                                              code)
                 elif self.pad_product_id:
-                    self.pad_product_id.dismantle_stock_moves(False, location, location_dest_scrap)
+                    self.pad_product_id.dismantle_stock_moves(False, self.pad_lot_id, location, location_dest_scrap,
+                                                              code)
             if self.chuck_product_id:
-                self.chuck_product_id.dismantle_stock_moves(False, location, location_dest_scrap)
+                self.chuck_product_id.dismantle_stock_moves(False, self.chuck_lot_id, location, location_dest_scrap,
+                                                            code)
         # ===========功能刀具[磨削]拆解==============
-        elif self.dismantle_cause in ['刀具需磨削']:
-            location_dest = self.env['stock.location'].search([('name', '=', '磨削房')])
-            # 除刀柄外物料拆解 入库到具体库位
-            if self.integral_product_id:
-                self.integral_product_id.dismantle_stock_moves(False, location, location_dest)
-            elif self.blade_product_id:
-                self.blade_product_id.dismantle_stock_moves(False, location, location_dest)
-                if self.bar_product_id:
-                    self.bar_product_id.dismantle_stock_moves(False, location, location_dest)
-                elif self.pad_product_id:
-                    self.pad_product_id.dismantle_stock_moves(False, location, location_dest)
-            if self.chuck_product_id:
-                self.chuck_product_id.dismantle_stock_moves(False, location, location_dest)
-        # ==============功能刀具[更换]拆解==============
-        elif self.dismantle_cause in ['更换为其他刀具']:
-            # 除刀柄外物料拆解 入库到具体库位
+        # elif self.dismantle_cause in ['刀具需磨削']:
+        #     location_dest = self.env['stock.location'].search([('name', '=', '磨削房')])
+        #     # 除刀柄外物料拆解 入库到具体库位
+        #     if self.integral_product_id:
+        #         self.integral_product_id.dismantle_stock_moves(False, location, location_dest)
+        #     elif self.blade_product_id:
+        #         self.blade_product_id.dismantle_stock_moves(False, location, location_dest)
+        #         if self.bar_product_id:
+        #             self.bar_product_id.dismantle_stock_moves(False, location, location_dest)
+        #         elif self.pad_product_id:
+        #             self.pad_product_id.dismantle_stock_moves(False, location, location_dest)
+        #     if self.chuck_product_id:
+        #         self.chuck_product_id.dismantle_stock_moves(False, location, location_dest)
+        # ==============功能刀具[更换,磨削]拆解==============
+        elif self.dismantle_cause in ['更换为其他刀具', '刀具需磨削']:
+            # 除刀柄外物料拆解 入库到具体货位
             if self.integral_freight_id:
-                self.integral_product_id.dismantle_stock_moves(self.integral_freight_id.barcode, location,
-                                                               location_dest)
+                self.integral_product_id.dismantle_stock_moves(self.integral_freight_id, self.integral_lot_id, location,
+                                                               location_dest, code)
             elif self.blade_freight_id:
-                self.blade_product_id.dismantle_stock_moves(self.blade_freight_id.barcode, location, location_dest)
+                self.blade_product_id.dismantle_stock_moves(self.blade_freight_id, self.blade_lot_id, location,
+                                                            location_dest, code)
                 if self.bar_freight_id:
-                    self.bar_product_id.dismantle_stock_moves(self.bar_freight_id.barcode, location, location_dest)
+                    self.bar_product_id.dismantle_stock_moves(self.bar_freight_id, self.bar_lot_id, location,
+                                                              location_dest, code)
                 elif self.pad_freight_id:
-                    self.pad_product_id.dismantle_stock_moves(self.pad_freight_id.barcode, location, location_dest)
+                    self.pad_product_id.dismantle_stock_moves(self.pad_freight_id, self.pad_lot_id, location,
+                                                              location_dest, code)
             if self.chuck_freight_id:
-                self.chuck_product_id.dismantle_stock_moves(self.chuck_freight_id.barcode, location, location_dest)
+                self.chuck_product_id.dismantle_stock_moves(self.chuck_freight_id, self.chuck_lot_id, location,
+                                                            location_dest, code)
         # ===============删除功能刀具的Rfid字段的值， 赋值给Rfid(已拆解)字段=====
         self.functional_tool_id.write({
             'rfid_dismantle': self.functional_tool_id.rfid,
@@ -946,26 +1010,22 @@ class FunctionalToolDismantle(models.Model):
 class ProductProduct(models.Model):
     _inherit = 'product.product'
 
-    def dismantle_stock_moves(self, shelf_location_barcode, location_id, location_dest_id):
+    def dismantle_stock_moves(self, shelf_location_id, lot_id, location_id, location_dest_id, code):
         # 创建功能刀具拆解单产品库存移动记录
         stock_move_id = self.env['stock.move'].sudo().create({
-            'name': '功能刀具拆解',
+            'name': code,
             'product_id': self.id,
             'location_id': location_id.id,
             'location_dest_id': location_dest_id.id,
             'product_uom_qty': 1.00,
             'state': 'done'
         })
-        if shelf_location_barcode:
-            location = self.env['sf.shelf.location'].sudo().search([('barcode', '=', shelf_location_barcode)])
-            location.product_num = location.product_num + 1
-        else:
-            location = self.env['sf.shelf.location']
         # 创建移动历史记录
         stock_move_line_id = self.env['stock.move.line'].sudo().create({
             'product_id': self.id,
+            'lot_id': lot_id.id,
             'move_id': stock_move_id.id,
-            'current_location_id': location.id,
+            'destination_location_id': shelf_location_id.id,
             'install_tool_time': fields.Datetime.now(),
             'qty_done': 1.0,
             'state': 'done',

sf_tool_management/models/fixture_enroll.py

@@ -1,6 +1,7 @@
 import json
 import base64
 import requests
+import logging
 from odoo import models, api
 from odoo.addons.sf_base.commons.common import Common
 from odoo.exceptions import UserError
@@ -10,30 +11,36 @@ class StockLot(models.Model):
     _inherit = 'stock.lot'
     _description = '夹具物料序列号注册'
 
-    def enroll_fixture_material_stock(self):
+    def sync_enroll_fixture_material_stock_all(self):
+        logging.info("调用 sync_enroll_fixture_material_stock_all 同步接口")
         sf_sync_config = self.env['res.config.settings'].get_values()
         token = sf_sync_config['token']
         sf_secret_key = sf_sync_config['sf_secret_key']
         headers = Common.get_headers(self, token, sf_secret_key)
         str_url = sf_sync_config['sf_url'] + "/api/fixture_material_stock/create"
-        objs_all = self.env['stock.lot'].search([('id', '=', self.id)])
+        product_ids = self.env['product.product'].sudo().search([('categ_type', '=', '夹具')]).ids
+        objs_all = self.env['stock.lot'].search([('rfid', '!=', False), ('product_id', 'in', product_ids)])
         fixture_material_stock_list = []
-        if objs_all:
-            for item in objs_all:
-                val = {
-                    'name': item.name,
-                    'tool_material_status': item.tool_material_status,
-                    'location': [] if not item.quant_ids else item.quant_ids[-1].location_id.name,
-                    'fixture_material_search_id': item.fixture_material_search_id.id,
-                }
-                fixture_material_stock_list.append(val)
-            kw = json.dumps(fixture_material_stock_list, ensure_ascii=False)
-            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
-            ret = r.json()
-            if ret.get('code') == 200:
-                return '夹具物料序列号注册成功'
-        else:
-            raise UserError("没有注册夹具物料序列号信息")
+        try:
+            if objs_all:
+                for item in objs_all:
+                    val = {
+                        'name': item.name,
+                        'tool_material_status': item.tool_material_status,
+                        'location': [] if not item.quant_ids else item.quant_ids[-1].location_id.name,
+                        'fixture_material_search_id': item.fixture_material_search_id.id,
+                    }
+                    fixture_material_stock_list.append(val)
+                kw = json.dumps(fixture_material_stock_list, ensure_ascii=False)
+                r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
+                ret = r.json()
+                if ret.get('code') == 200:
+                    logging.info("夹具物料序列号每日同步成功")
+                    return '夹具物料序列号注册成功'
+            else:
+                logging.info("没有注册夹具物料序列号信息")
+        except Exception as e:
+            logging.info("夹具物料序列号同步失败:%s" % e)
 
 
 class FixtureMaterialSearch(models.Model):
@@ -42,41 +49,46 @@ class FixtureMaterialSearch(models.Model):
 
     crea_url = "/api/fixture_material/create"
 
-    def enroll_fixture_material(self):
+    def sync_enroll_fixture_material_all(self):
+        logging.info("调用 sync_enroll_fixture_material_all 同步接口")
         sf_sync_config = self.env['res.config.settings'].get_values()
         token = sf_sync_config['token']
         sf_secret_key = sf_sync_config['sf_secret_key']
         headers = Common.get_headers(self, token, sf_secret_key)
         str_url = sf_sync_config['sf_url'] + self.crea_url
-        objs_all = self.search([('id', '=', self.id)])
+        objs_all = self.search([])
         fixture_material_list = []
-        if objs_all:
-            for obj in objs_all:
-                val = {
-                    'name': obj.name,
-                    'id': obj.id,
-                    'fixture_material_code': obj.fixture_material_id.code,
-                    'fixture_model_code': obj.fixture_model_id.code,
-                    'specification_name': obj.specification_fixture_id.name,
-                    'image': '' if not obj.image else base64.b64encode(obj.image).decode('utf-8'),
-                    'number': obj.number,
-                    'usable_num': obj.usable_num,
-                    'have_been_used_num': obj.have_been_used_num,
-                    'scrap_num': obj.scrap_num
-                }
-                fixture_material_list.append(val)
-            kw = json.dumps(fixture_material_list, ensure_ascii=False)
-            r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
-            ret = r.json()
-            if ret.get('code') == 200:
-                return '夹具物料注册成功'
-        else:
-            raise UserError("没有注册夹具物料信息")
+        try:
+            if objs_all:
+                for obj in objs_all:
+                    val = {
+                        'name': obj.name,
+                        'id': obj.id,
+                        'fixture_material_code': obj.fixture_material_id.code,
+                        'fixture_model_code': obj.fixture_model_id.code,
+                        'specification_name': obj.specification_fixture_id.name,
+                        'image': '' if not obj.image else base64.b64encode(obj.image).decode('utf-8'),
+                        'number': obj.number,
+                        'usable_num': obj.usable_num,
+                        'have_been_used_num': obj.have_been_used_num,
+                        'scrap_num': obj.scrap_num
+                    }
+                    fixture_material_list.append(val)
+                kw = json.dumps(fixture_material_list, ensure_ascii=False)
+                r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
+                ret = r.json()
+                if ret.get('code') == 200:
+                    logging.info("夹具物料每日同步成功")
+                    return '夹具物料注册成功'
+            else:
+                logging.info("没有注册夹具物料信息")
+        except Exception as e:
+            logging.info("夹具物料同步失败:%s" % e)
 
-    @api.model_create_multi
-    def create(self, vals_list):
-        records = super(FixtureMaterialSearch, self).create(vals_list)
-        for record in records:
-            if record:
-                record.enroll_fixture_material()
-        return records
+    # @api.model_create_multi
+    # def create(self, vals_list):
+    #     records = super(FixtureMaterialSearch, self).create(vals_list)
+    #     for record in records:
+    #         if record:
+    #             record.enroll_fixture_material()
+    #     return records

sf_tool_management/models/functional_tool.py

@@ -14,14 +14,15 @@ class FunctionalCuttingToolEntity(models.Model):
 
     functional_tool_name_id = fields.Many2one('sf.functional.tool.assembly', string='功能刀具组装单', readonly=True)
 
-    tool_groups_id = fields.Many2one('sf.tool.groups', '刀具组', related='functional_tool_name_id.tool_groups_id')
+    tool_groups_id = fields.Many2one('sf.tool.groups', '刀具组', related='functional_tool_name_id.tool_groups_id',
+                                     store=True)
     code = fields.Char('编码')
     rfid = fields.Char('Rfid', readonly=True)
     rfid_dismantle = fields.Char('Rfid(已拆解)', readonly=True)
     name = fields.Char('名称')
     tool_name_id = fields.Many2one('sf.tool.inventory', '功能刀具名称')
     sf_cutting_tool_model_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀具型号')
-    barcode_id = fields.Many2one('stock.lot', string='功能刀具序列号', readonly=True)
+    barcode_id = fields.Many2one('stock.lot', string='序列号', readonly=True)
     sf_cutting_tool_type_id = fields.Many2one('sf.functional.cutting.tool.model', string='功能刀具类型',
                                               group_expand='_read_group_mrs_cutting_tool_type_id', compute_sudo=True)
 
@@ -49,8 +50,6 @@ class FunctionalCuttingToolEntity(models.Model):
         string='位置', compute='_compute_current_location_id', store=True)
     image = fields.Binary('图片', readonly=True)
 
-    active = fields.Boolean(string='已归档', default=True)
-
     safe_inventory_id = fields.Many2one('sf.real.time.distribution.of.functional.tools',
                                         string='功能刀具安全库存', readonly=True)
 
@@ -391,6 +390,7 @@ class StockMoveLine(models.Model):
 
 class RealTimeDistributionOfFunctionalTools(models.Model):
     _name = 'sf.real.time.distribution.of.functional.tools'
+    _inherit = ['mail.thread']
     _description = '功能刀具安全库存'
 
     name = fields.Char('名称', readonly=True, compute='_compute_name', store=True)
@@ -408,7 +408,7 @@ class RealTimeDistributionOfFunctionalTools(models.Model):
     max_stock_num = fields.Integer('最高库存量')
     batch_replenishment_num = fields.Integer('批次补货量', readonly=True, compute='_compute_batch_replenishment_num',
                                              store=True)
-    unit = fields.Char('单位')
+    unit = fields.Char('单位', default="件")
     image = fields.Binary('图片', readonly=False)
 
     coarse_middle_thin = fields.Selection([("1", "粗"), ('2', '中'), ('3', '精')], string='粗/中/精', readonly=False)

sf_tool_management/models/functional_tool_enroll.py

@@ -33,23 +33,26 @@ def get_suitable_coolant_names(item):
 
 class ToolDatasync(models.Model):
     _name = 'sf.tool.datasync'
-    _description = '定时同步所有刀具'
+    _description = '定时同步所有刀具、夹具'
 
     def _cron_tool_datasync_all(self):
         try:
             self.env['stock.lot'].sudo().sync_enroll_tool_material_stock_all()
-            logging.info("刀具物料序列号每日同步成功")
+
+            self.env['stock.lot'].sudo().sync_enroll_fixture_material_stock_all()
+
             self.env['sf.tool.material.search'].sudo().sync_enroll_tool_material_all()
-            logging.info("刀具物料每日同步成功")
+
+            self.env['sf.fixture.material.search'].sudo().sync_enroll_fixture_material_all()
+
             self.env['sf.functional.cutting.tool.entity'].sudo().esync_enroll_functional_tool_entity_all()
-            logging.info("功能刀具列表每日同步成功")
-            self.env['sf.functional.tool.warning'].sudo().sync_enroll_functional_tool_warning_all()
-            logging.info("功能刀具预警每日同步成功")
-            self.env['stock.move.line'].sudo().sync_enroll_functional_tool_move_all()
-            logging.info("功能刀具出入库记录每日同步成功")
-            self.env[
-                'sf.real.time.distribution.of.functional.tools'].sudo().sync_enroll_functional_tool_real_time_distribution_all()
-            logging.info("功能刀具安全库存每日同步成功")
+            logging.info("已全部同步完成！！！")
+            # self.env['sf.functional.tool.warning'].sudo().sync_enroll_functional_tool_warning_all()
+            # logging.info("功能刀具预警每日同步成功")
+            # self.env['stock.move.line'].sudo().sync_enroll_functional_tool_move_all()
+            # logging.info("功能刀具出入库记录每日同步成功")
+            # self.env['sf.real.time.distribution.of.functional.tools'].sudo().sync_enroll_functional_tool_real_time_distribution_all()
+            # logging.info("功能刀具安全库存每日同步成功")
         except Exception as e:
             logging.info("捕获错误信息:%s" % e)
             raise ValidationError("数据错误导致同步失败,请联系管理员")
@@ -59,24 +62,25 @@ class StockLot(models.Model):
     _inherit = 'stock.lot'
     _description = '刀具物料序列号注册'
 
-    def enroll_tool_material_stock(self):
-        logging.info('调用刀具物料序列号注册接口: enroll_tool_material_stock()')
-        sf_sync_config = self.env['res.config.settings'].get_values()
-        token = sf_sync_config['token']
-        sf_secret_key = sf_sync_config['sf_secret_key']
-        headers = Common.get_headers(self, token, sf_secret_key)
-        str_url = sf_sync_config['sf_url'] + "/api/tool_material_stock/create"
-        objs_all = self.env['stock.lot'].search([('id', '=', self.id), ('active', 'in', [True, False])])
-        self._get_sync_stock_lot(objs_all, str_url, token, headers)
+    # def enroll_tool_material_stock(self):
+    #     logging.info('调用刀具物料序列号注册接口: enroll_tool_material_stock()')
+    #     sf_sync_config = self.env['res.config.settings'].get_values()
+    #     token = sf_sync_config['token']
+    #     sf_secret_key = sf_sync_config['sf_secret_key']
+    #     headers = Common.get_headers(self, token, sf_secret_key)
+    #     str_url = sf_sync_config['sf_url'] + "/api/tool_material_stock/create"
+    #     objs_all = self.env['stock.lot'].search([('id', '=', self.id), ('active', 'in', [True, False])])
+    #     self._get_sync_stock_lot(objs_all, str_url, token, headers)
 
     def sync_enroll_tool_material_stock_all(self):
-        logging.info('调用刀具物料序列号注册接口: sync_enroll_tool_material_stock_all()')
+        logging.info('调用 sync_enroll_tool_material_stock_all 同步接口')
         sf_sync_config = self.env['res.config.settings'].get_values()
         token = sf_sync_config['token']
         sf_secret_key = sf_sync_config['sf_secret_key']
         headers = Common.get_headers(self, token, sf_secret_key)
         str_url = sf_sync_config['sf_url'] + "/api/tool_material_stock/create"
-        objs_all = self.env['stock.lot'].search([('rfid', '!=', False)])
+        product_ids = self.env['product.product'].sudo().search([('categ_type', '=', '刀具')]).ids
+        objs_all = self.env['stock.lot'].search([('product_id', 'in', product_ids)])
         self._get_sync_stock_lot(objs_all, str_url, token, headers)
 
     def _get_sync_stock_lot(self, objs_all, str_url, token, headers):
@@ -86,6 +90,7 @@ class StockLot(models.Model):
                 for item in objs_all:
                     val = {
                         'name': item.name,
+                        'qty': item.product_qty,
                         'tool_material_status': item.tool_material_status,
                         'location': [] if not item.quant_ids else item.quant_ids[-1].location_id.name,
                         'tool_material_search_id': item.tool_material_search_id.id,
@@ -95,12 +100,13 @@ class StockLot(models.Model):
                 r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
                 ret = r.json()
                 if ret.get('code') == 200:
-                    return '刀具物料序列号注册成功'
+                    logging.info("刀具物料序列号每日同步成功")
+                    return '刀具(夹具)物料序列号注册成功'
             else:
-                logging.info("没有注册刀具物料序列号信息")
+                logging.info("没有刀具物料序列号信息")
         except Exception as e:
-            logging.info("捕获错误信息:%s" % e)
-
+            logging.info("刀具物料序列号同步失败:%s" % e)
+            
 
 class ToolMaterial(models.Model):
     _inherit = 'sf.tool.material.search'
@@ -108,18 +114,18 @@ class ToolMaterial(models.Model):
 
     crea_url = '/api/tool_material/create'
 
-    def enroll_tool_material(self):
-        logging.info('调用刀具物料注册接口: enroll_tool_material()')
-        sf_sync_config = self.env['res.config.settings'].get_values()
-        token = sf_sync_config['token']
-        sf_secret_key = sf_sync_config['sf_secret_key']
-        headers = Common.get_headers(self, token, sf_secret_key)
-        str_url = sf_sync_config['sf_url'] + self.crea_url
-        objs_all = self.search([('id', '=', self.id)])
-        self._get_sync_tool_material_search(objs_all, str_url, token, headers)
+    # def enroll_tool_material(self):
+    #     logging.info('调用刀具物料注册接口: enroll_tool_material()')
+    #     sf_sync_config = self.env['res.config.settings'].get_values()
+    #     token = sf_sync_config['token']
+    #     sf_secret_key = sf_sync_config['sf_secret_key']
+    #     headers = Common.get_headers(self, token, sf_secret_key)
+    #     str_url = sf_sync_config['sf_url'] + self.crea_url
+    #     objs_all = self.search([('id', '=', self.id)])
+    #     self._get_sync_tool_material_search(objs_all, str_url, token, headers)
 
     def sync_enroll_tool_material_all(self):
-        logging.info('调用刀具物料注册接口: sync_enroll_tool_material_all()')
+        logging.info('调用 sync_enroll_tool_material_all 同步接口')
         sf_sync_config = self.env['res.config.settings'].get_values()
         token = sf_sync_config['token']
         sf_secret_key = sf_sync_config['sf_secret_key']
@@ -150,11 +156,12 @@ class ToolMaterial(models.Model):
                 r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
                 ret = r.json()
                 if ret.get('code') == 200:
+                    logging.info("刀具物料每日同步成功")
                     return '刀具物料注册成功'
             else:
                 logging.info('没有注册刀具物料信息')
         except Exception as e:
-            logging.info("捕获错误信息:%s" % e)
+            logging.info("刀具物料同步失败:%s" % e)
 
 
 class FunctionalCuttingToolEntity(models.Model):
@@ -164,18 +171,18 @@ class FunctionalCuttingToolEntity(models.Model):
     crea_url = "/api/functional_tool_entity/create"
 
     # 注册同步功能刀具列表
-    def enroll_functional_tool_entity(self):
-        logging.info('调用功能刀具列表注册接口: enroll_functional_tool_entity()')
-        sf_sync_config = self.env['res.config.settings'].get_values()
-        token = sf_sync_config['token']
-        sf_secret_key = sf_sync_config['sf_secret_key']
-        headers = Common.get_headers(self, token, sf_secret_key)
-        str_url = sf_sync_config['sf_url'] + self.crea_url
-        objs_all = self.env['sf.functional.cutting.tool.entity'].search([('id', '=', self.id)])
-        self._get_sync_functional_cutting_tool_entity(objs_all, str_url, token, headers)
+    # def enroll_functional_tool_entity(self):
+    #     logging.info('调用功能刀具列表注册接口: enroll_functional_tool_entity()')
+    #     sf_sync_config = self.env['res.config.settings'].get_values()
+    #     token = sf_sync_config['token']
+    #     sf_secret_key = sf_sync_config['sf_secret_key']
+    #     headers = Common.get_headers(self, token, sf_secret_key)
+    #     str_url = sf_sync_config['sf_url'] + self.crea_url
+    #     objs_all = self.env['sf.functional.cutting.tool.entity'].search([('id', '=', self.id)])
+    #     self._get_sync_functional_cutting_tool_entity(objs_all, str_url, token, headers)
 
     def esync_enroll_functional_tool_entity_all(self):
-        logging.info('调用功能刀具列表注册接口: esync_enroll_functional_tool_entity_all()')
+        logging.info('调用 esync_enroll_functional_tool_entity_all 同步接口')
         sf_sync_config = self.env['res.config.settings'].get_values()
         token = sf_sync_config['token']
         sf_secret_key = sf_sync_config['sf_secret_key']
@@ -202,6 +209,7 @@ class FunctionalCuttingToolEntity(models.Model):
                         'coarse_middle_thin': item.coarse_middle_thin,
                         'new_former': item.new_former,
                         'tool_loading_length': item.tool_loading_length,
+                        'handle_length': item.handle_length,
                         'functional_tool_length': item.functional_tool_length,
                         'effective_length': item.effective_length,
                         'max_lifetime_value': item.max_lifetime_value,
@@ -234,11 +242,12 @@ class FunctionalCuttingToolEntity(models.Model):
                 r = requests.post(str_url, json={}, data={'kw': kw, 'token': token}, headers=headers)
                 ret = r.json()
                 if ret.get('code') == 200:
+                    logging.info("功能刀具列表每日同步成功")
                     return "功能刀具注册成功"
             else:
                 logging.info('没有注册功能刀具信息')
         except Exception as e:
-            logging.info("捕获错误信息:%s" % e)
+            logging.info("功能刀具同步失败:%s" % e)
 
 
 class FunctionalToolWarning(models.Model):

sf_tool_management/models/tool_material_search.py

@@ -46,6 +46,8 @@ class ToolMaterial(models.Model):
             record.scrap_num = scrap_num
             record.number = usable_num + have_been_used_num + scrap_num
 
+
+
     @api.model
     def _read_group_cutting_tool_material_id(self, categories, domain, order):
         cutting_tool_material_id = categories._search([], order=order, access_rights_uid=SUPERUSER_ID)