Resolve merge conflicts

jikimo_purchase_request/models/stock_picking.py

@@ -41,10 +41,8 @@ class StockPicking(models.Model):
         if backorder_ids:
             purchase_request_lines = self.move_ids.move_orig_ids.purchase_line_id.purchase_request_lines
             if purchase_request_lines:
-                purchase_request_lines.move_dest_ids = [
+               purchase_request_lines.move_dest_ids = [
-                    (4, x.id) for x in backorder_ids.move_ids if
+                   (4, x.id) for x in backorder_ids.move_ids if x.product_id.id in purchase_request_lines.mapped('product_id.id')
-                    x.product_id.id in purchase_request_lines.mapped('product_id.id') and \
-                    not x.created_purchase_request_line_id
                 ]
         return res
 

sf_demand_plan/__manifest__.py

@@ -10,7 +10,7 @@
     """,
     'category': 'sf',
     'website': 'https://www.sf.jikimo.com',
-    'depends': ['sf_plan'], #'jikimo_printing',
+    'depends': ['sf_plan','jikimo_printing'],
     'data': [
         'security/ir.model.access.csv',
         'data/stock_route_group.xml',

sf_demand_plan/models/mrp_bom.py

@@ -23,7 +23,7 @@ class MrpBom(models.Model):
         """重写name_get方法，只显示BOM编码"""
         result = []
         for record in self:
-            # 只显示BOM编码，如果编码为空则显示产品名称
+            # 只显示BOM编码，如果编码为空则显示名称
-            display_name = record.code or record.product_tmpl_id.name or f'BOM-{record.id}'
+            display_name = record.code or record.name or f'BOM-{record.id}'
             result.append((record.id, display_name))
         return result

sf_demand_plan/models/sf_demand_plan.py

@@ -36,9 +36,6 @@ class SfDemandPlan(models.Model):
 
     blank_type = fields.Selection([('圆料', '圆料'), ('方料', '方料')], string='坯料分类',
                                   related='product_id.blank_type')
-    blank_precision = fields.Selection([('精坯', '精坯'), ('粗坯', '粗坯')], string='坯料类型',
-                                       related='product_id.blank_precision')
-    manual_quotation = fields.Boolean('人工编程', related='product_id.manual_quotation', default=False)
     embryo_long = fields.Char('坯料尺寸(mm)', compute='_compute_embryo_long', store=True)
     is_incoming_material = fields.Boolean('客供料', related='sale_order_line_id.is_incoming_material', store=True)
     pending_qty = fields.Float(
@@ -115,10 +112,7 @@ class SfDemandPlan(models.Model):
     def _compute_embryo_long(self):
         for line in self:
             if line.product_id:
-                if line.product_id.blank_type == '圆料':
+                line.embryo_long = f"{round(line.product_id.model_long, 3)}*{round(line.product_id.model_width, 3)}*{round(line.product_id.model_height, 3)}"
-                    line.embryo_long = f"Ø{round(line.product_id.model_width, 3)}*{round(line.product_id.model_long, 3)}"
-                else:
-                    line.embryo_long = f"{round(line.product_id.model_long, 3)}*{round(line.product_id.model_width, 3)}*{round(line.product_id.model_height, 3)}"
             else:
                 line.embryo_long = None
 
@@ -215,7 +209,7 @@ class SfDemandPlan(models.Model):
     def name_get(self):
         result = []
         for plan in self:
-            result.append((plan.id, plan.demand_plan_number))
+            result.append((plan.id, plan.product_id.name))
         return result
 
     def button_production_release_plan(self):
@@ -224,10 +218,10 @@ class SfDemandPlan(models.Model):
         customer_location_id = self.env['ir.model.data']._xmlid_to_res_id('stock.stock_location_customers')
         if not self.overdelivery_allowed and line_ids.filtered(lambda p: p.location_id.id == customer_location_id):
             if float_compare(sum_product_uom_qty, self.product_uom_qty,
-                             precision_rounding=self.product_id.uom_id.rounding) == 1:
+                                          precision_rounding=self.product_id.uom_id.rounding) == 1:
                 raise ValidationError(f"已禁止向合作伙伴/客户超量发货，请更换“补货原因”或将“可超量发货”设置为“是”。")
         elif float_compare(sum_product_uom_qty, self.product_uom_qty,
-                           precision_rounding=self.product_id.uom_id.rounding) == 1:
+                                          precision_rounding=self.product_id.uom_id.rounding) == 1: 
             return {
                 'name': _('需求计划'),
                 'type': 'ir.actions.act_window',
@@ -243,8 +237,7 @@ class SfDemandPlan(models.Model):
         else:
             for demand_plan_line_id in line_ids:
                 demand_plan_line_id.action_confirm()
-
+    #需求要求取值格式是来源+来源明细行ID,但是来源明细行ID取得就是product_id.name得最后一位，所以这里也直接截取product_id.name        
-    # 需求要求取值格式是来源+来源明细行ID,但是来源明细行ID取得就是product_id.name得最后一位，所以这里也直接截取product_id.name
     @api.depends('product_id.name')
     def _compute_demand_plan_number(self):
         for line in self:

sf_demand_plan/models/sf_production_demand_plan.py

@@ -7,29 +7,7 @@ from odoo.tools import float_compare
 from datetime import datetime, timedelta
 from odoo.exceptions import UserError
 import re
-#本地环境问题  不加报错
-class ProductCategory(models.Model):
-    _inherit = 'product.category'
 
-    negative_inventory_allowed = fields.Boolean(string="允许负库存", default=False)
-
-class StockPicking(models.Model):
-    _inherit = 'stock.picking'
-
-    whether_show_quality_check = fields.Boolean(string="是否显示质检")
-
-class ProductTemplate(models.Model):
-    _inherit = 'product.template'
-
-    blank_type = fields.Selection([
-        ('圆料', '圆料'),
-        ('方料', '方料'),
-    ], string='坯料分类')
-
-    blank_precision = fields.Selection([
-        ('精坯', '精坯'),
-        ('粗坯', '粗坯'),
-    ], string='坯料类型')
 
 class SfProductionDemandPlan(models.Model):
     _name = 'sf.production.demand.plan'
@@ -43,7 +21,7 @@ class SfProductionDemandPlan(models.Model):
     status = fields.Selection([
         ('10', '草稿'),
         ('20', '待确认'),
-        ('30', '待工艺设计'),
+        ('30', '需求确认'),
         ('50', '待下达生产'),
         ('60', '已下达'),
         ('100', '取消'),
@@ -103,7 +81,6 @@ class SfProductionDemandPlan(models.Model):
                                   related='product_id.blank_type')
     blank_precision = fields.Selection([('精坯', '精坯'), ('粗坯', '粗坯')], string='坯料类型',
                                        related='product_id.blank_precision')
-    unit_number = fields.Float('单件用量', digits=(16, 3), related='product_id.unit_number')
     embryo_long = fields.Char('坯料尺寸(mm)', related='demand_plan_id.embryo_long')
     materials_id = fields.Char('材料', related='demand_plan_id.materials_id')
     model_machining_precision = fields.Selection(related='product_id.model_machining_precision', string='精度')
@@ -192,7 +169,6 @@ class SfProductionDemandPlan(models.Model):
     finished_product_arrival_date = fields.Date('采购计划到货(成品)')
     bom_id = fields.Many2one('mrp.bom', string="BOM", readonly=True)
     location_id = fields.Many2one('stock.location', string='需求位置', default=get_location_id, readonly=True)
-    manual_quotation = fields.Boolean('人工编程', related='product_id.manual_quotation', default=False)
 
     @api.constrains('plan_uom_qty')
     def _check_plan_uom_qty(self):
@@ -200,22 +176,15 @@ class SfProductionDemandPlan(models.Model):
         if line_ids:
             raise ValidationError(_("计划量不能小于等于0"))
 
-    @api.constrains('supply_method')
+    @api.constrains('new_supply_method')
-    def _check_supply_method(self):
+    def _check_new_supply_method(self):
         product_name = []
-        product = []
         for line in self:
-            if line.supply_method == 'purchase' and line.is_incoming_material:
+            if line.new_supply_method == 'purchase' and line.is_incoming_material:
                 product_name.append(line.product_id.display_name)
-            if line.supply_method == 'automation' and line.manual_quotation:
-                product.append(line.product_id.display_name)
-
         if product_name:
             unique_product_names = list(set(product_name))
             raise UserError('当前（%s）产品为客供料，不能选择外购' % ','.join(unique_product_names))
-        if product:
-            unique_product = list(set(product))
-            raise UserError('当前（%s）产品为人工编程，不能选择自动化产线加工' % ','.join(unique_product))
 
     @api.depends('new_supply_method')
     def _compute_custom_made_type(self):
@@ -375,12 +344,9 @@ class SfProductionDemandPlan(models.Model):
             pro_plan.do_production_schedule()
 
     def update_sale_order_state(self):
-        # demand_plan = self.env['sf.demand.plan'].sudo().search([('sale_order_id', '=', self.sale_order_id.id)])
+        demand_plan = self.env['sf.demand.plan'].sudo().search([('sale_order_id', '=', self.sale_order_id.id)])
-        # demand_plan_state = demand_plan.filtered(lambda line: line.state != '40')
+        demand_plan_state = demand_plan.filtered(lambda line: line.state != '40')
-        production_demand_plan = self.env['sf.production.demand.plan'].sudo().search(
+        if not demand_plan_state:
-            [('sale_order_id', '=', self.sale_order_id.id)])
-        production_demand_plan_state = production_demand_plan.filtered(lambda line: line.status in ('10', '20', '30'))
-        if not production_demand_plan_state:
             # 修改销售订单为加工中
             self.sale_order_id.state = 'processing'
 
@@ -621,7 +587,7 @@ class SfProductionDemandPlan(models.Model):
     def unlink(self):
         for item in self:
             if item.status not in ('10', '20', '30'):
-                raise ValidationError(u'只能删除状态为【草稿,待确认，待工艺设计】的需求计划。')
+                raise ValidationError(u'只能删除状态为【草稿,待确认，需求确认】的需求计划。')
             else:
                 super(SfProductionDemandPlan, item).unlink()
 
@@ -637,11 +603,6 @@ class SfProductionDemandPlan(models.Model):
         # 按产品分组并计算总数
         product_data = {}
         for plan in filtered_plan:
-            check_overdelivery_allowed = False
-            if not plan.demand_plan_id.overdelivery_allowed:
-                customer_location_id = self.env['ir.model.data']._xmlid_to_res_id('stock.stock_location_customers')
-                if plan.location_id.id == customer_location_id:
-                    check_overdelivery_allowed = True 
             if plan.product_id not in product_data:
                 # 初始化产品数据，从产品上获取需求量
                 product_data[plan.product_id] = {
@@ -651,22 +612,17 @@ class SfProductionDemandPlan(models.Model):
 
             # 累加计划数量
             product_data[plan.product_id]['plan_uom_qty'] += plan.plan_uom_qty
-            product_data[plan.product_id]['overdelivery_allowed'] = check_overdelivery_allowed
         # 检查需求超过计划数量的产品
         warning_messages = []
-        error_messages = []
         for product, data in product_data.items():
-            if data['overdelivery_allowed'] and float_compare(data['plan_uom_qty'], data['product_uom_qty'],precision_rounding=product.uom_id.rounding) == 1:
+            if float_compare(data['plan_uom_qty'], data['product_uom_qty'],
-                error_messages.append(f"您正在下达的产品 {product.display_name},已禁止向合作伙伴/客户超量发货，请更换“补货原因”或将“可超量发货”设置为“是”。")
+                                          precision_rounding=product.uom_id.rounding) == 1:
-            elif float_compare(data['plan_uom_qty'], data['product_uom_qty'],
-                             precision_rounding=product.uom_id.rounding) == 1:
                 warning_messages.append(
                     _("您正在下达的产品 %s，计划量%s，需求数量为%s，已超过需求数量") %
                     (product.display_name, data['plan_uom_qty'], data['product_uom_qty'])
                 )
-        if error_messages:
+        if warning_messages and check_overdelivery_allowed:
-            error_message = "\n".join(error_messages)
+            raise ValidationError(f"已禁止向合作伙伴/客户超量发货，请更换“补货原因”或将“可超量发货”设置为“是”。")
-            raise ValidationError(error_message)
         elif warning_messages:
             warning_message = "\n".join(warning_messages)
             return {
@@ -684,17 +640,17 @@ class SfProductionDemandPlan(models.Model):
 
     def button_release_plan(self):
         self.ensure_one()
+        if not self.new_supply_method:
+            raise ValidationError(f"供货方式不能为空！")
         check_overdelivery_allowed = False
         if not self.demand_plan_id.overdelivery_allowed:
             customer_location_id = self.env['ir.model.data']._xmlid_to_res_id('stock.stock_location_customers')
             if self.location_id.id == customer_location_id:
                 check_overdelivery_allowed = True
         if check_overdelivery_allowed:
-            if float_compare(self.plan_uom_qty, self.product_uom_qty,
+            if float_compare(self.plan_uom_qty, self.product_uom_qty,precision_rounding=self.product_id.uom_id.rounding) == 1:
-                             precision_rounding=self.product_id.uom_id.rounding) == 1:
                 raise ValidationError(f"已禁止向合作伙伴/客户超量发货，请更换“补货原因”或将“可超量发货”设置为“是”。")
-        elif float_compare(self.plan_uom_qty, self.product_uom_qty,
+        elif float_compare(self.plan_uom_qty, self.product_uom_qty,precision_rounding=self.product_id.uom_id.rounding) == 1:
-                           precision_rounding=self.product_id.uom_id.rounding) == 1:
             return {
                 'name': _('需求计划'),
                 'type': 'ir.actions.act_window',
@@ -710,49 +666,18 @@ class SfProductionDemandPlan(models.Model):
         self.action_confirm()
 
     def action_confirm(self):
-        """
+        self = self.with_context(
-        确认需求计划行，创建 BOM、触发库存规则，并更新状态。
+            demand_plan_line_id=self.id
-        """
+        )
-        # 将当前需求计划行 ID 写入上下文，便于后续方法使用
-        self = self.with_context(demand_plan_line_id=self.id)
-
-        # 创建物料清单（BOM），根据供货方式进行不同的处理
         self.mrp_bom_create()
-
-        # 启动库存规则（创建采购、生产等）
         self._action_launch_stock_rule()
-
-        # 根据供货方式设置状态字段
         if self.supply_method in ('automation', 'manual'):
-            self.write({'status': '50'})  # 自动/手工 供货：待排产
+            self.write({'status': '50'})
-            self.update_sale_order_state()
         else:
-            self.write({'status': '60'})  # 外购/外协/客户自供：无需排产
+            self.write({'status': '60'})
             self.update_sale_order_state()
 
-
-    def _get_embryo_template_by_supply_method(self):
-        """
-        根据供货方式返回对应的胚料模板 product.template 记录。
-        """
-        supply_map = {
-            'automation': self.env.ref('sf_dlm.product_embryo_sf_self_machining').sudo(),
-            'outsourcing': self.env.ref('sf_dlm.product_embryo_sf_outsource').sudo(),
-            'purchase': self.env.ref('sf_dlm.product_embryo_sf_purchase').sudo(),
-            'manual': self.env.ref('jikimo_sale_multiple_supply_methods.product_template_manual_processing').sudo(),
-            'material_customer_provided': self.env.ref('jikimo_sale_multiple_supply_methods.product_template_embryo_customer_provided').sudo(),
-        }
-        template = supply_map.get(self.supply_method)
-        if not template:
-            raise UserError(f"未配置供货方式 {self.supply_method} 对应的胚料模板")
-        return template
-
-
     def mrp_bom_create(self):
-        """
-        创建 BOM（包含胚料与成品 BOM），用于后续生产或采购流程。
-        """
-        # 如果同一计划中已有对应的 BOM 可复用，则直接使用
         if self.supply_method in ('automation', 'manual'):
             line_ids = self.demand_plan_id.line_ids.filtered(
                 lambda p: p.supply_method in ('automation', 'manual') and p.status in ('50', '60'))
@@ -765,32 +690,32 @@ class SfProductionDemandPlan(models.Model):
             if line_ids:
                 self.bom_id = line_ids[0].bom_id.id
                 return
-
-        # 根据供货方式选择模板和 BOM 类型
         bom_type = ''
+        # 根据供货方式修改成品模板
         if self.supply_method == 'automation':
             bom_type = 'normal'
             product_template_id = self.env.ref('sf_dlm.product_template_sf').sudo().product_tmpl_id
         elif self.supply_method == 'outsourcing':
             bom_type = 'subcontract'
-            product_template_id = self.env.ref('jikimo_sale_multiple_supply_methods.product_template_outsourcing').sudo()
+            product_template_id = self.env.ref(
+                'jikimo_sale_multiple_supply_methods.product_template_outsourcing').sudo()
         elif self.supply_method == 'purchase':
-            product_template_id = self.env.ref('jikimo_sale_multiple_supply_methods.product_template_purchase').sudo()
+            product_template_id = self.env.ref(
+                'jikimo_sale_multiple_supply_methods.product_template_purchase').sudo()
         elif self.supply_method == 'manual':
             bom_type = 'normal'
-            product_template_id = self.env.ref('jikimo_sale_multiple_supply_methods.product_template_manual_processing').sudo()
+            product_template_id = self.env.ref(
+                'jikimo_sale_multiple_supply_methods.product_template_manual_processing').sudo()
 
-        # 使用模板复制内容到当前产品
+        # 复制成品模板上的属性
         self.product_id.product_tmpl_id.copy_template(product_template_id)
-
-        # 构造 BOM 编码（包含时间戳）
         future_time = datetime.now() + timedelta(hours=8)
+        # 生成BOM单据编码
         code = f"{self.product_id.default_code}-{bom_type}-{future_time.strftime('%Y%m%d%H%M%S')}"
 
         order_id = self.sale_order_id
         product = self.product_id
-
+        # 拼接方法需要的item结构，成品的模型数据信息就是坯料的数据信息
-        # 构造胚料产品的参数
         item = {
             'texture_code': product.materials_id.materials_no,
             'texture_type_code': product.materials_type_id.materials_no,
@@ -803,81 +728,110 @@ class SfProductionDemandPlan(models.Model):
             'embryo_redundancy_id': self.sale_order_line_id.embryo_redundancy_id,
             'model_id': self.model_id
         }
-
-        # 从产品名中提取编号（如 S12345-3）
         product_name = ''
         match = re.search(r'(S\d{5}-\d+)', product.name)
         product_seria = 0
+        # 如果匹配成功，提取结果
         if match:
             product_name = match.group(0)
+            # 获取成品名结尾-n的n
             product_seria = int(product_name.split('-')[-1])
 
-        # 如果供货方式不是采购，则需要先创建胚料产品
+        # 成品供货方式为采购则不生成bom
         if self.supply_method != 'purchase':
-            # 判断是否为客户自供
+            # 当成品上带有客供料选项时，生成坯料时选择“客供料”路线
             if self.sale_order_line_id.embryo_redundancy_id:
-                embryo_template = self.env.ref('jikimo_sale_multiple_supply_methods.product_template_embryo_customer_provided').sudo()
+                # 将成品模板的内容复制到成品上
-                embryo_key = 'material_customer_provided'
+                customer_provided_embryo = self.env.ref(
-            else:
+                    'jikimo_sale_multiple_supply_methods.product_template_embryo_customer_provided').sudo()
-                embryo_template = self._get_embryo_template_by_supply_method()
+                # 创建坯料，客供料的批量不需要创建bom
-                embryo_key = self.supply_method
+                material_customer_provided_embryo = self.env['product.template'].sudo().no_bom_product_create(
-
+                    customer_provided_embryo.with_context(active_test=False).product_variant_id,
-            # 获取批次追踪方式
+                    item,
-            tracking_method = embryo_template.tracking
+                    order_id, 'material_customer_provided', product_seria, product)
-
+                # 成品配置bom
-            # 创建胚料产品（无 BOM 产品）
+                product_bom_material_customer_provided = self.env['mrp.bom'].with_user(
-            embryo_product = self.env['product.template'].sudo().no_bom_product_create(
+                    self.env.ref("base.user_admin")).bom_create(
-                embryo_template.with_context(active_test=False).product_variant_id,
+                    product, bom_type, 'product', code)
-                item,
+                product_bom_material_customer_provided.with_user(
-                order_id,
+                    self.env.ref("base.user_admin")).bom_create_line_has(
-                embryo_key,
+                    material_customer_provided_embryo)
-                product_seria,
+                self.bom_id = product_bom_material_customer_provided.id
-                product
+            elif self.product_id.materials_type_id.gain_way == '自加工':
-            )
+                self_machining_id = self.env.ref('sf_dlm.product_embryo_sf_self_machining').sudo()
-
+                # 创建坯料
-            if embryo_product == -3:
+                self_machining_embryo = self.env['product.template'].sudo().no_bom_product_create(
-                raise UserError('该订单模型的材料型号暂未设置获取方式和供应商,请先配置再进行分配')
+                    self_machining_id,
-
+                    item,
-            # 设置胚料 BOM 类型
+                    order_id, 'self_machining', product_seria, product)
-            if embryo_key in ('automation', 'manual', 'material_customer_provided'):
+                # 创建坯料的bom
-                embryo_bom_type = 'normal'
+                self_machining_bom = self.env['mrp.bom'].with_user(
-            elif embryo_key == 'outsourcing':
+                    self.env.ref("base.user_admin")).bom_create(
-                embryo_bom_type = 'subcontract'
+                    self_machining_embryo, 'normal', False)
-            elif embryo_key == 'purchase':
+                # 创建坯料里bom的组件
-                embryo_bom_type = 'purchase'
+                self_machining_bom_line = self_machining_bom.with_user(
-            else:
+                    self.env.ref("base.user_admin")).bom_create_line(
-                embryo_bom_type = 'normal'
+                    self_machining_embryo)
-
+                if not self_machining_bom_line:
-            # 创建胚料 BOM 及 BOM 行
+                    raise UserError('该订单模型的材料型号暂未有原材料,请先配置再进行分配')
-            embryo_bom = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).bom_create(
+                # 产品配置bom
-                embryo_product, embryo_bom_type, True, tracking=tracking_method)
+                product_bom_self_machining = self.env['mrp.bom'].with_user(
-
+                    self.env.ref("base.user_admin")).bom_create(
-            embryo_bom_line = embryo_bom.with_user(self.env.ref("base.user_admin")).bom_create_line(embryo_product)
+                    product, bom_type, 'product', code)
-            if not embryo_bom_line:
+                product_bom_self_machining.with_user(self.env.ref("base.user_admin")).bom_create_line_has(
-                raise UserError('该订单模型的材料型号暂未有原材料,请先配置再进行分配')
+                    self_machining_embryo)
-
+                self.bom_id = product_bom_self_machining.id
-            # 创建成品 BOM（包含胚料）
+            elif self.product_id.materials_type_id.gain_way == '外协':
-            product_bom = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).bom_create(
+                outsource_id = self.env.ref('sf_dlm.product_embryo_sf_outsource').sudo()
-                product, bom_type, 'product', code, tracking=tracking_method)
+                # 创建坯料
-            product_bom.with_user(self.env.ref("base.user_admin")).bom_create_line_has(embryo_product)
+                outsource_embryo = self.env['product.template'].sudo().no_bom_product_create(outsource_id,
-
+                                                                                             item,
-            # 赋值 BOM ID
+                                                                                             order_id,
-            self.bom_id = product_bom.id
+                                                                                             'subcontract',
-
+                                                                                             product_seria,
+                                                                                             product)
+                if outsource_embryo == -3:
+                    raise UserError('该订单模型的材料型号暂未设置获取方式和供应商,请先配置再进行分配')
+                # 创建坯料的bom
+                outsource_bom = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).bom_create(
+                    outsource_embryo,
+                    'subcontract', True)
+                # 创建坯料的bom的组件
+                outsource_bom_line = outsource_bom.with_user(
+                    self.env.ref("base.user_admin")).bom_create_line(outsource_embryo)
+                if not outsource_bom_line:
+                    raise UserError('该订单模型的材料型号暂未有原材料,请先配置再进行分配')
+                # 产品配置bom
+                product_bom_outsource = self.env['mrp.bom'].with_user(
+                    self.env.ref("base.user_admin")).bom_create(product, bom_type, 'product', code)
+                product_bom_outsource.with_user(self.env.ref("base.user_admin")).bom_create_line_has(
+                    outsource_embryo)
+                self.bom_id = product_bom_outsource.id
+            elif self.product_id.materials_type_id.gain_way == '采购':
+                purchase_id = self.env.ref('sf_dlm.product_embryo_sf_purchase').sudo()
+                purchase_embryo = self.env['product.template'].sudo().no_bom_product_create(purchase_id,
+                                                                                            item,
+                                                                                            order_id,
+                                                                                            'purchase',
+                                                                                            product_seria,
+                                                                                            product)
+                if purchase_embryo and purchase_embryo == -3:
+                    raise UserError('该订单模型的材料型号暂未设置获取方式和供应商,请先配置再进行分配')
+                else:
+                    # 产品配置bom
+                    product_bom_purchase = self.env['mrp.bom'].with_user(
+                        self.env.ref("base.user_admin")).bom_create(product, bom_type, 'product', code)
+                    product_bom_purchase.with_user(self.env.ref("base.user_admin")).bom_create_line_has(
+                        purchase_embryo)
+                    self.bom_id = product_bom_purchase.id
 
     def _action_launch_stock_rule(self):
-        """
-        触发库存规则（如采购、生产），并确认相关拣货单。
-        """
         procurements = []
-
         group_id = self.sale_order_id.procurement_group_id
         if not group_id:
-            # 没有分组则创建
             group_id = self.env['procurement.group'].create(self._prepare_procurement_group_vals())
             self.sale_order_id.procurement_group_id = group_id
         else:
-            # 若已有分组但字段有变动则更新
             updated_vals = {}
             if group_id.partner_id != self.sale_order_id.partner_shipping_id:
                 updated_vals.update({'partner_id': self.sale_order_id.partner_shipping_id.id})
@@ -885,42 +839,27 @@ class SfProductionDemandPlan(models.Model):
                 updated_vals.update({'move_type': self.sale_order_id.picking_policy})
             if updated_vals:
                 group_id.write(updated_vals)
-
-        # 构造 procurement 所需的字段
         values = self._prepare_procurement_values(group_id=group_id)
-
-        # 单位换算
         line_uom = self.sale_order_line_id.product_uom
         quant_uom = self.product_id.uom_id
         plan_uom_qty, procurement_uom = line_uom._adjust_uom_quantities(self.plan_uom_qty, quant_uom)
-
-        # 创建 procurement 请求
         procurements.append(self.env['procurement.group'].Procurement(
             self.product_id, plan_uom_qty, procurement_uom,
             self.sale_order_id.partner_shipping_id.property_stock_customer,
             self.product_id.display_name, self.sale_order_id.name, self.sale_order_id.company_id, values))
-
-        # 执行调度
         if procurements:
             procurement_group = self.env['procurement.group']
             if self.env.context.get('import_file'):
                 procurement_group = procurement_group.with_context(import_file=False)
             procurement_group.run(procurements)
-
-        # 确认相关的拣货单
         orders = self.mapped('sale_order_id')
         for order in orders:
             pickings_to_confirm = order.picking_ids.filtered(lambda p: p.state not in ['cancel', 'done'])
             if pickings_to_confirm:
                 pickings_to_confirm.action_confirm()
-
         return True
 
-
     def _prepare_procurement_group_vals(self):
-        """
-        构造创建 procurement group 所需的字段。
-        """
         return {
             'name': self.sale_order_id.name,
             'move_type': self.sale_order_id.picking_policy,
@@ -928,18 +867,11 @@ class SfProductionDemandPlan(models.Model):
             'partner_id': self.sale_order_id.partner_shipping_id.id,
         }
 
-
     def _prepare_procurement_values(self, group_id=False):
-        """
-        构造单个 procurement 请求所需的字段字典。
-        """
         self.ensure_one()
-
-        # 交货日期与计划日期
         date_deadline = self.sale_order_id.commitment_date or (
-            self.sale_order_id.date_order + timedelta(days=self.sale_order_line_id.customer_lead or 0.0))
+                self.sale_order_id.date_order + timedelta(days=self.sale_order_line_id.customer_lead or 0.0))
         date_planned = date_deadline - timedelta(days=self.sale_order_id.company_id.security_lead)
-
         values = {
             'group_id': group_id,
             'sale_line_id': self.sale_order_line_id.id,
@@ -955,6 +887,4 @@ class SfProductionDemandPlan(models.Model):
             'sequence': self.sale_order_line_id.sequence,
             'demand_plan_line_id': self.id
         }
-
         return values
-

sf_demand_plan/static/src/scss/style.css

@@ -83,7 +83,7 @@
     }
 }
 
-/*.demand_plan_tree th[data-name=planned_start_date] + th::before{*/
+th[data-name=processing_time] + th::before{
-/*    content: '待执行单据';*/
+    content: '待执行单据';
-/*    line-height: 38px;*/
+    line-height: 38px;
-/*}*/
+}

sf_demand_plan/views/demand_plan.xml

@@ -22,7 +22,6 @@
                 <field name="model_id" optional="hide"/>
                 <field name="part_name"/>
                 <field name="part_number"/>
-                <field name="manual_quotation" optional="hide"/>
                 <field name="is_incoming_material"/>
                 <field name="new_supply_method" attrs="{'readonly': [('status', '!=', '30')]}"/>
                 <field name="readonly_custom_made_type" invisible="1"/>
@@ -32,14 +31,13 @@
                 <field name="product_uom_qty"/>
                 <field name="plan_uom_qty" attrs="{'readonly': [('status', '!=', '30')]}"/>
                 <field name="deadline_of_delivery"/>
-                <field name="inventory_quantity_auto_apply" optional="hide"/>
+                <field name="inventory_quantity_auto_apply"/>
-                <field name="qty_delivered" optional="hide"/>
+                <field name="qty_delivered"/>
-                <field name="qty_to_deliver" optional="hide"/>
+                <field name="qty_to_deliver"/>
                 <field name="model_long"/>
                 <field name="blank_type" optional="hide"/>
                 <field name="blank_precision"/>
                 <field name="embryo_long"/>
-                <field name="unit_number" optional="hide"/>
                 <field name="materials_id"/>
                 <field name="model_machining_precision"/>
                 <field name="model_process_parameters_ids" widget="many2many_tags"/>

sf_demand_plan/views/demand_plan_info.xml

@@ -14,15 +14,12 @@
                 <sheet>
                     <group>
                         <group>
-                            <field name="demand_plan_number"/>
                             <field name="product_id"/>
                             <field name="part_name"/>
                             <field name="part_number"/>
                             <field name="materials_id"/>
                             <field name="blank_type"/>
-                            <field name="blank_precision"/>
                             <field name="embryo_long"/>
-                            <field name="manual_quotation"/>                      
                             <field name="is_incoming_material"/>
                             <field name="pending_qty"/>
                             <field name="planned_qty"/>
@@ -39,46 +36,12 @@
                             <field name="inventory_quantity_auto_apply"/>
                             <field name="priority" attrs="{'readonly': [('state',  'in', ('40','50'))]}"/>
                             <field name="overdelivery_allowed"/>
-                            <field name="origin"/>
                         </group>
                     </group>
                     <notebook>
                         <page string="计划">
-                            <field name="line_ids" attrs="{'invisible': [('state', 'in', ('40','50'))]}">
+                            <field name="line_ids" attrs="{'readonly': [('state', 'in', ('40','50'))]}">
-                                <tree editable="bottom" create="false" delete="false">
+                                <tree editable="bottom" delete="false">
-                                    <field name="status"/>
-                                    <field name="readonly_custom_made_type" invisible="1"/>
-                                    <field name="new_supply_method" attrs="{'readonly': [('status', '!=', '30')]}"/>
-                                    <field name="custom_made_type"
-                                           attrs="{
-                                             'readonly': ['|', '|', ('new_supply_method', '!=', 'custom_made'), ('status', '!=', '30'), ('readonly_custom_made_type', '=', True)],
-                                             'required': [('new_supply_method', '=', 'custom_made')]}"/>
-                                    <field name="route_ids" widget="many2many_tags" optional="hide"/>
-                                    <field name="location_id" optional="hide"/>
-                                    <field name="bom_id" optional="hide"/>
-                                    <field name="processing_time" optional="hide"/>
-                                    <field name="plan_uom_qty" attrs="{'readonly': [('status', '!=', '30')]}"/>
-                                    <field name="blank_arrival_date"/>
-                                    <field name="finished_product_arrival_date"/>
-                                    <field name="planned_start_date"/>
-                                    <field name="actual_start_date"/>
-                                    <field name="actual_end_date"/>
-                                    <field name="plan_remark"/>
-                                    <field name="procurement_reason"/>
-                                    <field name="write_date" string="更新时间"/>
-                                    <field name="hide_release_production_order" invisible="1"/>
-                                    <button string="下达计划" name="button_release_plan" type="object"
-                                            class="btn-primary"
-                                            attrs="{'invisible': [('status', 'in', ('50','60','100'))]}"
-                                    />
-                                    <button name="button_release_production" type="object" string="下发生产"
-                                            class="btn-primary"
-                                            attrs="{'invisible': [('hide_release_production_order', '=', False)]}"
-                                    />
-                                </tree>
-                            </field>
-                            <field name="line_ids" attrs="{'invisible': [('state', 'not in', ('40','50'))]}">
-                                <tree editable="bottom">
                                     <field name="status"/>
                                     <field name="readonly_custom_made_type" invisible="1"/>
                                     <field name="new_supply_method" attrs="{'readonly': [('status', '!=', '30')]}"/>
@@ -89,7 +52,6 @@
                                     <field name="route_ids" widget="many2many_tags" optional="hide"/>
                                     <field name="location_id" optional="hide"/>
                                     <field name="bom_id" optional="hide" readonly="1" options="{'no_create': True}"/>
-                                    <field name="processing_time" optional="hide"/>
                                     <field name="plan_uom_qty" attrs="{'readonly': [('status', '!=', '30')]}"/>
                                     <field name="blank_arrival_date"/>
                                     <field name="finished_product_arrival_date"/>
@@ -108,6 +70,10 @@
                                             class="btn-primary"
                                             attrs="{'invisible': [('hide_release_production_order', '=', False)]}"
                                     />
+                                    <button name="button_delete" type="object" string="删除"
+                                            class="btn-primary"
+                                            attrs="{'invisible': [('status', 'not in', ('10','20','30'))]}"
+                                            confirm='是否确认删除？'/>
                                 </tree>
                             </field>
                         </page>

sf_manufacturing/models/stock.py

@@ -217,8 +217,7 @@ class StockRule(models.Model):
                 '''
                 创建制造订单时生成序列号
                 '''
-                if production.product_id.tracking != "none":
+                production.action_generate_serial()
-                    production.action_generate_serial()
                 origin_production = production.move_dest_ids and production.move_dest_ids[
                     0].raw_material_production_id or False
                 orderpoint = production.orderpoint_id
@@ -443,7 +442,7 @@ class ProductionLot(models.Model):
     @api.model
     def _get_next_serial(self, company, product):
         """Return the next serial number to be attributed to the product."""
-        if product.tracking != "none":
+        if product.tracking == "serial":
             last_serial = self.env['stock.lot'].search(
                 [('company_id', '=', company.id), ('product_id', '=', product.id), ('name', 'ilike', product.name)],
                 limit=1, order='name desc')
@@ -454,9 +453,7 @@ class ProductionLot(models.Model):
                 return self.env['stock.lot'].generate_lot_names1(product.name, last_serial.name if (
                         not move_line_id or
                         (last_serial and last_serial.name > move_line_id.lot_name)) else move_line_id.lot_name, 2)[1]
-            else:
+        return "%s-%03d" % (product.name, 1)
-                return "%s-%03d" % (product.name, 1)
-        return False
 
     qr_code_image = fields.Binary(string='二维码', compute='_generate_qr_code')
 

sf_mrs_connect/controllers/__init__.py

@@ -1,2 +1 @@
 from . import controllers
-from . import sync_controller

sf_mrs_connect/controllers/sync_controller.py

@@ -1,22 +0,0 @@
-# study/jikimo_sf/sf_mrs_connect/controllers/sync_controller.py
-from odoo import http
-from odoo.http import request
-
-class FixtureSyncController(http.Controller):
-
-    @http.route('/api/fixture_model/sync_from_mrs', type='json', auth='none', csrf=False)
-    def sync_model(self, **kw):
-        code = kw.get('code')
-        if not code:
-            return {'status':'fail','msg':'code missing'}
-        request.env['sf.fixture.model'].sudo().sync_from_mrs(code)
-        return {'status':'success'}
-
-    @http.route('/api/fixture_param/sync_from_mrs', type='json', auth='none', csrf=False)
-    def sync_param(self, **kw):
-        code = kw.get('code')
-        if not code:
-            return {'status':'fail','msg':'code missing'}
-        request.env['sf.fixture.materials.basic.parameters']\
-            .sudo().sync_from_mrs(code)
-        return {'status':'success'}

sf_mrs_connect/models/common.py

@@ -1,14 +0,0 @@
-# study/jikimo_sf/sf_mrs_connect/models/common.py
-import time, hashlib
-
-class Common:
-    @staticmethod
-    def get_headers(token, secret_key):
-        ts = str(int(time.time()))
-        sign = hashlib.sha256(f"{token}{secret_key}{ts}".encode()).hexdigest()
-        return {
-            "token": token,
-            "sign": sign,
-            "timestamp": ts,
-            "Content-Type": "application/json",
-        }

sf_mrs_connect/models/redis_utils.py

@@ -1,30 +0,0 @@
-# study/jikimo_sf/sf_mrs_connect/models/redis_utils.py
-import redis, json, logging
-
-_logger = logging.getLogger(__name__)
-
-class RedisClient:
-    def __init__(self, host='localhost', port=6379, db=0):
-        try:
-            self.client = redis.Redis(host=host, port=port, db=db, decode_responses=True)
-        except Exception as e:
-            _logger.error(f"Redis init error: {e}")
-            self.client = None
-
-    def get_json(self, key):
-        if not self.client:
-            return None
-        try:
-            data = self.client.get(key)
-            return json.loads(data) if data else None
-        except Exception as e:
-            _logger.error(f"Redis GET error [{key}]: {e}")
-            return None
-
-    def set_json(self, key, value, ex=3600):
-        if not self.client:
-            return
-        try:
-            self.client.set(key, json.dumps(value, ensure_ascii=False), ex=ex)
-        except Exception as e:
-            _logger.error(f"Redis SET error [{key}]: {e}")

sf_mrs_connect/models/sync_common.py

@@ -5,11 +5,9 @@ import base64
 import traceback
 
 import requests
-from odoo import models,api,fields
+from odoo import models
 from odoo.exceptions import ValidationError
-from .redis_utils import RedisClient
+from odoo.addons.sf_base.commons.common import Common
-from .common import Common
-from odoo.addons.jikimo_sf.sf_base.commons.common import Common
 
 _logger = logging.getLogger(__name__)
 
@@ -1508,157 +1506,149 @@ class SyncMulti_Mounting_Type(models.Model):
             raise ValidationError("联装类型认证未通过")
 
 
-# class SyncFixtureModel(models.Model):
+class SyncFixtureModel(models.Model):
-#     _inherit = 'sf.fixture.model'
+    _inherit = 'sf.fixture.model'
-#     _description = '同步夹具型号列表'
+    _description = '同步夹具型号列表'
 
-#     url = '/api/fixture_model/list'
+    url = '/api/fixture_model/list'
 
-#     # 定时同步夹具型号列表
+    # 定时同步夹具型号列表
-#     def sync_fixture_model_yesterday(self):
+    def sync_fixture_model_yesterday(self):
-#         config = self.env['res.config.settings'].get_values()
+        config = self.env['res.config.settings'].get_values()
-#         headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
-#         strUrl = config['sf_url'] + self.url
+        strUrl = config['sf_url'] + self.url
-#         r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
-#         r = r.json()
+        r = r.json()
-#         result = json.loads(r['result'])
+        result = json.loads(r['result'])
-#         if result['status'] == 1:
+        if result['status'] == 1:
-#             if result.get('fixture_model_yesterday_list'):
+            if result.get('fixture_model_yesterday_list'):
-#                 for item in result['fixture_model_yesterday_list']:
+                for item in result['fixture_model_yesterday_list']:
-#                     if item:
+                    if item:
-#                         fixture_model = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
+                        fixture_model = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
-#                         val = {
+                        val = {
-#                             "name": item['name'],
+                            "name": item['name'],
-#                             "code": item['code'],
+                            "code": item['code'],
-#                             "fixture_material_id": self.env['sf.fixture.material'].search(
+                            "fixture_material_id": self.env['sf.fixture.material'].search(
-#                                 [('code', '=', item['fixture_material_code'])]).id,
+                                [('code', '=', item['fixture_material_code'])]).id,
-#                             "multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
+                            "multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
-#                                 [('code', '=', item['multi_mounting_type_code'])]).id,
+                                [('code', '=', item['multi_mounting_type_code'])]).id,
-#                             "brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
+                            "brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
-#                             "model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
+                            "model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
-#                             "status": item['status'],
+                            "status": item['status'],
-#                             "active": item['active'],
+                            "active": item['active'],
-#                         }
+                        }
-#                         if not fixture_model:
+                        if not fixture_model:
-#                             self.create(val)
+                            self.create(val)
-#                         else:
+                        else:
-#                             fixture_model.write(val)
+                            fixture_model.write(val)
 
-#         else:
+        else:
-#             raise ValidationError("夹具型号认证未通过")
+            raise ValidationError("夹具型号认证未通过")
 
-#     # 定时同步所有夹具型号列表
+    # 定时同步所有夹具型号列表
-# def sync_all_fixture_model(self):
+    def sync_all_fixture_model(self):
-#         config = self.env['res.config.settings'].get_values()
+        config = self.env['res.config.settings'].get_values()
-#         headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
-#         strUrl = config['sf_url'] + self.url
+        strUrl = config['sf_url'] + self.url
-#         r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
-#         r = r.json()
+        r = r.json()
-#         result = json.loads(r['result'])
+        result = json.loads(r['result'])
-#         # print('result:%s' % result)
+        # print('result:%s' % result)
-#         if result['status'] == 1:
+        if result['status'] == 1:
-#             if result.get('fixture_model_all_list'):
+            if result.get('fixture_model_all_list'):
-#                 for item in result['fixture_model_all_list']:
+                for item in result['fixture_model_all_list']:
-#                     if item:
+                    if item:
-#                         fixture_model = self.search([('code', '=', item['code']), ('active', 'in', [True, False])])
+                        fixture_model = self.search([('code', '=', item['code']), ('active', 'in', [True, False])])
-#                         val = {
+                        val = {
-#                             "name": item['name'],
+                            "name": item['name'],
-#                             "code": item['code'],
+                            "code": item['code'],
-#                             "fixture_material_id": self.env['sf.fixture.material'].search(
+                            "fixture_material_id": self.env['sf.fixture.material'].search(
-#                                 [('code', '=', item['fixture_material_code'])]).id,
+                                [('code', '=', item['fixture_material_code'])]).id,
-#                             "multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
+                            "multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
-#                                 [('code', '=', item['multi_mounting_type_code'])]).id,
+                                [('code', '=', item['multi_mounting_type_code'])]).id,
-#                             "brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
+                            "brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
-#                             "model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
+                            "model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
-#                             "status": item['status'],
+                            "status": item['status'],
-#                             "active": item['active'],
+                            "active": item['active'],
-#                         }
+                        }
-#                         if not fixture_model:
+                        if not fixture_model:
-#                             self.create(val)
+                            self.create(val)
-#                         else:
+                        else:
-#                             fixture_model.write(val)
+                            fixture_model.write(val)
-#         else:
+        else:
-#             raise ValidationError("夹具型号认证未通过")
+            raise ValidationError("夹具型号认证未通过")
 
 
-# class SyncfixtureMaterialsBasicParameters(models.Model):
+class SyncfixtureMaterialsBasicParameters(models.Model):
-#     _inherit = 'sf.fixture.materials.basic.parameters'
+    _inherit = 'sf.fixture.materials.basic.parameters'
-#     _description = '同步夹具型号基本参数列表'
+    _description = '同步夹具型号基本参数列表'
 
-#     url = '/api/fixture_parameters/list'
+    url = '/api/fixture_parameters/list'
 
-#     # 定时同步夹具型号基本信息
+    # 定时同步夹具型号基本信息
-#     def sync_fixture_materials_basic_parameters_yesterday(self):
+    def sync_fixture_materials_basic_parameters_yesterday(self):
-#         config = self.env['res.config.settings'].get_values()
+        config = self.env['res.config.settings'].get_values()
-#         headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
-#         strUrl = config['sf_url'] + self.url
+        strUrl = config['sf_url'] + self.url
-#         r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
-#         r = r.json()
+        r = r.json()
-#         result = json.loads(r['result'])
+        result = json.loads(r['result'])
-#         if result['status'] == 1:
+        if result['status'] == 1:
-#             if result.get('fixture_parameters_yesterday_list'):
+            if result.get('fixture_parameters_yesterday_list'):
-#                 all_list = result.get('fixture_parameters_yesterday_list')
+                all_list = result.get('fixture_parameters_yesterday_list')
-#                 if all_list.get('zero_chuck_all_list'):
+                if all_list.get('zero_chuck_all_list'):
-#                     self._write_or_create(all_list.get('zero_chuck_yesterday_list'), '零点卡盘')
+                    self._write_or_create(all_list.get('zero_chuck_yesterday_list'), '零点卡盘')
-#                 if all_list.get('zero_tray_all_list'):
+                if all_list.get('zero_tray_all_list'):
-#                     self._write_or_create(all_list.get('zero_tray_yesterday_list'), '零点托盘')
+                    self._write_or_create(all_list.get('zero_tray_yesterday_list'), '零点托盘')
-#                 if all_list.get('pneumatic_fixture_all_list'):
+                if all_list.get('pneumatic_fixture_all_list'):
-#                     self._write_or_create(all_list.get('pneumatic_fixture_yesterday_list'), '气动夹具')
+                    self._write_or_create(all_list.get('pneumatic_fixture_yesterday_list'), '气动夹具')
-#                 if all_list.get('jaw_vice_all_list'):
+                if all_list.get('jaw_vice_all_list'):
-#                     self._write_or_create(all_list.get('jaw_vice_yesterday_list'), '虎钳夹具')
+                    self._write_or_create(all_list.get('jaw_vice_yesterday_list'), '虎钳夹具')
-#                 if all_list.get('magnet_fixture_all_list'):
+                if all_list.get('magnet_fixture_all_list'):
-#                     self._write_or_create(all_list.get('magnet_fixture_yesterday_list'), '磁吸夹具')
+                    self._write_or_create(all_list.get('magnet_fixture_yesterday_list'), '磁吸夹具')
-#                 if all_list.get('adapter_board_all_list'):
+                if all_list.get('adapter_board_all_list'):
-#                     self._write_or_create(all_list.get('adapter_board_yesterday_list'), '转接板(锁板)夹具')
+                    self._write_or_create(all_list.get('adapter_board_yesterday_list'), '转接板(锁板)夹具')
-#                 if all_list.get('scroll_chuck_all_list'):
+                if all_list.get('scroll_chuck_all_list'):
-#                     self._write_or_create(all_list.get('scroll_chuck_yesterday_list'), '三爪卡盘')
+                    self._write_or_create(all_list.get('scroll_chuck_yesterday_list'), '三爪卡盘')
-#                 if all_list.get('air_tray_all_list'):
+        else:
-#                     self._write_or_create(all_list.get('air_tray_all_list'),'气吹托盘')
+            raise ValidationError("夹具型号基本参数认证未通过")
-#                 if all_list.get('magnet_tray_all_list'):
-#                     self._write_or_create(all_list.get('magnet_tray_all_list'),'磁吸托盘')
-#         else:
-#             raise ValidationError("夹具型号基本参数认证未通过")
 
-#     # 定时同步所有夹具型号基本信息
+    # 定时同步所有夹具型号基本信息
-#     def sync_all_fixture_materials_basic_parameters(self):
+    def sync_all_fixture_materials_basic_parameters(self):
-#         config = self.env['res.config.settings'].get_values()
+        config = self.env['res.config.settings'].get_values()
-#         headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
-#         strUrl = config['sf_url'] + self.url
+        strUrl = config['sf_url'] + self.url
-#         r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
-#         r = r.json()
+        r = r.json()
-#         result = json.loads(r['result'])
+        result = json.loads(r['result'])
-#         if result['status'] == 1:
+        if result['status'] == 1:
-#             if result.get('fixture_parameters_all_list'):
+            if result.get('fixture_parameters_all_list'):
-#                 all_list = result.get('fixture_parameters_all_list')
+                all_list = result.get('fixture_parameters_all_list')
-#                 if all_list.get('zero_chuck_all_list'):
+                if all_list.get('zero_chuck_all_list'):
-#                     self._write_or_create(all_list.get('zero_chuck_all_list'), '零点卡盘')
+                    self._write_or_create(all_list.get('zero_chuck_all_list'), '零点卡盘')
-#                 if all_list.get('zero_tray_all_list'):
+                if all_list.get('zero_tray_all_list'):
-#                     self._write_or_create(all_list.get('zero_tray_all_list'), '零点托盘')
+                    self._write_or_create(all_list.get('zero_tray_all_list'), '零点托盘')
-#                 if all_list.get('pneumatic_fixture_all_list'):
+                if all_list.get('pneumatic_fixture_all_list'):
-#                     self._write_or_create(all_list.get('pneumatic_fixture_all_list'), '气动夹具')
+                    self._write_or_create(all_list.get('pneumatic_fixture_all_list'), '气动夹具')
-#                 if all_list.get('jaw_vice_all_list'):
+                if all_list.get('jaw_vice_all_list'):
-#                     self._write_or_create(all_list.get('jaw_vice_all_list'), '虎钳夹具')
+                    self._write_or_create(all_list.get('jaw_vice_all_list'), '虎钳夹具')
-#                 if all_list.get('magnet_fixture_all_list'):
+                if all_list.get('magnet_fixture_all_list'):
-#                     self._write_or_create(all_list.get('magnet_fixture_all_list'), '磁吸夹具')
+                    self._write_or_create(all_list.get('magnet_fixture_all_list'), '磁吸夹具')
-#                if all_list.get('adapter_board_all_list'):
+                if all_list.get('adapter_board_all_list'):
-#                     self._write_or_create(all_list.get('adapter_board_all_list'), '转接板(锁板)夹具')
+                    self._write_or_create(all_list.get('adapter_board_all_list'), '转接板(锁板)夹具')
-#                 if all_list.get('scroll_chuck_all_list'):
+                if all_list.get('scroll_chuck_all_list'):
-#                     self._write_or_create(all_list.get('scroll_chuck_all_list'), '三爪卡盘')
+                    self._write_or_create(all_list.get('scroll_chuck_all_list'), '三爪卡盘')
-#                 if all_list.get('air_tray_all_list'):
+        else:
-#                     self._write_or_create(all_list.get('air_tray_all_list'),'气吹托盘')
+            raise ValidationError("夹具型号基本参数认证未通过")
-#                 if all_list.get('magnet_tray_all_list'):
-#                     self._write_or_create(all_list.get('magnet_tray_all_list'),'磁吸托盘')
-#         else:
-#             raise ValidationError("夹具型号基本参数认证未通过")
 
-#     def _write_or_create(self, fixture_parameters_list, material_name):
+    def _write_or_create(self, fixture_parameters_list, material_name):
-#         for item in fixture_parameters_list:
+        for item in fixture_parameters_list:
-#             if item:
+            if item:
-#                 basic_parameters = self.search([('code', '=', item.get('code')), ('active', 'in', [True, False])])
+                basic_parameters = self.search([('code', '=', item.get('code')), ('active', 'in', [True, False])])
-#                 if not basic_parameters:
+                if not basic_parameters:
-#                     self.create(self._get_basic_parameters_list(item, material_name))
+                    self.create(self._get_basic_parameters_list(item, material_name))
-#                 else:
+                else:
-#                     basic_parameters.write(self._get_basic_parameters_list(item, material_name))
+                    basic_parameters.write(self._get_basic_parameters_list(item, material_name))
 
 
 class SyncFunctionalFixtureType(models.Model):
@@ -3241,93 +3231,3 @@ class EmbryoRedundancySync(models.Model):
                         "active": item['active'],
                         "remark": item['remark'],
                     })
-
-
-
-
-
-
-class SyncFixtureModel(models.Model):
-    _inherit = 'sf.fixture.model'
-    _description = 'Redis 优先同步夹具型号'
-
-    def sync_all_fixture_model(self):
-        rc = RedisClient()
-        key = 'mrs:fixture_model_all_list'
-        all_list = rc.get_json(key)
-        if not all_list:
-            raise ValidationError(f"Redis 中未找到 key={key}")
-
-        for item in all_list:
-            if not item or not item.get('code'):
-                continue
-
-            record = self.search([('code', '=', item['code'])], limit=1)
-            vals = {
-                'name': item['name'],
-                'code': item['code'],
-                'fixture_material_id': self.env['sf.fixture.material']
-                    .search([('code', '=', item['fixture_material_code'])], limit=1).id,
-                'multi_mounting_type_id': self.env['sf.multi_mounting.type']
-                    .search([('code', '=', item['multi_mounting_type_code'])], limit=1).id,
-                'brand_id': self.env['sf.machine.brand']
-                    .search([('code', '=', item['brand_code'])], limit=1).id,
-                'model_file': base64.b64decode(item['model_file']) if item.get('model_file') else False,
-                'status': item['status'],
-                'active': item['active'],
-            }
-            if record:
-                record.write(vals)
-            else:
-                self.create(vals)
-
-
-class SyncfixtureMaterialsBasicParameters(models.Model):
-    _inherit = 'sf.fixture.materials.basic.parameters'
-    _description = 'Redis 优先同步夹具基本参数'
-
-    def sync_all_fixture_materials_basic_parameters(self):
-        rc = RedisClient()
-        key = 'mrs:fixture_param_all_list'
-        all_list = rc.get_json(key)
-        if not all_list:
-            raise ValidationError(f"Redis 中未找到 key={key}")
-
-        def _sync_list(param_list, material_name):
-            for item in param_list or []:
-                if not item or not item.get('code'):
-                    continue
-                record = self.search([('code', '=', item['code'])], limit=1)
-                vals = self._get_basic_parameters_list(item, material_name)
-                if record:
-                    record.write(vals)
-                else:
-                    self.create(vals)
-
-        _sync_list(all_list.get('zero_chuck_all_list'), '零点卡盘')
-        _sync_list(all_list.get('zero_tray_all_list'), '零点托盘')
-        _sync_list(all_list.get('pneumatic_fixture_all_list'), '气动夹具')
-        _sync_list(all_list.get('jaw_vice_all_list'), '虎钳夹具')
-        _sync_list(all_list.get('magnet_fixture_all_list'), '磁吸夹具')
-        _sync_list(all_list.get('adapter_board_all_list'), '转接板(锁板)夹具')
-        _sync_list(all_list.get('scroll_chuck_all_list'), '三爪卡盘')
-        _sync_list(all_list.get('air_tray_all_list'), '气吹托盘')
-        _sync_list(all_list.get('magnet_tray_all_list'), '磁吸托盘')
-
-    def _get_basic_parameters_list(self, item, material_name):
-        """
-        统一结构化 item 数据，供写入模型字段使用（你应当根据 material_name 自定义字段映射）
-        """
-        return {
-            'name': item.get('name'),
-            'code': item.get('code'),
-            'length': item.get('length'),
-            'width': item.get('width'),
-            'height': item.get('height'),
-            'diameter': item.get('diameter'),
-            'weight': item.get('weight'),
-            'fixture_model_id': self.env['sf.fixture.model'].search([('code', '=', item.get('fixture_model_code'))], limit=1).id,
-            'materials_model_id': self.env['sf.materials.model'].search([('code', '=', item.get('material_code'))], limit=1).id,
-            'active': item.get('active', True),
-            # 你可以根据 material_name 判断类型并补充字段
-        }