是否磁吸

sf_base/models/common.py

@@ -42,6 +42,7 @@ class MrsMaterialModel(models.Model):
     materials_num = fields.Char("编码号")
     name = fields.Char('型号名')
     need_h = fields.Boolean("热处理", default="false")
+    need_m = fields.Boolean("是否磁吸", default="false")
     mf_materia_post = fields.Char("热处理后密度")
     density = fields.Float("密度(kg/m³)")
     materials_id = fields.Many2one('sf.production.materials', "材料名")

sf_base/views/common_view.xml

@@ -263,6 +263,7 @@
                                 <field name="materials_no" readonly="1" force_save="1"/>
                                 <field name="gain_way" required="0"/>
                                 <field name="density" readonly="1" required="1"  class="custom_required"/>
+                                <field name="need_m" default="false" readonly="1"/>
                             </group>
                             <group>
                                 <field name="rough_machining" required="1"/>
@@ -306,6 +307,7 @@
                     <field name="tensile_strength"/>
                     <field name="hardness" optional="show"/>
                     <field name="need_h"/>
+                    <field name="need_m"/>
                     <field name="apply" widget="many2many_tags" optional="show"/>
                     <field name="density" optional="show"/>
                     <field name="rough_machining" optional="hide"/>
@@ -352,6 +354,7 @@
                                             <field name="materials_no"/>
                                             <field name="name"/>
                                             <field name="need_h"/>
+                                            <field name="need_m"/>
                                             <field name="mf_materia_post"/>
                                             <field name="density"/>
                                             <field name='materials_id' default="default" invisible="1"/>

sf_demand_plan/__manifest__.py

@@ -30,7 +30,6 @@
         'web.assets_backend': [
             'sf_demand_plan/static/src/scss/style.css',
             'sf_demand_plan/static/src/js/print_demand.js',
-            'sf_demand_plan/static/src/js/custom_button.js',
         ]
     },
     'license': 'LGPL-3',

sf_demand_plan/models/purchase_order.py

@@ -36,7 +36,7 @@ class PurchaseOrderLine(models.Model):
     @api.model
     def create(self, vals):
         res = super(PurchaseOrderLine, self).create(vals)
-        if not res.demand_plan_line_id and res.order_id.origin:
+        if not res.demand_plan_line_id:
             origin = [origin.replace(' ', '') for origin in res.order_id.origin.split(',')]
             if self.env.context.get('demand_plan_line_id'):
                 res.demand_plan_line_id = self.env.context.get('demand_plan_line_id')

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'
@@ -710,49 +688,19 @@ 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 +713,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,84 +751,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 isinstance(embryo_product, models.Model):  # 确保返回的是记录而非错误码
+                self_machining_embryo = self.env['product.template'].sudo().no_bom_product_create(
-                embryo_product.write({'tracking': tracking_method})
+                    self_machining_id,
-
+                    item,
-            if embryo_product == -3:
+                    order_id, 'self_machining', product_seria, product)
-                raise UserError('该订单模型的材料型号暂未设置获取方式和供应商,请先配置再进行分配')
+                # 创建坯料的bom
-
+                self_machining_bom = self.env['mrp.bom'].with_user(
-            # 设置胚料 BOM 类型
+                    self.env.ref("base.user_admin")).bom_create(
-            if embryo_key in ('automation', 'manual', 'material_customer_provided'):
+                    self_machining_embryo, 'normal', False)
-                embryo_bom_type = 'normal'
+                # 创建坯料里bom的组件
-            elif embryo_key == 'outsourcing':
+                self_machining_bom_line = self_machining_bom.with_user(
-                embryo_bom_type = 'subcontract'
+                    self.env.ref("base.user_admin")).bom_create_line(
-            elif embryo_key == 'purchase':
+                    self_machining_embryo)
-                embryo_bom_type = 'purchase'
+                if not self_machining_bom_line:
-            else:
+                    raise UserError('该订单模型的材料型号暂未有原材料,请先配置再进行分配')
-                embryo_bom_type = 'normal'
+                # 产品配置bom
-
+                product_bom_self_machining = self.env['mrp.bom'].with_user(
-            # 创建胚料 BOM 及 BOM 行
+                    self.env.ref("base.user_admin")).bom_create(
-            embryo_bom = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).bom_create(
+                    product, bom_type, 'product', code)
-                embryo_product, embryo_bom_type, True, tracking=tracking_method)
+                product_bom_self_machining.with_user(self.env.ref("base.user_admin")).bom_create_line_has(
-
+                    self_machining_embryo)
-            embryo_bom_line = embryo_bom.with_user(self.env.ref("base.user_admin")).bom_create_line(embryo_product)
+                self.bom_id = product_bom_self_machining.id
-            if not embryo_bom_line:
+            elif self.product_id.materials_type_id.gain_way == '外协':
-                raise UserError('该订单模型的材料型号暂未有原材料,请先配置再进行分配')
+                outsource_id = self.env.ref('sf_dlm.product_embryo_sf_outsource').sudo()
-
+                # 创建坯料
-            # 创建成品 BOM（包含胚料）
+                outsource_embryo = self.env['product.template'].sudo().no_bom_product_create(outsource_id,
-            product_bom = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).bom_create(
+                                                                                             item,
-                product, bom_type, 'product', code, tracking=tracking_method)
+                                                                                             order_id,
-            product_bom.with_user(self.env.ref("base.user_admin")).bom_create_line_has(embryo_product)
+                                                                                             'subcontract',
-
+                                                                                             product_seria,
-            # 赋值 BOM ID
+                                                                                             product)
-            self.bom_id = product_bom.id
+                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})
@@ -888,42 +862,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,
@@ -931,18 +890,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,
@@ -958,6 +910,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/js/custom_button.js

@@ -1,59 +0,0 @@
-/** @odoo-module **/
-
-import { registry } from "@web/core/registry";
-import { ListRenderer } from "@web/views/list/list_renderer";
-import { useService } from "@web/core/utils/hooks";
-import { useEffect } from "@odoo/owl";
-
-export class CustomDemandPlanListRenderer extends ListRenderer {
-    setup() {
-        super.setup();
-        this.orm = useService("orm");
-        this.notification = useService("notification");
-        console.log('setup', this.props);
-
-        // 监听selection属性的变化
-        useEffect(() => {
-            this.updateButtonState();
-        }, () => [this.props.list.selection]);
-    }
-
-    /**
-     * 更新按钮状态
-     */
-    async updateButtonState() {
-        const selectedRecords = this.props.list.selection;
-        const isStatus30 = selectedRecords.some(record => record.data.status != "30");
-        const button = $(this.__owl__.parent.bdom.parentEl).find('button[name="button_batch_release_plan"]');
-        console.log('isStatus30', isStatus30, button);
-        if (isStatus30) {
-            // 禁用按钮
-            button.attr('disabled', true);
-        } else {
-            button.attr('disabled', false);
-        }
-    }
-}
-// 使用setTimeout延迟注册，避免在模块加载时立即执行
-setTimeout(() => {
-    const registerCustomRenderer = () => {
-        try {
-            const listView = registry.category("views").get("list");
-            if (listView) {
-                registry.category("views").add("custom_demand_plan_list", {
-                    ...listView,
-                    Renderer: CustomDemandPlanListRenderer,
-                });
-                console.log("Custom demand plan list renderer registered successfully");
-            } else {
-                console.warn("List view not found, retrying...");
-                // 如果还没找到，再等一段时间
-                setTimeout(registerCustomRenderer, 1000);
-            }
-        } catch (error) {
-            console.error("Error registering custom renderer:", error);
-        }
-    };
-
-    registerCustomRenderer();
-}, 1000); 

sf_demand_plan/views/demand_plan.xml

@@ -4,8 +4,7 @@
         <field name="model">sf.production.demand.plan</field>
         <field name="arch" type="xml">
             <tree string="需求计划" default_order="sequence desc,id desc" editable="bottom"
-                  class="demand_plan_tree freeze-columns-before-part_number" create="false" delete="false"
+                  class="demand_plan_tree freeze-columns-before-part_number" create="false" delete="false">
-                  js_class="custom_demand_plan_list">
                 <header>
                     <button string="打印" name="button_action_print" type="object"
                             class="btn-primary"/>

sf_demand_plan/views/demand_plan_info.xml

@@ -108,9 +108,6 @@
                                             class="btn-primary"
                                             attrs="{'invisible': [('hide_release_production_order', '=', False)]}"
                                     />
-                                    <button string="详情" name="button_plan_detail" type="object"
-                                            class="btn-primary"
-                                    />
                                 </tree>
                             </field>
                         </page>

sf_demand_plan/wizard/sf_demand_plan_print_wizard.py

@@ -37,7 +37,7 @@ class SfDemandPlanPrintWizard(models.TransientModel):
             if pdf_data:
                 try:
                     # 执行打印
-                    # self.env['jikimo.printing'].sudo().print_pdf(pdf_data)
+                    self.env['jikimo.printing'].sudo().print_pdf(pdf_data)
                     record.status = 'success'
                     production_demand_plan_id = self.env['sf.production.demand.plan'].sudo().search(
                         [('model_id', '=', record.model_id)])

sf_demand_plan/wizard/sf_release_plan_wizard.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 import logging
 from odoo import models, fields, api, _
-from werkzeug.exceptions import InternalServerError
 
 _logger = logging.getLogger(__name__)
 
@@ -18,10 +17,4 @@ class SfReleasePlanWizard(models.TransientModel):
     def confirm(self):
         if self.demand_plan_line_id:
             for demand_plan_line_id in self.demand_plan_line_id:
-                try:
+                demand_plan_line_id.action_confirm()
-                    demand_plan_line_id.action_confirm()
-                except Exception as e:
-                    self.env.cr.rollback()
-                    demand_plan_line_id.write({'is_processing': False})
-                    self.env.cr.commit()
-                    raise InternalServerError('操作失败', e)

sf_mrs_connect/models/sync_common.py

@@ -1506,149 +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'), '三爪卡盘')
-        else:
+#         else:
-            raise ValidationError("夹具型号基本参数认证未通过")
+#             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'), '三爪卡盘')
-        else:
+#         else:
-            raise ValidationError("夹具型号基本参数认证未通过")
+#             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):
@@ -3231,3 +3231,108 @@ class EmbryoRedundancySync(models.Model):
                         "active": item['active'],
                         "remark": item['remark'],
                     })
+
+
+
+
+
+
+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)
+
+        # ✅ Redis 无数据时，请求 MRS 端刷新 Redis 缓存
+        if not all_list:
+            config = self.env['res.config.settings'].get_values()
+            headers = Common.get_headers(config['token'], config['sf_secret_key'])
+            refresh_url = config['mrs_url'] + '/api/refresh_redis/fixture_param'
+
+            try:
+                res = requests.post(refresh_url, headers=headers, json={}, timeout=10)
+                res.raise_for_status()
+            except Exception as e:
+                raise ValidationError(f"Redis 无数据，MRS 缓存刷新失败: {str(e)}")
+
+            # 再次尝试从 Redis 获取
+            all_list = rc.get_json(key)
+            if not all_list:
+                raise ValidationError("Redis 刷新后仍无数据，无法同步夹具基本参数")
+
+        # ✅ 同步函数作为局部函数定义在方法体内部
+        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'), '磁吸托盘')
+
+
+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)
+
+        # ✅ Redis 没数据时，请求 MRS 接口刷新
+        if not all_list:
+            config = self.env['res.config.settings'].get_values()
+            headers = Common.get_headers(config['token'], config['sf_secret_key'])
+            refresh_url = config['mrs_url'] + '/api/refresh_redis/fixture_model'
+
+            try:
+                res = requests.post(refresh_url, headers=headers, json={}, timeout=10)
+                res.raise_for_status()
+            except Exception as e:
+                raise ValidationError(f"Redis 无数据，MRS 刷新失败: {str(e)}")
+
+            # 再次尝试获取 Redis
+            all_list = rc.get_json(key)
+            if not all_list:
+                raise ValidationError("刷新后仍无 Redis 数据，无法同步夹具型号")
+
+        # ✅ 开始同步夹具型号
+        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)

sf_plan_management/i18n/zh_CN.po

@@ -45759,6 +45759,11 @@ msgstr ""
 msgid "热处理"
 msgstr ""
 
+#. module: sf_base
+#: model:ir.model.fields,field_description:sf_base.field_sf_materials_model__need_m
+msgid "是否磁吸"
+msgstr ""
+
 #. module: sf_base
 #: model:ir.model.fields,field_description:sf_base.field_sf_materials_model__mf_materia_post
 msgid "热处理后密度"