修改采购申请相关欠单创建报错的问题

Merge Request: 1、质检单类型为出厂检测报告时，隐藏通过状态下的不合格按钮；2、功能刀具组装检测BOM物料时过滤产品的追溯类型为不追溯的产品。

Created By: @禹翔辉
Reviewed By: @胡尧
Approved By: @胡尧 
Accepted By: @禹翔辉
URL: https://jikimo-hn.coding.net/p/jikimo_sfs/d/jikimo_sf/git/merge/2202

jikimo_purchase_request/models/__init__.py

@@ -6,3 +6,4 @@ from . import mrp_production
 from . import purchase_order
 from . import stock_rule
 from . import stock_picking
+from . import product_product

jikimo_purchase_request/models/mrp_production.py

@@ -9,18 +9,11 @@ class MrpProduction(models.Model):
     @api.depends('state')
     def _compute_pr_mp_count(self):
         for item in self:
-            # if item.product_id.product_tmpl_id.single_manufacturing == True and not item.is_remanufacture:
+            if item.product_id.is_customer_provided:
-            #     first_order = self.env['mrp.production'].search(
+                item.pr_mp_count = 0
-            #         [('origin', '=', item.origin), ('product_id', '=', item.product_id.id)], limit=1, order='id asc')
+            else:
-            #     pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', first_order.name)])
+                pr_ids = item._get_purchase_request()
-            #     item.pr_mp_count = len(pr_ids)
+                item.pr_mp_count = len(pr_ids)
-            # else:
-            #     pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', item.name)])
-            #     item.pr_mp_count = len(pr_ids)
-            # 由于采购申请合并了所有销售订单行的采购，所以不区分产品
-            mrp_names = self.env['mrp.production'].search([('origin', '=', item.origin)]).mapped('name')
-            pr_ids = self.env['purchase.request'].sudo().search([('origin', 'in', mrp_names)])
-            item.pr_mp_count = len(pr_ids)
             # pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', item.name), ('is_subcontract', '!=', 'True')])
 
     def action_view_pr_mp(self):
@@ -28,17 +21,9 @@ class MrpProduction(models.Model):
         采购请求
         """
         self.ensure_one()
-        # pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', self.name),('is_subcontract', '!=', True)])
-        # if self.product_id.product_tmpl_id.single_manufacturing == True and not self.is_remanufacture:
-        #     first_order = self.env['mrp.production'].search(
-        #         [('origin', '=', self.origin), ('product_id', '=', self.product_id.id)], limit=1, order='id asc')
-        #     pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', first_order.name)])
-        # else:
-        #     pr_ids = self.env['purchase.request'].sudo().search([('origin', 'like', self.name)])
-        # 由于采购申请合并了所有销售订单行的采购，所以不区分产品
-        mrp_names = self.env['mrp.production'].search([('origin', '=', self.origin)]).mapped('name')
-        pr_ids = self.env['purchase.request'].sudo().search([('origin', 'in', mrp_names)])
 
+        # 由于采购申请合并了所有销售订单行的采购，所以不区分产品
+        pr_ids = self._get_purchase_request()
 
         action = {
             'res_model': 'purchase.request',
@@ -52,7 +37,16 @@ class MrpProduction(models.Model):
         else:
             action.update({
                 'name': _("从 %s生成采购请求单", self.name),
-                'domain': [('id', 'in', pr_ids)],
+                'domain': [('id', 'in', pr_ids.ids)],
                 'view_mode': 'tree,form',
             })
         return action
+
+    def _get_purchase_request(self):
+        """获取跟制造订单相关的采购申请单（根据采购申请单行项目的产品匹配）"""
+        mrp_names = self.env['mrp.production'].search([('origin', '=', self.origin)]).mapped('name')
+        pr_ids = self.env['purchase.request'].sudo().search([('origin', 'in', mrp_names)])
+        product_list = self.product_id._get_product_include_bom()
+        pr_line_ids = pr_ids.line_ids.filtered(lambda l: l.product_id in product_list)
+        return pr_line_ids.mapped('request_id')
+    

jikimo_purchase_request/models/product_product.py

@@ -0,0 +1,17 @@
+from odoo import models
+
+
+class ProductProduct(models.Model):
+    _inherit = 'product.product'
+
+
+    def _get_product_include_bom(self):
+        """获取产品列表（包括所有bom）"""
+        self.ensure_one()
+        product_list = [self]
+        bom_ids = self.bom_ids
+        while (bom_ids):
+            bom_product_ids = bom_ids.bom_line_ids.mapped('product_id')
+            product_list.append(bom_product_ids)
+            bom_ids = bom_product_ids.bom_ids
+        return product_list

jikimo_purchase_request/models/purchase_request.py

@@ -41,13 +41,14 @@ class PurchaseRequest(models.Model):
         if lines:
             for line in lines:
                 for line_item in line.order_line:
-                    product_id = line_item.product_id.id
+                    if line_item.state == 'purchase':
-                    qty = line_item.product_qty
+                        product_id = line_item.product_id.id
-                    product_rounding[product_id] = line_item.product_id.uom_id.rounding
+                        qty = line_item.product_qty
-                    if product_id in product_summary:
+                        product_rounding[product_id] = line_item.product_id.uom_id.rounding
-                        product_summary[product_id] += qty
+                        if product_id in product_summary:
-                    else:
+                            product_summary[product_id] += qty
-                        product_summary[product_id] = qty
+                        else:
+                            product_summary[product_id] = qty
 
         # 校验产品数量
         discrepancies = []
@@ -60,10 +61,10 @@ class PurchaseRequest(models.Model):
 
         if discrepancies:
             # 弹出提示框
-            message = "产品数量不一致:\n"
+            message = "产品与采购数量不一致:\n"
             for product_id, required_qty, order_qty in discrepancies:
                 product_name = self.env['product.product'].browse(product_id).display_name  # 获取产品名称
-                message += f"产品 {product_name}，需求数量 {required_qty}，关联采购订单数量 {order_qty}（含询价状态）\n"
+                message += f"产品 {product_name}，需求数量 {required_qty}，关联采购订单确认的数量 {order_qty}。\n"
                 # 添加确认框
             message += "确认关闭？"
             return {
@@ -149,6 +150,8 @@ class PurchaseRequestLine(models.Model):
                 # 如果匹配成功，提取结果
                 if match:
                     product_name = match.group(0)
+                else:
+                    product_name = record.product_id.name
                 sale_order_name = ''
                 match_sale = re.search(r'S(\d+)', record.product_id.name)
                 if match_sale:

jikimo_purchase_request/models/stock_picking.py

@@ -42,6 +42,6 @@ class StockPicking(models.Model):
             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 = [
-                   (4, x.id) for x in backorder_ids.move_ids if x.product_id.id == purchase_request_lines.product_id.id
+                   (4, x.id) for x in backorder_ids.move_ids if x.product_id.id in purchase_request_lines.mapped('product_id.id')
                 ]
         return res

jikimo_test_generate_product_name/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from . import models

jikimo_test_generate_product_name/__manifest__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+{
+    'name': 'Jikimo_test_generate_product_name',
+    'version': '',
+    'summary': """ Jikimo_test_generate_product_name Summary """,
+    'author': '',
+    'website': '',
+    'category': '',
+    'depends': ['sf_manufacturing'],
+    'data': [
+        
+    ],
+    
+    'application': True,
+    'installable': True,
+    'auto_install': False,
+    'license': 'LGPL-3',
+}

jikimo_test_generate_product_name/models/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from . import product_template

jikimo_test_generate_product_name/models/product_template.py

@@ -0,0 +1,21 @@
+from odoo import models
+
+
+class ProductTemplate(models.Model):
+    _inherit = 'product.template'
+
+    def generate_product_name(self, order_id, item, i):
+        """生成成品名称"""
+        # 3D文件名（去掉后缀，截取前40个字符）+“-”+模型ID
+        product_name = '%s-%s' % ('.'.join(item['model_name'].split('.')[:-1])[:40], item['model_id'])
+        return product_name
+
+    def generate_embryo_name(self, order_id, item,  materials_id, materials_type_id, embryo_redundancy_id, i):
+        """生成坯料名称"""
+        embryo_name = '%s-%s[%s * %s * %s]%s' % (materials_id.name, materials_type_id.name,
+                                                       self.format_float(item['model_long'] + embryo_redundancy_id.long),
+                                                       self.format_float(item['model_width'] + embryo_redundancy_id.width),
+                                                       self.format_float(item['model_height'] + embryo_redundancy_id.height),
+                                            item['model_id'])
+        return embryo_name
+    

sf_bf_connect/models/http.py

@@ -2,7 +2,7 @@
 import logging
 from datetime import datetime, timedelta
 import hashlib
-from odoo import models
+from odoo import models, SUPERUSER_ID
 from odoo.http import request
 
 __author__ = 'jinling.yang'
@@ -48,5 +48,7 @@ class Http(models.AbstractModel):
             _logger.info('sf_secret_key:%s' % factory_secret.sf_secret_key)
             if check_sf_str != datas['HTTP_CHECKSTR']:
                 raise AuthenticationError('数据校验不通过')
+            # 设置管理员用户
+            request.update_env(user=SUPERUSER_ID)
         else:
             raise AuthenticationError('请求参数中无token')

sf_demand_plan/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+from . import models
+from . import wizard

sf_demand_plan/__manifest__.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+{
+    'name': '机企猫智能工厂 需求计划',
+    'version': '1.0',
+    'summary': '智能工厂计划管理',
+    'sequence': 1,
+    'description': """
+在本模块，支持齐套检查与下达生产
+    """,
+    'category': 'sf',
+    'website': 'https://www.sf.jikimo.com',
+    'depends': ['sf_plan', 'jikimo_printing'],
+    'data': [
+        'security/ir.model.access.csv',
+        'views/demand_plan.xml',
+        'wizard/sf_demand_plan_print_wizard_view.xml',
+    ],
+    'demo': [
+    ],
+    'assets': {
+        'web.assets_qweb': [
+        ],
+        'web.assets_backend': [
+            'sf_demand_plan/static/src/scss/style.css',
+            'sf_demand_plan/static/src/js/print_demand.js',
+        ]
+    },
+    'license': 'LGPL-3',
+    'installable': True,
+    'application': False,
+    'auto_install': False,
+}

sf_demand_plan/models/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+from . import sf_production_demand_plan
+from . import sale_order

sf_demand_plan/models/sale_order.py

@@ -0,0 +1,29 @@
+from odoo import models, fields, api, _
+
+
+class ReSaleOrder(models.Model):
+    _inherit = 'sale.order'
+
+    mrp_production_ids = fields.Many2many(
+        'mrp.production',
+        compute='_compute_mrp_production_ids',
+        string='与此销售订单相关联的制造订单',
+        groups='mrp.group_mrp_user', store=True)
+
+    def sale_order_create_line(self, product, item):
+        ret = super(ReSaleOrder, self).sale_order_create_line(product, item)
+        vals = {
+            'sale_order_id': ret.order_id.id,
+            'sale_order_line_id': ret.id,
+        }
+        demand_plan = self.env['sf.production.demand.plan'].sudo().create(vals)
+        if demand_plan.product_id.machining_drawings_name:
+            filename_url = demand_plan.product_id.machining_drawings_name.rsplit('.', 1)[0]
+            wizard_vals = {
+                'demand_plan_id': demand_plan.id,
+                'model_id': demand_plan.model_id,
+                'filename_url': filename_url,
+                'type': '1',
+            }
+            self.env['sf.demand.plan.print.wizard'].sudo().create(wizard_vals)
+        return ret

sf_demand_plan/models/sf_production_demand_plan.py

@@ -0,0 +1,533 @@
+# -*- coding: utf-8 -*-
+import ast
+import json
+from odoo import models, fields, api, _
+from odoo.exceptions import ValidationError
+from odoo.tools import float_compare
+from datetime import datetime, timedelta
+from odoo.exceptions import UserError
+
+
+class SfProductionDemandPlan(models.Model):
+    _name = 'sf.production.demand.plan'
+    _description = 'sf_production_demand_plan'
+
+    def _get_machining_precision(self):
+        machinings = self.env['sf.machining.accuracy'].sudo().search([])
+        list = [(m.sync_id, m.name) for m in machinings]
+        return list
+
+    priority = fields.Selection([
+        ('1', '紧急'),
+        ('2', '高'),
+        ('3', '中'),
+        ('4', '低'),
+    ], string='优先级', default='3')
+    status = fields.Selection([
+        ('10', '草稿'),
+        ('20', '待确认'),
+        ('30', '需求确认'),
+        ('50', '待下达生产'),
+        ('60', '已下达'),
+        ('100', '取消'),
+    ], string='状态', compute='_compute_status', store=True)
+    sale_order_id = fields.Many2one(comodel_name="sale.order",
+                                    string="销售订单", readonly=True)
+    sale_order_line_id = fields.Many2one(comodel_name="sale.order.line",
+                                         string="销售订单明细", readonly=True)
+    sale_order_line_number = fields.Char(string='销售订单行', compute='_compute_sale_order_line_number', store=True)
+    company_id = fields.Many2one(
+        related='sale_order_id.company_id',
+        store=True, index=True, precompute=True)
+    partner_id = fields.Many2one(
+        comodel_name='res.partner',
+        related='sale_order_line_id.order_partner_id',
+        string="客户",
+        store=True, index=True)
+    order_remark = fields.Text(related='sale_order_id.remark',
+                               string="订单备注", store=True)
+    glb_url = fields.Char(related='sale_order_line_id.glb_url', string='glb文件地址')
+    product_id = fields.Many2one(
+        comodel_name='product.product',
+        related='sale_order_line_id.product_id',
+        string='产品', store=True, index=True)
+    model_id = fields.Char('模型ID', related='product_id.model_id')
+    part_name = fields.Char('零件名称', related='product_id.part_name')
+    part_number = fields.Char('零件图号', compute='_compute_part_number', store=True)
+    is_incoming_material = fields.Boolean('客供料', related='sale_order_line_id.is_incoming_material', store=True)
+    supply_method = fields.Selection([
+        ('automation', "自动化产线加工"),
+        ('manual', "人工线下加工"),
+        ('purchase', "外购"),
+        ('outsourcing', "委外加工"),
+    ], string='供货方式', related='sale_order_line_id.supply_method', store=True)
+    product_uom_qty = fields.Float(
+        string="需求数量",
+        related='sale_order_line_id.product_uom_qty', store=True)
+    deadline_of_delivery = fields.Date('客户交期', related='sale_order_id.deadline_of_delivery', store=True)
+    inventory_quantity_auto_apply = fields.Float(
+        string="成品库存",
+        compute='_compute_inventory_quantity_auto_apply'
+    )
+    qty_delivered = fields.Float(
+        "交货数量", related='sale_order_line_id.qty_delivered')
+    qty_to_deliver = fields.Float(
+        "待交货数量", related='sale_order_line_id.qty_to_deliver')
+    model_long = fields.Char('尺寸', compute='_compute_model_long')
+    materials_id = fields.Char('材料', compute='_compute_materials_id', store=True)
+    model_machining_precision = fields.Selection(selection=_get_machining_precision, string='精度',
+                                                 related='product_id.model_machining_precision')
+    model_process_parameters_ids = fields.Many2many('sf.production.process.parameter',
+                                                    'plan_process_parameter_rel',
+                                                    string='表面工艺',
+                                                    compute='_compute_model_process_parameters_ids'
+                                                    , store=True
+                                                    )
+    product_remark = fields.Char("产品备注", related='product_id.model_remark')
+    order_code = fields.Char('E-SHOP订单号', related='sale_order_id.order_code')
+    order_state = fields.Selection(
+        string='订单状态',
+        related='sale_order_line_id.state')
+    route_id = fields.Many2one('stock.route', string='路线', related='sale_order_line_id.route_id', store=True)
+    contract_date = fields.Date('合同日期', related='sale_order_id.contract_date')
+    date_order = fields.Datetime('下单日期', related='sale_order_id.date_order')
+    contract_code = fields.Char('合同号', related='sale_order_id.contract_code', store=True)
+    plan_remark = fields.Text("计划备注")
+    material_check = fields.Selection([
+        ('0', "未齐套"),
+        ('1', "已齐套"),
+    ], string='投料齐套检查', compute='_compute_material_check', store=True)
+    processing_time = fields.Char('程序工时', readonly=True)
+    planned_start_date = fields.Date('计划开工日期')
+    actual_start_date = fields.Datetime('实际开工日期', compute='_compute_actual_start_date', store=True)
+    actual_end_date = fields.Datetime('实际完工日期', compute='_compute_actual_end_date', store=True)
+    print_count = fields.Char('打印次数', default='T0C0', readonly=True)
+    sequence = fields.Integer('序号')
+
+    hide_action_open_mrp_production = fields.Boolean(
+        string='显示待工艺确认按钮',
+        compute='_compute_hid_button',
+        default=False
+    )
+
+    hide_action_purchase_orders = fields.Boolean(
+        string='显示采购按钮',
+        compute='_compute_hide_action_purchase_orders',
+        default=False
+    )
+
+    hide_action_stock_picking = fields.Boolean(
+        string='显示调拨单按钮',
+        compute='_compute_hide_action_stock_picking',
+        default=False
+    )
+
+    hide_action_outsourcing_stock_picking = fields.Boolean(
+        string='委外显示调拨单按钮',
+        compute='_compute_hide_action_stock_picking',
+        default=False
+    )
+
+    hide_action_view_programming = fields.Boolean(
+        string='显示编程单按钮',
+        compute='_compute_hid_button',
+        default=False
+    )
+
+    outsourcing_purchase_request = fields.Char('委外采购申请单')
+
+    @api.depends('sale_order_id.state', 'sale_order_id.mrp_production_ids.schedule_state', 'sale_order_id.order_line',
+                 'sale_order_id.mrp_production_ids.state')
+    def _compute_status(self):
+        for record in self:
+            if record.sale_order_id:
+                sale_order_state = record.sale_order_id.state
+                if sale_order_state in ('draft', 'sent', 'supply method'):
+                    record.status = '20'  # 待确认
+                if record.supply_method in ('purchase', 'outsourcing') and sale_order_state in (
+                        'sale', 'processing', 'physical_distribution', 'delivered',
+                        'done') and sale_order_state != 'cancel':
+                    record.status = '60'  # 已下达
+                if record.supply_method in ('automation', 'manual'):
+                    if sale_order_state in (
+                            'sale', 'processing', 'physical_distribution', 'delivered',
+                            'done') and sale_order_state != 'cancel':
+                        record.status = '30'  # 需求确认
+                    # 检查所有制造订单的排程单状态,有一个为待排程状态,就为待下达生产
+                    pending_productions = record.sale_order_id.mrp_production_ids.filtered(
+                        lambda p: p.state == 'confirmed' and p.product_id.id == record.product_id.id
+                    )
+                    if pending_productions:
+                        record.status = '50'  # 待下达生产
+                    # 检查所有制造订单的排程单状态
+                    if record.sale_order_id.mrp_production_ids:
+                        product_productions = record.sale_order_id.mrp_production_ids.filtered(
+                            lambda p: p.product_id.id == record.product_id.id
+                        )
+                        if product_productions and all(order.schedule_state != '未排' for order in product_productions):
+                            record.status = '60'  # 已下达
+                if sale_order_state == 'cancel' or not record.sale_order_line_id:
+                    record.status = '100'  # 取消
+
+    @api.depends('sale_order_line_id.product_id.name')
+    def _compute_sale_order_line_number(self):
+        for line in self:
+            if line.product_id:
+                line.sale_order_line_number = line.sale_order_line_id.product_id.name[-1]
+            else:
+                line.sale_order_line_number = None
+
+    @api.depends('product_id.part_number', 'product_id.model_name')
+    def _compute_part_number(self):
+        for line in self:
+            if line.product_id:
+                if line.product_id.part_number:
+                    line.part_number = line.product_id.part_number
+                else:
+                    if line.product_id.model_name:
+                        line.part_number = line.product_id.model_name.rsplit('.', 1)[0]
+            else:
+                line.part_number = None
+
+    @api.depends('product_id.length', 'product_id.width', 'product_id.height')
+    def _compute_model_long(self):
+        for line in self:
+            if line.product_id:
+                line.model_long = f"{line.product_id.length}*{line.product_id.width}*{line.product_id.height}"
+            else:
+                line.model_long = None
+
+    @api.depends('product_id.materials_id')
+    def _compute_materials_id(self):
+        for line in self:
+            if line.product_id:
+                line.materials_id = f"{line.product_id.materials_id.name}/{line.product_id.materials_type_id.name}"
+            else:
+                line.materials_id = None
+
+    @api.depends('product_id.model_process_parameters_ids')
+    def _compute_model_process_parameters_ids(self):
+        for line in self:
+            if line.product_id and line.product_id.model_process_parameters_ids:
+                line.model_process_parameters_ids = [(6, 0, line.product_id.model_process_parameters_ids.ids)]
+            else:
+                line.model_process_parameters_ids = [(5, 0, 0)]
+
+    def _compute_inventory_quantity_auto_apply(self):
+        location_id = self.env['stock.location'].search([('name', '=', '成品存货区')], limit=1).id
+        product_ids = self.mapped('product_id').ids
+        if product_ids:
+            quant_data = self.env['stock.quant'].read_group(
+                domain=[
+                    ('product_id', 'in', product_ids),
+                    ('location_id', '=', location_id)
+                ],
+                fields=['product_id', 'inventory_quantity_auto_apply'],
+                groupby=['product_id']
+            )
+            quantity_map = {item['product_id'][0]: item['inventory_quantity_auto_apply'] for item in quant_data}
+        else:
+            quantity_map = {}
+        for line in self:
+            if line.product_id:
+                line.inventory_quantity_auto_apply = quantity_map.get(line.product_id.id, 0.0)
+            else:
+                line.inventory_quantity_auto_apply = 0.0
+
+    @api.depends('sale_order_id.mrp_production_ids.workorder_ids.date_start')
+    def _compute_actual_start_date(self):
+        for record in self:
+            if record.sale_order_id and record.sale_order_id.mrp_production_ids:
+                manufacturing_orders = record.sale_order_id.mrp_production_ids.filtered(
+                    lambda mo: mo.product_id == record.product_id)
+                if manufacturing_orders:
+                    start_dates = [
+                        workorder.date_start for mo in manufacturing_orders
+                        for workorder in mo.workorder_ids if workorder.date_start
+                    ]
+                    record.actual_start_date = min(start_dates) if start_dates else None
+                else:
+                    record.actual_start_date = None
+            else:
+                record.actual_start_date = None
+
+    @api.depends('sale_order_id.mrp_production_ids.workorder_ids.state',
+                 'sale_order_id.mrp_production_ids.workorder_ids.date_finished')
+    def _compute_actual_end_date(self):
+        for record in self:
+            if record.sale_order_id and record.sale_order_id.mrp_production_ids:
+                manufacturing_orders = record.sale_order_id.mrp_production_ids.filtered(
+                    lambda mo: mo.product_id == record.product_id)
+                finished_orders = manufacturing_orders.filtered(lambda mo: mo.state == 'done')
+                sum_product_qty = sum(finished_orders.mapped('product_qty'))
+                if finished_orders and float_compare(sum_product_qty, record.product_uom_qty,
+                                                     precision_rounding=record.product_id.uom_id.rounding) >= 0:
+                    end_dates = [
+                        workorder.date_finished for mo in finished_orders
+                        for workorder in mo.workorder_ids if workorder.date_finished
+                    ]
+                    record.actual_end_date = max(end_dates) if end_dates else None
+                else:
+                    record.actual_end_date = None
+            else:
+                record.actual_end_date = None
+
+    @api.depends('sale_order_id.mrp_production_ids.move_raw_ids.reserved_availability')
+    def _compute_material_check(self):
+        for record in self:
+            if record.sale_order_id and record.sale_order_id.mrp_production_ids:
+                manufacturing_orders = record.sale_order_id.mrp_production_ids.filtered(
+                    lambda mo: mo.product_id == record.product_id)
+                if manufacturing_orders and manufacturing_orders.move_raw_ids:
+                    total_reserved_availability = sum(manufacturing_orders.mapped('move_raw_ids.reserved_availability'))
+                    if float_compare(total_reserved_availability, record.product_uom_qty,
+                                     precision_rounding=record.product_id.uom_id.rounding) >= 0:
+                        record.material_check = '1'  # 已齐套
+                    else:
+                        record.material_check = '0'  # 未齐套
+                else:
+                    record.material_check = None
+            else:
+                record.material_check = None
+
+    @api.constrains('planned_start_date')
+    def _check_planned_start_date(self):
+        for record in self:
+            if record.planned_start_date and record.planned_start_date < fields.Date.today():
+                raise ValidationError("计划开工日期必须大于或等于今天。")
+
+    def release_production_order(self):
+        if not self.planned_start_date:
+            raise ValidationError("请先填写计划开工日期")
+        pro_plan_list = self.env['sf.production.plan'].search(
+            [('product_id', '=', self.product_id.id), ('state', '=', 'draft')])
+        sf_production_line = self.env['sf.production.line'].sudo().search(
+            [('name', '=', '1#CNC自动生产线')], limit=1)
+        if sf_production_line:
+            now = datetime.now()
+            time_part = (now + timedelta(minutes=3)).time()
+            date_part = fields.Date.from_string(self.planned_start_date)
+            date_planned_start = datetime.combine(date_part, time_part)
+            pro_plan_list.production_line_id = sf_production_line.id
+            pro_plan_list.date_planned_start = date_planned_start
+            for pro_plan in pro_plan_list:
+                pro_plan.do_production_schedule()
+
+    def button_action_print(self):
+        return {
+            'res_model': 'sf.demand.plan.print.wizard',
+            'type': 'ir.actions.act_window',
+            'name': _("打印"),
+            'domain': [('demand_plan_id', 'in', self.ids)],
+            'views': [[self.env.ref('sf_demand_plan.action_plan_print_tree').id, 'list']],
+            'search_view_id': self.env.ref('sf_demand_plan.action_plan_print_search').id,
+            'target': 'new',
+        }
+
+    @api.depends('sale_order_id.mrp_production_ids.state', 'sale_order_id.mrp_production_ids.programming_state')
+    def _compute_hid_button(self):
+        for record in self:
+            mrp_production_ids = record.sale_order_id.mrp_production_ids.filtered(
+                lambda p: p.state == 'technology_to_confirmed' and p.product_id.id == record.product_id.id
+            )
+            record.hide_action_open_mrp_production = bool(mrp_production_ids) and record.supply_method in (
+                'automation', 'manual')
+            programming_mrp_production_ids = record.sale_order_id.mrp_production_ids.filtered(
+                lambda p: p.programming_state == '编程中' and p.product_id.id == record.product_id.id
+            )
+            record.hide_action_view_programming = bool(programming_mrp_production_ids)
+
+    def _compute_hide_action_purchase_orders(self):
+        for record in self:
+            record.hide_action_purchase_orders = False
+            outsourcing_purchase_request = []
+            if record.supply_method in ('automation',
+                                        'manual') and record.material_check == '0' and not record.sale_order_line_id.is_incoming_material:
+                mrp_production = record.sale_order_id.mrp_production_ids.filtered(
+                    lambda p: p.product_id.id == record.product_id.id
+                ).sorted(key=lambda p: p.id)
+                if mrp_production:
+                    raw_materials = mrp_production.mapped('move_raw_ids.product_id')
+                    if raw_materials:
+                        purchase_orders = self.env['purchase.order'].sudo().search([
+                            ('state', '=', 'purchase'),
+                            ('order_line.product_id', 'in', raw_materials.ids)
+                        ])
+                        total_purchase_quantity = sum(
+                            sum(
+                                order.order_line.filtered(
+                                    lambda line: line.product_id in raw_materials
+                                ).mapped('product_qty')
+                            )
+                            for order in purchase_orders
+                        )
+                        if float_compare(total_purchase_quantity, record.product_uom_qty,
+                                         precision_rounding=record.product_id.uom_id.rounding) == -1:
+                            pr_ids = self.env['purchase.request'].sudo().search(
+                                [('line_ids.product_id', 'in', raw_materials.ids), ('state', '!=', 'done')])
+                            outsourcing_purchase_request.extend(pr_ids.ids)
+            elif record.supply_method in ('purchase', 'outsourcing'):
+                purchase_orders = self.env['purchase.order'].sudo().search([
+                    ('state', 'in', ('purchase', 'done')),
+                    ('order_line.product_id', '=', record.product_id.id)
+                ])
+                total_purchase_quantity = sum(
+                    sum(
+                        order.order_line.filtered(
+                            lambda line: line.product_id in record.product_id
+                        ).mapped('product_qty')
+                    )
+                    for order in purchase_orders
+                )
+
+                if float_compare(total_purchase_quantity, record.product_uom_qty,
+                                 precision_rounding=record.product_id.uom_id.rounding) == -1:
+                    pr_ids = self.env['purchase.request'].sudo().search(
+                        [('origin', 'like', record.sale_order_id.name), ('state', '!=', 'done')])
+                    outsourcing_purchase_request.extend(pr_ids.ids)
+                if record.supply_method == 'outsourcing' and not record.sale_order_line_id.is_incoming_material:
+                    bom_line_ids = record.product_id.bom_ids.bom_line_ids
+                    # BOM_数量
+                    total_product_qty = sum(line.product_qty for line in bom_line_ids)
+                    bom_product_ids = bom_line_ids.mapped('product_id')
+                    product_purchase_orders = self.env['purchase.order'].sudo().search([
+                        ('state', 'in', ('purchase', 'done')),
+                        ('order_line.product_id', 'in', bom_product_ids.ids)
+                    ])
+                    # 购订单_数量
+                    total_outsourcing_purchase_quantity = sum(
+                        sum(
+                            order.order_line.filtered(
+                                lambda line: line.product_id in bom_product_ids
+                            ).mapped('product_qty')
+                        )
+                        for order in product_purchase_orders
+                    )
+                    quantity = total_outsourcing_purchase_quantity / total_product_qty
+                    if float_compare(quantity, record.product_uom_qty,
+                                     precision_rounding=record.product_id.uom_id.rounding) == -1:
+                        purchase_request = self.env['purchase.request'].sudo().search(
+                            [('line_ids.product_id', 'in', bom_product_ids.ids),
+                             ('line_ids.purchase_state', 'not in', ('purchase', 'done')), ('state', '!=', 'done')])
+                        outsourcing_purchase_request.extend(purchase_request.ids)
+            record.outsourcing_purchase_request = json.dumps(outsourcing_purchase_request)
+            if outsourcing_purchase_request:
+                record.hide_action_purchase_orders = True
+
+    @api.depends('sale_order_id.mrp_production_ids.picking_ids.state', 'sale_order_id.picking_ids.state')
+    def _compute_hide_action_stock_picking(self):
+        for record in self:
+            record.hide_action_stock_picking = False
+            record.hide_action_outsourcing_stock_picking = False
+            if record.supply_method in ('automation', 'manual'):
+                manufacturing_orders = record.sale_order_id.mrp_production_ids.filtered(
+                    lambda p: p.product_id.id == record.product_id.id
+                )
+                record.hide_action_stock_picking = bool(manufacturing_orders.mapped('picking_ids').filtered(
+                    lambda p: p.state == 'assigned'))
+            elif record.supply_method in ('purchase', 'outsourcing'):
+                assigned_picking_ids = record.sale_order_id.picking_ids.filtered(
+                    lambda
+                        p: p.state == 'assigned' and p.picking_type_id.name != '发料出库' and p.move_line_ids.product_id in record.product_id)
+                if record.supply_method == 'outsourcing':
+                    outsourcing_assigned_picking_ids = record.get_outsourcing_picking_ids()
+                    record.hide_action_outsourcing_stock_picking = outsourcing_assigned_picking_ids
+                    record.hide_action_stock_picking = assigned_picking_ids or outsourcing_assigned_picking_ids
+                else:
+                    record.hide_action_stock_picking = assigned_picking_ids
+
+    def get_outsourcing_picking_ids(self):
+        order_ids = self.env['purchase.order'].sudo().search(
+            [('order_line.product_id', 'in', self.product_id.ids),
+             ('purchase_type', '=', 'outsourcing')])
+        outsourcing_picking_ids = order_ids._get_subcontracting_resupplies()
+        outsourcing_assigned_picking_ids = outsourcing_picking_ids.filtered(lambda p: p.state == 'assigned')
+        return outsourcing_assigned_picking_ids
+
+    def action_open_sale_order(self):
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'sale.order',
+            'res_id': self.sale_order_id.id,
+            'view_mode': 'form',
+        }
+
+    def action_open_mrp_production(self):
+        self.ensure_one()
+        mrp_production_ids = self.sale_order_id.mrp_production_ids.filtered(
+            lambda p: p.state == 'technology_to_confirmed' and p.product_id.id == self.product_id.id
+        )
+        action = {
+            'res_model': 'mrp.production',
+            'type': 'ir.actions.act_window',
+        }
+        if len(mrp_production_ids) == 1:
+            action.update({
+                'view_mode': 'form',
+                'res_id': mrp_production_ids.id,
+            })
+        else:
+            action.update({
+                'name': _("制造订单列表"),
+                'domain': [('id', 'in', mrp_production_ids.ids)],
+                'view_mode': 'tree,form',
+            })
+        return action
+
+    def action_view_purchase_request(self):
+        self.ensure_one()
+        pr_ids = self.env['purchase.request'].sudo().search(
+            [('id', 'in', ast.literal_eval(self.outsourcing_purchase_request))])
+        action = {
+            'res_model': 'purchase.request',
+            'type': 'ir.actions.act_window',
+        }
+        if len(pr_ids) == 1:
+            action.update({
+                'view_mode': 'form',
+                'res_id': pr_ids[0].id,
+            })
+        else:
+            action.update({
+                'name': _("采购申请"),
+                'domain': [('id', 'in', pr_ids.ids)],
+                'view_mode': 'tree,form',
+            })
+        return action
+
+    def action_view_stock_picking(self):
+        self.ensure_one()
+        action = self.env["ir.actions.actions"]._for_xml_id("stock.action_picking_tree_all")
+        picking_ids = None
+        if self.supply_method in ('automation', 'manual'):
+            mrp_production_ids = self.sale_order_id.mrp_production_ids.filtered(
+                lambda p: p.product_id.id == self.product_id.id
+            )
+            picking_ids = mrp_production_ids.mapped('picking_ids').filtered(
+                lambda p: p.state == 'assigned')
+        elif self.supply_method in ('purchase', 'outsourcing'):
+            picking_ids = self.sale_order_id.picking_ids.filtered(
+                lambda
+                    p: p.state == 'assigned' and p.picking_type_id.name != '发料出库' and p.move_line_ids.product_id in self.product_id)
+            if self.supply_method == 'outsourcing' and self.hide_action_outsourcing_stock_picking:
+                picking_ids = picking_ids.union(self.get_outsourcing_picking_ids())
+        if picking_ids:
+            if len(picking_ids) > 1:
+                action['domain'] = [('id', 'in', picking_ids.ids)]
+            elif picking_ids:
+                action['res_id'] = picking_ids.id
+                action['views'] = [(self.env.ref('stock.view_picking_form').id, 'form')]
+                if 'views' in action:
+                    action['views'] += [(state, view) for state, view in action['views'] if view != 'form']
+            return action
+
+    def action_view_programming(self):
+        self.ensure_one()
+        programming_mrp_production_ids = self.sale_order_id.mrp_production_ids.filtered(
+            lambda p: p.programming_state == '编程中' and p.product_id.id == self.product_id.id
+        ).mapped('programming_no')
+        if programming_mrp_production_ids:
+            programming_no = list(set(programming_mrp_production_ids))
+            numbers_str = "、".join(programming_no)
+            raise ValidationError(f"编程单号：{numbers_str}，请去云平台处理")

sf_demand_plan/security/ir.model.access.csv

@@ -0,0 +1,6 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_sf_production_demand_plan,sf.production.demand.plan,model_sf_production_demand_plan,base.group_user,1,0,0,0
+access_sf_production_demand_plan_for_dispatch,sf.production.demand.plan for dispatch,model_sf_production_demand_plan,sf_base.group_plan_dispatch,1,1,0,0
+
+access_sf_demand_plan_print_wizard,sf.demand.plan.print.wizard,model_sf_demand_plan_print_wizard,base.group_user,1,0,0,0
+access_sf_demand_plan_print_wizard_for_dispatch,sf.demand.plan.print.wizard for dispatch,model_sf_demand_plan_print_wizard,sf_base.group_plan_dispatch,1,1,0,0

sf_demand_plan/static/src/js/print_demand.js

@@ -0,0 +1,215 @@
+odoo.define('sf_demand.print_demand', function (require) {
+    "use strict";
+    
+    var ListController = require('web.ListController');
+    var ListRenderer = require('web.ListRenderer');
+    var ListView = require('web.ListView');
+    var viewRegistry = require('web.view_registry');
+    var { url } = require("@web/core/utils/urls") 
+    
+    var CustomListRenderer = ListRenderer.extend({
+        _render: function () {
+            var self = this;
+            this.getParent()?.$buttons.hide();
+            
+            return this._super.apply(this, arguments).then(function () {
+                // 添加图片预览容器到页面左侧
+                if (!$('.table-image-preview-container').length) {
+                    self.$el.parent().addClass('custom-table-image-container')
+                    self.$el.before(
+                        `<div class="custom-preview-container">
+                            <img class="table-image-preview-container" src="" /> 
+                            <iframe class="table-image-preview-container" src=""/>
+                        </div>`
+                    );
+                    self.$el.prepend(`
+                        <div class="print-button-container" style="margin-bottom:10px;">
+                            <button class="btn btn-primary o_print_custom">
+                                <i class="fa fa-print"></i> 打印
+                            </button>
+                            <button class="btn btn-secondary  o_cancel_custom">
+                               取消
+                            </button>
+                        </div>
+                    `);
+                }
+            });
+        },
+        start: function() {
+            setTimeout(() => {
+                this.$el.find('.o_data_row').eq(0).trigger('click')
+            }, 500);
+            return this._super();
+        },
+        events: _.extend({}, ListRenderer.prototype.events, {
+            'click .o_data_row': '_onCustomRowClick',
+            'click .o_print_custom': '_onPrintClick',
+            'click .o_cancel_custom': '_onCancelClick'
+        }),
+        _onCancelClick() {
+            this.getParent()?.getParent()?.dialogs.closeAll()
+        },
+        _onCustomRowClick: async function (ev) {
+            var self = this;
+            var $row = $(ev.currentTarget);
+            var index = $row.index();
+            var data = this.state.data[index];
+            if(data.fileData?.fileUrl) {
+
+            } else {
+                data.fileData = { }
+                if(data.res_id) {
+                    // 正确获取 ORM 服务的方式
+                    // var orm = this.getParent().getParent().env.services
+                    const key = data.data.type == 1 ? 'machining_drawings' : 'cnc_worksheet'
+                    const attachment = await this._rpc({
+                        model: 'ir.binary',
+                        method: 'attachment_info',
+                        args: [
+                            data.model,
+                            data.res_id,
+                            key
+                        ],
+                    })
+    
+                    if (attachment) {
+                        Object.assign(data.fileData, attachment)
+                        this._getTypeInfo(attachment.mimetype, data.fileData)
+                    }
+                    const fileUrl = this.getFileUrl(data.fileData.attachment_type, data, key)
+                    data.fileData.fileUrl = fileUrl
+                }
+            }
+            $('.table-image-preview-container').hide()
+            if(data.fileData.attachment_type == 'iframe') {
+                
+                $('iframe.table-image-preview-container').attr('src', decodeURIComponent(data.fileData.fileUrl) ).show()
+            } else {
+                $('img.table-image-preview-container').attr('src', data.fileData.fileUrl).show()
+            }
+        },
+        getSelectedIds: function() {
+            return this.state.data.map(_ => {
+                return _.data.id
+            })
+        },
+        _onPrintClick(e) {
+            var print_ids = this.getSelectedIds();
+    
+                    
+            this._rpc({
+                model: 'sf.demand.plan.print.wizard',
+                method: 'demand_plan_print',
+                args: [ print_ids ] ,
+                // context: this.state.getContext()
+            }).then((e) => {
+                
+                this.getParent()?.getParent()?.env.services?.notification.notify( {
+                    type: 'info',
+                    message: e.message,
+                })
+                // self.do_notify("成功", "打印任务已发送到打印机");
+            }).catch(function(error) {
+                console.error("打印错误:", error);
+                // self.do_warn("打印失败", error.data.message || "未知错误");
+            }).finally(e => {
+                this.getParent().reload()
+                
+            })
+            
+        },
+        getFileUrl(attachment_type, data, key) {
+            let fileUrl
+            switch (attachment_type) {
+                case 'image':
+                        const timer = +new Date()
+                        fileUrl = url("/web/image", {
+                            model: data.model,
+                            id: data.res_id,
+                            field: key,
+                            unique: '',
+                            timer
+                        });
+               
+                    break;
+                case 'iframe':
+                 
+                    const iframe_file_url = encodeURIComponent(
+                        url("/web/content", {
+                            model: data.model,
+                            id: data.res_id,
+                            field: key,
+                        })
+                    );
+                    fileUrl = `${this.state.attachment_base}?file=${iframe_file_url}`;
+                case 'unknown':
+                    fileUrl = encodeURIComponent(
+                        url("/web/content", {
+                            model: data.model,
+                            id: data.res_id,
+                            field: key,
+                        })
+                    );
+            }
+
+            return fileUrl
+        },
+        _getTypeInfo(type, data) {
+            switch (type) {
+                case 'application/pdf':
+                    data.attachment_base = `/web/static/lib/pdfjs/web/viewer.html`;
+                    data.attachment_type = 'iframe'
+                    break;
+                case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+                    data.attachment_base = `/jikimo_attachment_viewer/static/lib/docxjs/viewer.html`;
+                    data.attachment_type = 'iframe'
+                    break;
+                case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
+                    data.attachment_base = `/jikimo_attachment_viewer/static/lib/exceljs/viewer.html`;
+                    data.attachment_type = 'iframe'
+                    break;
+                case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+                    data.attachment_base = '';
+                    data.attachment_type = 'unknown'
+                    break;
+                case 'image/png':
+                case 'image/jpeg':
+                case 'image/jpg':
+                    data.attachment_base = ''
+                    data.attachment_type = 'image'
+                    break;
+                default:
+                    data.attachment_base = ''
+                    data.attachment_type = 'unknown'
+                    break;
+            }
+        }
+    });
+    
+    var CustomListController = ListController.extend({
+        // 可以保留或移除，根据是否需要处理自定义事件
+        // 处理打印操作
+        // rpc.query({
+        //     model: 'sf.demand.plan.print.wizard',
+        //     method: 'demand_plan_print',
+        //     args: [recordIds]
+        // }).then(function(result) {
+        //     self.do_notify("成功", "打印任务已发送到打印机");
+        //     // 刷新视图显示最新状态
+        //     self.reload();
+        // }).catch(function(error) {
+        //     self.do_warn("打印失败", error.data.message || "发生未知错误");
+        // });
+    });
+    
+    var PrintDemand = ListView.extend({
+        config: _.extend({}, ListView.prototype.config, {
+            Renderer: CustomListRenderer,
+            Controller: CustomListController,
+        }),
+    });
+
+    viewRegistry.add('print_demand', PrintDemand);
+
+    return PrintDemand;
+});

sf_demand_plan/static/src/scss/style.css

@@ -0,0 +1,66 @@
+.demand_plan_tree .o_list_table_ungrouped th:not(.o_list_record_selector,.row_no,[data-name=sequence]) {
+    min-width: 98px !important;
+}
+
+.demand_plan_tree .o_list_table_grouped th:not(.o_list_record_selector,.row_no,[data-name=sequence]) {
+    width: 98px !important;
+}
+
+.demand_plan_tree .o_list_table_ungrouped  {
+    min-width: 1900px;
+}
+
+
+.o_selected_row {
+    background-color: #e6f7ff !important;
+    font-weight: bold;
+}
+
+.custom-table-image-container {
+    display: flex;
+    height: calc(95vh - 254px);
+    gap: 20px;
+    position: relative;
+    th.o_list_record_selector, td.o_list_record_selector{
+        display: none;
+    }
+    .custom-preview-container, .print_demand {
+        flex: 1;
+        
+        max-width: 49%;
+        tbody {
+            tr:not(.o_data_row) {
+                display: none;
+            }
+        }
+        tfoot {
+            display: none;
+        }
+    }
+    .print_demand {
+        .table-responsive {
+            width: 100%;
+            overflow-x: auto!important;
+        }
+    }
+    .custom-preview-container {
+        background-color: #dadce0;
+        padding: 20px;
+        img {
+            max-width: 100%;
+            max-height: 100%;
+        }
+        iframe {
+            width: 100%;
+            height: 100%;
+        }
+    }
+    .o_print_custom, .o_cancel_custom {
+        position: absolute;
+        bottom: 20px;
+        right: 20px;
+    }
+    .o_print_custom {
+        right: 66px;
+    }
+}

sf_demand_plan/views/demand_plan.xml

@@ -0,0 +1,123 @@
+<odoo>
+    <record id="view_sf_production_demand_plan_tree" model="ir.ui.view">
+        <field name="name">sf.production.demand.plan.tree</field>
+        <field name="model">sf.production.demand.plan</field>
+        <field name="arch" type="xml">
+            <tree string="需求计划" default_order="sequence desc,create_date desc" editable="bottom"
+                  class="demand_plan_tree">
+                <header>
+                    <button string="打印" name="button_action_print" type="object"
+                            class="btn-primary"/>
+                </header>
+                <field name="sequence" widget="handle"/>
+                <field name="id" optional="hide"/>
+                <field name="priority"/>
+                <field name="status"/>
+                <field name="partner_id"/>
+                <field name="order_remark"/>
+                <field name="glb_url" optional="hide"/>
+                <field name="product_id"/>
+                <field name="model_id" optional="hide"/>
+                <field name="part_name"/>
+                <field name="part_number"/>
+                <field name="is_incoming_material"/>
+                <field name="supply_method"/>
+                <field name="product_uom_qty"/>
+                <field name="deadline_of_delivery"/>
+                <field name="inventory_quantity_auto_apply"/>
+                <field name="qty_delivered"/>
+                <field name="qty_to_deliver"/>
+                <field name="model_long"/>
+                <field name="materials_id"/>
+                <field name="model_machining_precision"/>
+                <field name="model_process_parameters_ids" widget="many2many_tags"/>
+                <field name="product_remark" optional="hide"/>
+                <field name="order_code" optional="hide"/>
+                <field name="sale_order_id" optional="hide"/>
+                <field name="sale_order_line_number" optional="hide"/>
+                <field name="order_state"/>
+                <field name="route_id" optional="hide"/>
+                <field name="contract_date"/>
+                <field name="date_order"/>
+                <field name="contract_code"/>
+                <field name="plan_remark"/>
+                <field name="processing_time"/>
+                <field name="material_check" optional="hide"/>
+                <field name="hide_action_open_mrp_production" invisible="1"/>
+                <field name="hide_action_purchase_orders" invisible="1"/>
+                <field name="hide_action_stock_picking" invisible="1"/>
+                <field name="hide_action_view_programming" invisible="1"/>
+                <button name="action_open_sale_order" type="object" string="供货方式待确认" class="btn-secondary"
+                        attrs="{'invisible': [('supply_method', '!=', False)]}"/>
+                <button name="action_open_mrp_production" type="object" string="待工艺确认" class="btn-secondary"
+                        attrs="{'invisible': [('hide_action_open_mrp_production', '=', False)]}"/>
+                <button name="action_view_purchase_request" type="object" string="采购申请" class="btn-secondary"
+                        attrs="{'invisible': [('hide_action_purchase_orders', '=', False)]}"/>
+                <button name="action_view_stock_picking" type="object" string="调拨单" class="btn-secondary"
+                        attrs="{'invisible': [('hide_action_stock_picking', '=', False)]}"/>
+                <button name="action_view_programming" type="object" string="编程单" class="btn-secondary"
+                        attrs="{'invisible': [('hide_action_view_programming', '=', False)]}"/>
+                <field name="planned_start_date"/>
+                <field name="actual_start_date"/>
+                <field name="actual_end_date"/>
+                <field name="create_date" optional="hide" string="创建时间"/>
+                <field name="create_uid" optional="hide" string="创建人"/>
+                <field name="write_date" string="更新时间"/>
+                <field name="write_uid" optional="hide" string="更新人"/>
+                <field name="print_count"/>
+                <button name="release_production_order" type="object" string="下达生产" class="btn-primary"
+                        attrs="{'invisible': ['|',('status', '!=', '50'), ('supply_method', 'not in', ['automation', 'manual'])]}"/>
+            </tree>
+        </field>
+    </record>
+
+    <record id="view_sf_production_demand_plan_search" model="ir.ui.view">
+        <field name="name">sf.production.demand.plan.search</field>
+        <field name="model">sf.production.demand.plan</field>
+        <field name="arch" type="xml">
+            <search>
+                <field name="order_remark"/>
+                <field name="product_id"/>
+                <field name="part_name"/>
+                <field name="part_number"/>
+                <field name="partner_id"/>
+                <field name="supply_method"/>
+                <field name="materials_id"/>
+                <field name="model_process_parameters_ids"/>
+                <field name="plan_remark"/>
+                <field name="contract_code"/>
+                <group expand="0" string="Group By">
+                    <filter name="group_by_priority" string="优先级" domain="[]" context="{'group_by': 'priority'}"/>
+                    <filter name="group_by_status" string="状态" domain="[]" context="{'group_by': 'status'}"/>
+                    <filter name="group_by_partner_id" string="客户" domain="[]" context="{'group_by': 'partner_id'}"/>
+                    <filter name="group_by_is_incoming_material" string="客供料" domain="[]"
+                            context="{'group_by': 'is_incoming_material'}"/>
+                    <filter name="group_by_supply_method" string="供货方式" domain="[]"
+                            context="{'group_by': 'supply_method'}"/>
+                    <filter name="group_by_deadline_of_delivery" string="客户交期" domain="[]"
+                            context="{'group_by': 'deadline_of_delivery'}"/>
+                    <filter name="group_by_materials_id" string="材料" domain="[]"
+                            context="{'group_by': 'materials_id'}"/>
+                    <filter name="group_by_contract_code" string="合同号" domain="[]"
+                            context="{'group_by': 'contract_code'}"/>
+                </group>
+            </search>
+        </field>
+    </record>
+
+    <record id="sf_production_demand_plan_action" model="ir.actions.act_window">
+        <field name="name">需求计划</field>
+        <field name="type">ir.actions.act_window</field>
+        <field name="res_model">sf.production.demand.plan</field>
+        <field name="view_mode">tree</field>
+    </record>
+
+
+    <menuitem
+            id="demand_plan_menu"
+            name="需求计划"
+            sequence="140"
+            action="sf_production_demand_plan_action"
+            parent="sf_plan.sf_production_plan_menu"
+    />
+</odoo>

sf_demand_plan/wizard/__init__.py

@@ -0,0 +1 @@
+from . import sf_demand_plan_print_wizard

sf_demand_plan/wizard/sf_demand_plan_print_wizard.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+import logging
+from odoo import models, fields, api, _
+
+_logger = logging.getLogger(__name__)
+
+
+class SfDemandPlanPrintWizard(models.TransientModel):
+    _name = 'sf.demand.plan.print.wizard'
+    _description = u'打印向导'
+
+    demand_plan_id = fields.Many2one('sf.production.demand.plan', string='需求计划ID')
+    product_id = fields.Many2one(
+        comodel_name='product.product',
+        related='demand_plan_id.product_id',
+        string='产品', store=True, index=True)
+    model_id = fields.Char('模型ID')
+    filename_url = fields.Char('文件名/URL')
+    type = fields.Selection([
+        ('1', '图纸'),
+        ('2', '程序单'),
+    ], string='类型')
+    status = fields.Selection([
+        ('not_start', '未开始'),
+        ('success', '成功'),
+        ('fail', '失败'),
+    ], string='状态', default='not_start')
+    machining_drawings = fields.Binary('2D加工图纸', related='product_id.machining_drawings', store=True)
+
+    workorder_id = fields.Many2one('mrp.workorder', string='工单')
+    cnc_worksheet = fields.Binary('程序单')
+
+    @api.model
+    def demand_plan_print(self, print_ids):
+        plan_print_ids = self.env['sf.demand.plan.print.wizard'].sudo().search(
+            [('id', 'in', print_ids)])
+        if not plan_print_ids:
+            return {'message': '记录不存在'}
+        success_records = []
+        failed_records = []
+        for record in plan_print_ids:
+            pdf_data = record.machining_drawings if record.type == '1' else record.cnc_worksheet
+            if pdf_data:
+                try:
+                    # 执行打印
+                    self.env['jikimo.printing'].sudo().print_pdf(pdf_data)
+                    record.status = 'success'
+                    t_part, c_part = record.demand_plan_id.print_count.split('C')
+                    t_num = int(t_part[1:])
+                    c_num = int(c_part)
+                    if record.type == '1':
+                        t_num += 1
+                    elif record.type == '2':
+                        c_num += 1
+                    record.demand_plan_id.print_count = f"T{t_num}C{c_num}"
+                    success_records.append({
+                        'filename_url': record.filename_url,
+                    })
+                except Exception as e:
+                    record.status = 'fail'
+                    _logger.error(f"文件{record.filename_url}打印失败: {str(e)}")
+                    failed_records.append({
+                        'filename_url': record.filename_url,
+                    })
+        if failed_records:
+            message = f"成功打印 {len(success_records)} 个文件，失败 {len(failed_records)} 个"
+        else:
+            message = f"所有 {len(success_records)} 个文件打印成功"
+        return {'message': message}
+
+
+class MrpWorkorder(models.Model):
+    _inherit = 'mrp.workorder'
+
+    def write(self, vals):
+        res = super(MrpWorkorder, self).write(vals)
+        for record in self:
+            if 'cnc_worksheet' in vals:
+                demand_plan_print = self.env['sf.demand.plan.print.wizard'].sudo().search(
+                    [('workorder_id', '=', record.id)])
+                if demand_plan_print:
+                    self.env['sf.demand.plan.print.wizard'].sudo().write(
+                        {'cnc_worksheet': record.cnc_worksheet, 'filename_url': record.cnc_worksheet_name})
+                else:
+                    demand_plan = self.env['sf.production.demand.plan'].sudo().search(
+                        [('product_id', '=', record.product_id.id)])
+                    if demand_plan:
+                        wizard_vals = {
+                            'demand_plan_id': demand_plan.id,
+                            'model_id': demand_plan.model_id,
+                            'type': '2',
+                            'workorder_id': record.id,
+                            'cnc_worksheet': record.cnc_worksheet,
+                            'filename_url': record.cnc_worksheet_name
+                        }
+                        self.env['sf.demand.plan.print.wizard'].sudo().create(wizard_vals)
+        return res

sf_demand_plan/wizard/sf_demand_plan_print_wizard_view.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<odoo>
+    <record id="action_plan_print_tree" model="ir.ui.view">
+        <field name="name">sf.demand.plan.print.wizard.tree</field>
+        <field name="model">sf.demand.plan.print.wizard</field>
+        <field name="arch" type="xml">
+            <tree string="打印" class="print_demand"  js_class="print_demand" >
+                <field name="model_id"/>
+                <field name="filename_url"/>
+                <field name="type"/>
+                <field name="machining_drawings"  attrs="{'column_invisible': True }"/>
+                <field name="cnc_worksheet" attrs="{'column_invisible': True }" />
+                <field name="status"/>
+            </tree>
+        </field>
+    </record>
+
+    <record id="action_plan_print_search" model="ir.ui.view">
+        <field name="name">sf.demand.plan.print.wizard.search</field>
+        <field name="model">sf.demand.plan.print.wizard</field>
+        <field name="arch" type="xml">
+            <search>
+                <field name="type"/>
+                <filter string="图纸" name="filter_type_1" domain="[('type', '=', '1')]"/>
+                <filter string="程序单" name="filter_type_2" domain="[('type', '=', '2')]"/>
+                <filter string="图纸、程序单" name="filter_type_all" domain="[('type', 'in', ('1','2'))]"/>
+                <separator/>
+                <group expand="0" string="Group By">
+                    <filter name="group_by_type" string="类型" domain="[]" context="{'group_by': 'type'}"/>
+                </group>
+            </search>
+        </field>
+    </record>
+</odoo>

sf_dlm/models/product_template.py

@@ -10,6 +10,7 @@ class ResProductTemplate(models.Model):
     model_name = fields.Char('模型名称')
     categ_type = fields.Selection(
         [("成品", "成品"), ("胚料", "胚料"), ("原材料", "原材料")], string='产品的类别', related='categ_id.type', store=True)
+    blank_type = fields.Selection([('圆料', '圆料'), ('方料', '方料')], string='坯料分类')
     model_long = fields.Float('模型长[mm]', digits=(16, 3))
     model_width = fields.Float('模型宽[mm]', digits=(16, 3))
     model_height = fields.Float('模型高[mm]', digits=(16, 3))
@@ -74,6 +75,7 @@ class ResProductTemplate(models.Model):
         attachment = self.attachment_create(item['model_name'], item['model_data'])
         vals = {
             'name': '%s-%s-%s' % ('P', order_id.name, i),
+            'blank_type': item.get('blank_type'),
             'model_long': item['model_long'] + model_type.embryo_tolerance,
             'model_width': item['model_width'] + model_type.embryo_tolerance,
             'model_height': item['model_height'] + model_type.embryo_tolerance,

sf_dlm_management/views/product_template_management_view.xml

@@ -95,7 +95,7 @@
                     <page string="加工参数">
                         <group>
                             <group string="模型">
-                                <label for="model_long" string="尺寸[mm]"/>
+                                <label for="model_long" string="坯料尺寸[mm]"/>
                                 <div class="o_address_format">
                                     <label for="model_long" string="长"/>
                                     <field name="model_long" class="o_address_zip"/>
@@ -104,6 +104,7 @@
                                     <label for="model_height" string="高"/>
                                     <field name="model_height" class="o_address_zip"/>
                                 </div>
+                                <field name="blank_type" readonly="1"/>
                                 <field name="model_volume" string="体积[mm³]"/>
                                 <field name="product_model_type_id" string="模型类型"/>
                                 <field name="model_processing_panel" placeholder="例如R,U" string="加工面板"

sf_manufacturing/controllers/controllers.py

@@ -445,32 +445,7 @@ class Manufacturing_Connect(http.Controller):
                         shelfinfo = list(filter(lambda x: x.get('DeviceId') == DeciveId,
                                                 request.env['sf.shelf.location'].sudo().get_sf_shelf_location_info(
                                                     DeciveId)))
-                        total_data = request.env['sf.shelf.location.datasync'].sudo().get_total_data()
+                        request.env['sf.shelf.location.datasync'].sudo().set_shelf_location(shelfinfo)
-                        for item in shelfinfo:
-                            logging.info('货架已获取信息:%s' % item)
-                            shelf_barcode = request.env['sf.shelf.location.datasync'].sudo().find_our_code(
-                                total_data, item['Postion'])
-                            location_id = request.env['sf.shelf.location'].sudo().search(
-                                [('barcode', '=', shelf_barcode)],
-                                limit=1)
-                            if location_id:
-                                # 如果是线边刀库信息,则对功能刀具移动生成记录
-                                if 'Tool' in item['Postion']:
-                                    tool = request.env['sf.functional.cutting.tool.entity'].sudo().search(
-                                        [('rfid', '=', item['RfidCode']), ('functional_tool_status', '!=', '已拆除')])
-                                    tool.sudo().tool_in_out_stock_location(location_id)
-                                    if tool:
-                                        location_id.product_sn_id = tool.barcode_id.id
-                                        # 修改功能刀具状态
-                                        if item.get('State') == '报警':
-                                            if tool.functional_tool_status != item.get('State'):
-                                                tool.write({
-                                                    'functional_tool_status': item['State']
-                                                })
-                                    else:
-                                        location_id.product_sn_id = False
-                                        if item['RfidCode']:
-                                            logging.info('Rfid为【%s】的功能刀具在系统中不存在！' % item['RfidCode'])
                     else:
                         equipment_id = request.env['maintenance.equipment'].sudo().search([('name', '=', DeciveId)])
                         if equipment_id:

sf_manufacturing/controllers/main.py

@@ -27,7 +27,7 @@ class JikimoSaleRoutePicking(Sf_Bf_Connect):
             bfm_process_order_list = json.loads(kw['bfm_process_order_list'])
             order_id = request.env['sale.order'].with_user(request.env.ref("base.user_admin")).sale_order_create(
                 company_id, kw['delivery_name'], kw['delivery_telephone'], kw['delivery_address'],
-                kw['delivery_end_date'], kw['payments_way'], kw['pay_way'], kw['order_number'], state='draft',
+                kw['delivery_end_date'], kw['payments_way'], kw['pay_way'], kw['order_number'], kw['remark'], state='draft',
                 model_display_version=kw.get('model_display_version'))
             i = 1
             # 给sale_order的default_code字段赋值
@@ -45,9 +45,8 @@ class JikimoSaleRoutePicking(Sf_Bf_Connect):
                 product.product_tmpl_id.is_customer_provided = True if item['embryo_redundancy_id'] else False
                 order_id.with_user(request.env.ref("base.user_admin")).sale_order_create_line(product, item)
                 i += 1
-            if kw.get('contract_file_name') and kw.get('contract_file') and kw.get('contract_code'):
+            # BFM 内部下单 新增合同等内容补充
-                order_id.create_sale_documents(kw.get('contract_file_name'), kw.get('contract_file'))
+            order_id.write_sale_documents(kw)
-                order_id.write({'contract_code': kw.get('contract_code')})
             res['factory_order_no'] = order_id.name
             order_id.confirm_to_supply_method()
         except Exception as e:

sf_manufacturing/models/mrp_production.py

@@ -283,6 +283,8 @@ class MrpProduction(models.Model):
                     # 如果匹配成功，提取结果
                     if match:
                         product_name = match.group(0)
+                    else:
+                        product_name = production_id.product_id.name
                     if production_id.sale_order_id:
                         sale_order = production_id.sale_order_id
                     else:

sf_manufacturing/models/mrp_workorder.py

@@ -227,22 +227,30 @@ class ResMrpWorkOrder(models.Model):
                 # finish_move.move_dest_ids.move_line_ids.reserved_uom_qty = 0
         else:
             next_workorder = sorted_workorders[position + 1]
-            next_state = next_workorder.state
+            # 持续获取下一个工单，直到找到一个不是返工的工单
-            if next_state not in ['pending', 'waiting', 'ready']:
+            while next_workorder and next_workorder.state == 'rework':
-                raise UserError('下工序已经开始，无法回退')
+                position += 1
-            if next_workorder.is_subcontract:
+                if position + 1 < len(sorted_workorders):
-                next_workorder.picking_ids.write({'state': 'waiting'})
+                    next_workorder = sorted_workorders[position + 1]
-            next_workorder.state = 'pending'
-            self.time_ids.date_end = None
-            cur_workorder.state = 'progress'
-            cur_workorder.production_id.state = 'progress'
-            quality_check = self.env['quality.check'].search(
-                [('workorder_id', '=', self.id)])
-            for check_order in quality_check:
-                if check_order.point_id.is_inspect:
-                    check_order.quality_state = 'waiting'
                 else:
-                    check_order.quality_state = 'none'
+                    next_workorder = None
+            if next_workorder:
+                next_state = next_workorder.state
+                if next_state not in ['pending', 'waiting', 'ready']:
+                    raise UserError('下工序已经开始，无法回退')
+                if next_workorder.is_subcontract:
+                    next_workorder.picking_ids.write({'state': 'waiting'})
+                next_workorder.state = 'pending'
+                self.time_ids.date_end = None
+                cur_workorder.state = 'progress'
+                cur_workorder.production_id.state = 'progress'
+                quality_check = self.env['quality.check'].search(
+                    [('workorder_id', '=', self.id)])
+                for check_order in quality_check:
+                    if check_order.point_id.is_inspect:
+                        check_order.quality_state = 'waiting'
+                    else:
+                        check_order.quality_state = 'none'
 
     def _compute_working_users(self):
         super()._compute_working_users()
@@ -326,6 +334,7 @@ class ResMrpWorkOrder(models.Model):
 
     tag_type = fields.Selection([("重新加工", "重新加工")], string="标签", tracking=True)
     technology_design_id = fields.Many2one('sf.technology.design')
+    cnc_worksheet_name = fields.Char('工作指令文件名', readonly=True)
 
     def _compute_default_construction_period_status(self):
         need_list = ['pending', 'waiting', 'ready', 'progress', 'to be detected', 'done']

sf_manufacturing/models/product_template.py

@@ -26,6 +26,7 @@ class ResProductMo(models.Model):
     model_file = fields.Binary('模型文件')
     categ_type = fields.Selection(string='产品的类别', related='categ_id.type', store=True)
     model_name = fields.Char('模型名称')
+    blank_type = fields.Selection([('圆料', '圆料'), ('方料', '方料')], string='坯料分类')
     model_long = fields.Float('模型长(mm)', digits=(16, 3))
     model_width = fields.Float('模型宽(mm)', digits=(16, 3))
     model_height = fields.Float('模型高(mm)', digits=(16, 3))
@@ -799,6 +800,8 @@ class ResProductMo(models.Model):
                 # 如果匹配成功，提取结果
                 if match:
                     product_name = match.group(0)
+                else:
+                    product_name = record.name
                 sale_order_name = ''
                 match_sale = re.search(r'S(\d+)', record.name)
                 if match_sale:
@@ -890,8 +893,10 @@ class ResProductMo(models.Model):
             embryo_redundancy_id = item.get('embryo_redundancy')
         if not embryo_redundancy_id:
             raise UserError('请先配置模型类型内的坯料冗余')
+        product_name = self.generate_product_name(order_id, item, i)
         vals = {
-            'name': '%s-%s-%s' % ('P', order_id.name, i),
+            'name': product_name,
+            'blank_type': item.get('blank_type'),
             'model_long': self.format_float(item['model_long'] + embryo_redundancy_id.long),
             'model_width': self.format_float(item['model_width'] + embryo_redundancy_id.width),
             'model_height': self.format_float(item['model_height'] + embryo_redundancy_id.height),
@@ -1012,12 +1017,9 @@ class ResProductMo(models.Model):
         if not embryo_redundancy_id:
             raise UserError('请先配置模型类型内的坯料冗余')
         logging.info('no_bom_copy_product_supplier-vals:%s' % supplier)
+        embryo_name = self.generate_embryo_name(order_id, item, materials_id, materials_type_id, embryo_redundancy_id, i)
         vals = {
-            'name': '%s-%s-%s [%s %s-%s * %s * %s]' % ('R',
+            'name': embryo_name,
-                                                       order_id.name, i, materials_id.name, materials_type_id.name,
-                                                       self.format_float(item['model_long'] + embryo_redundancy_id.long),
-                                                       self.format_float(item['model_width'] + embryo_redundancy_id.width),
-                                                       self.format_float(item['model_height'] + embryo_redundancy_id.height)),
             'length': self.format_float(item['model_long'] + embryo_redundancy_id.long),
             'width': self.format_float(item['model_width'] + embryo_redundancy_id.width),
             'height': self.format_float(item['model_height'] + embryo_redundancy_id.height),
@@ -1119,7 +1121,19 @@ class ResProductMo(models.Model):
 
     # 增加产品表面积
 
+    def generate_product_name(self, order_id, item, i):
+        """生成成品名称"""
+        product_name = '%s-%s-%s' % ('P', order_id.name, i)
+        return product_name
 
+    def generate_embryo_name(self, order_id, item,  materials_id, materials_type_id, embryo_redundancy_id, i):
+        """生成坯料名称"""
+        embryo_name = '%s-%s-%s [%s %s-%s * %s * %s]' % ('R',
+                                                       order_id.name, i, materials_id.name, materials_type_id.name,
+                                                       self.format_float(item['model_long'] + embryo_redundancy_id.long),
+                                                       self.format_float(item['model_width'] + embryo_redundancy_id.width),
+                                                       self.format_float(item['model_height'] + embryo_redundancy_id.height))
+        return embryo_name
 
 class ResProductFixture(models.Model):
     _inherit = 'product.template'

sf_manufacturing/models/purchase_order.py

@@ -212,6 +212,8 @@ class PurchaseOrderLine(models.Model):
                 # 如果匹配成功，提取结果
                 if match:
                     product_name = match.group(0)
+                else:
+                    product_name = record.product_id.name
                 sale_order_name = ''
                 match_sale = re.search(r'S(\d+)', record.product_id.name)
                 if match_sale:

sf_manufacturing/models/sale_order.py

@@ -74,14 +74,17 @@ class SaleOrder(models.Model):
                 'blank_area': product.model_area,
                 'price': product.list_price,
                 'embryo_redundancy_id': line.embryo_redundancy_id,
+                'model_id': line.model_id
             }
             product_name = ''
             match = re.search(r'(S\d{5}-\d+)', product.name)
+            product_seria = 0
             # 如果匹配成功，提取结果
             if match:
                 product_name = match.group(0)
-            # 获取成品名结尾-n的n
+                # 获取成品名结尾-n的n
-            product_seria = int(product_name.split('-')[-1])
+                product_seria = int(product_name.split('-')[-1])
+            
             # 成品供货方式为采购则不生成bom
             if line.supply_method != 'purchase':
                 bom_data = self.env['mrp.bom'].with_user(self.env.ref("base.user_admin")).get_bom(product)
@@ -190,6 +193,19 @@ class SaleOrder(models.Model):
             'target': 'new',
             'res_id': wizard.id,
         }
+
+    def write_sale_documents(self, kw):
+        """BFM 内部下单 内容补充 """
+        val = {}
+        if kw.get('contract_file_name') and kw.get('contract_file'):
+            document_id = self.create_sale_documents(kw.get('contract_file_name'), kw.get('contract_file'))
+            val.update({'contract_document_id': document_id.id})
+        if kw.get('contract_code') or kw.get('contract_date'):
+            val.update({'contract_code': kw.get('contract_code'), 'contract_date': kw.get('contract_date')})
+        if kw.get('customer_name'):
+            val.update({'customer_name': kw.get('customer_name')})
+        self.write(val)
+
     def create_sale_documents(self, contract_file_name, contract_file):
         # 创建ir.attachment记录
         attachment = self.env['ir.attachment'].sudo().create({
@@ -211,9 +227,7 @@ class SaleOrder(models.Model):
             'res_id': self.id,
         })
 
-        self.write({
+        return document
-            'contract_document_id': document.id
-        })
 
 class SaleOrderLine(models.Model):
     _inherit = 'sale.order.line'

sf_manufacturing/models/sf_technology_design.py

@@ -23,7 +23,6 @@ class sf_technology_design(models.Model):
     # def _compute_group_uniq_id(self):
     #     for record in self:
 
-
     def json_technology_design_str(self, k, route, i, process_parameter):
         workorders_values_str = [0, '', {
             'route_id': route.id if route.routing_type in ['表面工艺'] else route.route_workcenter_id.id,
@@ -36,11 +35,19 @@ class sf_technology_design(models.Model):
         return workorders_values_str
 
     def write(self, vals):
-        return super(sf_technology_design, self).write(vals)
+        res = super(sf_technology_design, self).write(vals)
+        if 'group_uniq_id' in vals or 'process_parameters_id' in vals or 'active' in vals:
+            if self.production_id:
+                process_parameters_id = self.production_id.technology_design_ids.mapped('process_parameters_id')
+                if process_parameters_id.ids:
+                    self.production_id.product_id.model_process_parameters_ids = process_parameters_id.ids
+                else:
+                    self.production_id.product_id.model_process_parameters_ids = None
+        return res
+
     def unlink_technology_design(self):
         self.active = False
 
-
     @api.model_create_multi
     def create(self, vals_list):
         for vals in vals_list:
@@ -48,10 +55,12 @@ class sf_technology_design(models.Model):
                 raise ValidationError(_("工序不能为空"))
         result = super(sf_technology_design, self).create(vals_list)
         for res in result:
-            record = self.search([('production_id', '=', res.production_id.id), ('active', 'in', [True, False])], order='group_uniq_id desc', limit=1)
+            record = self.search([('production_id', '=', res.production_id.id), ('active', 'in', [True, False])],
-            res.group_uniq_id=record.group_uniq_id + 1
+                                 order='group_uniq_id desc', limit=1)
+            res.group_uniq_id = record.group_uniq_id + 1
         return result
-    def get_duplicates_with_inactive(self,technology_designs):
+
+    def get_duplicates_with_inactive(self, technology_designs):
         # 统计每个 'sequence' 出现的次数
         sequence_count = Counter(technology_design.sequence for technology_design in technology_designs)
 
@@ -62,6 +71,7 @@ class sf_technology_design(models.Model):
         ]
 
         return result
+
     # def rearrange_numbering(self,self_technology_designs):
     #     inactive_designs = self.get_duplicates_with_inactive(self_technology_designs)
     #     if inactive_designs:
@@ -75,7 +85,7 @@ class sf_technology_design(models.Model):
 
     def get_technology_design(self):
         return {
-            'sequence':self.sequence,
+            'sequence': self.sequence,
             'route_id': self.route_id.id,
             'process_parameters_id': self.process_parameters_id.id,
             'panel': self.panel,
@@ -83,17 +93,19 @@ class sf_technology_design(models.Model):
             'time_cycle_manual': self.time_cycle_manual,
             'is_auto': self.is_auto,
             'active': self.active,
-            'group_uniq_id':self.group_uniq_id,
+            'group_uniq_id': self.group_uniq_id,
         }
-    def sync_technology_designs(self,production_technology_designs, self_technology_designs):
+
+    def sync_technology_designs(self, production_technology_designs, self_technology_designs):
         production_id = production_technology_designs[0].production_id.id
-        self_technology_design_dict = {item.group_uniq_id:item for item in self_technology_designs}
+        self_technology_design_dict = {item.group_uniq_id: item for item in self_technology_designs}
-        production_technology_designs_dict = {item.group_uniq_id:item for item in production_technology_designs}
+        production_technology_designs_dict = {item.group_uniq_id: item for item in production_technology_designs}
         for technology_design in production_technology_designs:
             if not self_technology_design_dict.get(technology_design.group_uniq_id):
                 technology_design.write({'production_id': False})
             else:
-                technology_design.write(self_technology_design_dict.get(technology_design.group_uniq_id).get_technology_design())
+                technology_design.write(
+                    self_technology_design_dict.get(technology_design.group_uniq_id).get_technology_design())
         for technology_design in self_technology_designs:
             if not production_technology_designs_dict.get(technology_design.group_uniq_id):
                 technology_design = technology_design.get_technology_design()
@@ -101,9 +113,8 @@ class sf_technology_design(models.Model):
                 technology_design.pop('group_uniq_id')
                 self.env['sf.technology.design'].create(technology_design)
 
-
+    def unified_procedure_multiple_work_orders(self, self_technology_designs, production_item):
-
-    def unified_procedure_multiple_work_orders(self,self_technology_designs,production_item):
         technology_designs = self.env['sf.technology.design'].sudo().search(
             [('production_id', '=', production_item.id), ('active', 'in', [True, False])])
-        self.sync_technology_designs(self_technology_designs=self_technology_designs,production_technology_designs=technology_designs)
+        self.sync_technology_designs(self_technology_designs=self_technology_designs,
+                                     production_technology_designs=technology_designs)

sf_manufacturing/models/stock.py

@@ -637,6 +637,8 @@ class StockPicking(models.Model):
                     if lot_ids:
                         move.action_clear_lines_show_details()
                         move.action_show_details()
+        # 先进行设置数量
+        self.action_set_quantities_to_reservation()
         res = super().button_validate()
         # lot_ids = None
         # product_ids = self.move_ids.mapped('product_id')
@@ -861,6 +863,8 @@ class ReStockMove(models.Model):
                     # 如果匹配成功，提取结果
                     if match:
                         product_name = match.group(0)
+                    else:
+                        product_name = move.product_id.name
                     if move.picking_id.sale_order_id:
                         sale_order = move.picking_id.sale_order_id
                     else:
@@ -893,6 +897,8 @@ class ReStockMove(models.Model):
                     # 如果匹配成功，提取结果
                     if match:
                         product_name = match.group(0)
+                    else:
+                        product_name = production_id.product_id.name
                     if move.picking_id.sale_order_id:
                         sale_order = move.picking_id.sale_order_id
                     else:

sf_message/data/template_data.xml

@@ -210,8 +210,8 @@
             <field name="msgtype">markdown</field>
             <field name="urgency">normal</field>
             <field name="content">### 功能刀具寿命到期提醒：
-单号：拆解单[{{code}}]({{tool_expired_remind_special_url}})
+单号：拆解单[{{code}}]({{request_url}})
-事项：{{functional_tool_id.tool_name_id.name}}寿命已到期，需拆解</field>
+事项：{{name}}寿命已到期，需拆解</field>
         </record>
 
         <record id="template_tool_assembly_remind" model="jikimo.message.template">

sf_message/models/sf_message_functional_tool_dismantle.py

@@ -1,4 +1,5 @@
 from odoo import models, api
+from urllib.parse import urlencode
 
 
 class SFMessagefunctionalToolDismantle(models.Model):
@@ -18,12 +19,39 @@ class SFMessagefunctionalToolDismantle(models.Model):
                 obj.add_queue('功能刀具寿命到期')
         return result
 
-    def get_special_url(self,id,tmplate_name,special_name,model_id):
+    def _get_message(self, message_queue_ids):
+        contents = []
+        for message_queue_id in message_queue_ids:
+            if message_queue_id.message_template_id.name == '功能刀具寿命到期':
+                content = message_queue_id.message_template_id.content
+                td_line = self.search([('id', '=', int(message_queue_id.res_id))])
+                url = self.request_url(int(message_queue_id.res_id))
+                content = content.replace('{{code}}', td_line.code).replace(
+                    '{{request_url}}', url).replace('{{name}}', td_line.name)
+                contents.append(content)
+        return contents, message_queue_ids
+
+    def request_url(self, id):
+        url = self.env['ir.config_parameter'].get_param('web.base.url')
+        action_id = self.env.ref('sf_tool_management.sf_functional_tool_dismantle_view_act').id
+        menu_id = self.env.ref('sf_tool_management.menu_sf_functional_tool_dismantle').id
+        # 查询参数
+        params = {'id': id, 'menu_id': menu_id, 'action': action_id,
+                  'model': 'sf.functional.tool.dismantle',
+                  'view_type': 'form'}
+        # 拼接查询参数
+        tool_string = urlencode(params)
+        # 拼接URL
+        full_url = url + "/web#" + tool_string
+        return full_url
+
+    def get_special_url(self, id, tmplate_name, special_name, model_id):
         menu_id = 0
         action_id = 0
-        if tmplate_name=='调拨入库' and special_name== 'tool_expired_remind_special_url':
+        if tmplate_name == '调拨入库' and special_name == 'tool_expired_remind_special_url':
             menu_id = self.env.ref('mrp.menu_mrp_root').id
             action_id = self.env.ref('sf_tool_management.sf_functional_tool_dismantle_view_act').id
-            return super(SFMessagefunctionalToolDismantle, self).get_url(id, menu_id, action_id,model_id)
+            return super(SFMessagefunctionalToolDismantle, self).get_url(id, menu_id, action_id, model_id)
         else:
-            return super(SFMessagefunctionalToolDismantle, self).get_special_url(id, tmplate_name, special_name, model_id)
+            return super(SFMessagefunctionalToolDismantle, self).get_special_url(id, tmplate_name, special_name,
+                                                                                 model_id)

sf_message/models/sf_message_quality_check.py

@@ -43,14 +43,17 @@ class SFMessageQualityCheck(models.Model):
     #          ('message_template_id', '=', message_template.id)])
     #     return jikimo_message_queue
     def write(self, vals):
-        original_state = self.quality_state
+        original_state = {}
+        for item in self:
+            original_state.update({f'{item.id}': item.quality_state})
         res = super(SFMessageQualityCheck, self).write(vals)
-        if res and vals.get('quality_state') == 'none' and original_state != 'none':
+        for item in self:
-            message_template_id = self.env['jikimo.message.template'].sudo().search([('name', '=', '待质检提醒')])
+            if vals.get('quality_state') == 'none' and original_state.get(f'{item.id}') != 'none':
-            queue_id = self.env['jikimo.message.queue'].sudo().search(
+                message_template_id = self.env['jikimo.message.template'].sudo().search([('name', '=', '待质检提醒')])
-                [('message_template_id', '=', message_template_id[-1].id), ('res_id', '=', self.id)])
+                queue_id = self.env['jikimo.message.queue'].sudo().search(
-            if not queue_id and '制造' not in [pt.name for pt in self.point_id.picking_type_ids]:
+                    [('message_template_id', '=', message_template_id[-1].id), ('res_id', '=', item.id)])
-                self.add_queue('待质检')
+                if not queue_id and '制造' not in [pt.name for pt in item.point_id.picking_type_ids]:
+                    item.add_queue('待质检')
         return res
 
     def _get_message(self, message_queue_ids):

sf_mrs_connect/controllers/controllers.py

@@ -42,6 +42,12 @@ class Sf_Mrs_Connect(http.Controller, MultiInheritController):
                 res = {'status': -2, 'message': '查询到待工艺确认的制造订单'}
                 return json.JSONEncoder().encode(res)
             if productions:
+                # 修改需求计划中的程序工时
+                demand_plan = request.env['sf.production.demand.plan'].with_user(
+                    request.env.ref("base.user_admin")).search([('model_id', '=', ret['folder_name'])])
+                if demand_plan and ret['total_estimated_time']:
+                    demand_plan.write(
+                        {'processing_time': ret['total_estimated_time']})
 
                 # 拉取所有加工面的程序文件
                 for r in ret['processing_panel'].split(','):
@@ -91,12 +97,15 @@ class Sf_Mrs_Connect(http.Controller, MultiInheritController):
                         program_path_tmp_panel = os.path.join('/tmp', ret['folder_name'], 'return', panel)
                         files_panel = os.listdir(program_path_tmp_panel)
                         panel_file_path = ''
+                        panel_file_name = ''
                         if files_panel:
                             for file in files_panel:
                                 file_extension = os.path.splitext(file)[1]
                                 if file_extension.lower() == '.pdf':
                                     panel_file_path = os.path.join(program_path_tmp_panel, file)
+                                    panel_file_name = os.path.splitext(file)[0]
                                     logging.info('panel_file_path:%s' % panel_file_path)
+                                    logging.info('panel_file_name:%s' % panel_file_name)
                                     
                             # 向编程单中添加二维码
                             request.env['printing.utils'].add_qr_code_to_pdf(
@@ -105,7 +114,8 @@ class Sf_Mrs_Connect(http.Controller, MultiInheritController):
                                 "模型ID：%s" % model_id,
                                 "零件图号：%s" % part_number if part_number else None
                             )
-                            cnc_workorder.write({'cnc_worksheet': base64.b64encode(open(panel_file_path, 'rb').read())})
+                            cnc_workorder.write({'cnc_worksheet': base64.b64encode(open(panel_file_path, 'rb').read()),
+                                                 'cnc_worksheet_name': panel_file_name})
                             pre_workorder = productions.workorder_ids.filtered(
                                 lambda ap: ap.routing_type in ['装夹预调', '人工线下加工'] and ap.state not in ['done', 'rework'
                                                                                                 'cancel'] and ap.processing_panel == panel)

sf_quality/views/quality_check_view.xml

@@ -66,7 +66,7 @@
                 <attribute name="string">不合格</attribute>
             </xpath>
             <xpath expr="//header//button[@name='do_fail'][2]" position="attributes">
-                <attribute name="attrs">{'invisible': ['|',('quality_state', '!=', 'pass'),('work_state','in', ('done', 'rework'))]}</attribute>
+                <attribute name="attrs">{'invisible': ['|','|',('quality_state', '!=', 'pass'),('work_state','in', ('done', 'rework')),'&amp;',('quality_state', '=', 'pass'), ('test_type', '=', '出厂检验报告')]}</attribute>
                 <attribute name="string">不合格</attribute>
             </xpath>
 

sf_sale/models/sale_order.py

@@ -63,14 +63,16 @@ class ReSaleOrder(models.Model):
 
     model_display_version = fields.Char('模型展示版本', default="v1")
 
+    customer_name = fields.Char('终端客户')
     contract_code = fields.Char('合同编号')
+    contract_date = fields.Date('合同日期')
     contract_document_id = fields.Many2one('documents.document', string='合同文件')
     contract_file = fields.Binary(related='contract_document_id.datas', string='合同文件内容')
     contract_file_name = fields.Char(related='contract_document_id.attachment_id.name', string='文件名')
 
     # 业务平台分配工厂后在智能工厂先创建销售订单
     def sale_order_create(self, company_id, delivery_name, delivery_telephone, delivery_address,
-                          deadline_of_delivery, payments_way, pay_way, order_number, state='sale',
+                          deadline_of_delivery, payments_way, pay_way, order_number, remark, state='sale',
                           model_display_version='v1'):
         now_time = datetime.datetime.now()
         partner = self.get_customer()
@@ -89,6 +91,7 @@ class ReSaleOrder(models.Model):
             'pay_way': pay_way,
             'order_code': order_number,
             'model_display_version': model_display_version,
+            'remark': remark,
         }
         if deadline_of_delivery:
             # deadline_of_delivery字段存在为false字符串情况
@@ -156,6 +159,7 @@ class ReSaleOrder(models.Model):
             'manual_quotation': item.get('manual_quotation'),
             'model_id': item['model_id'],
             'delivery_end_date': item['delivery_end_date'],
+            'customer_delivery_date': item.get('customer_delivery_date'),
         }
         return self.env['sale.order.line'].with_context(skip_procurement=True).create(vals)
 
@@ -289,8 +293,8 @@ class ResaleOrderLine(models.Model):
     manual_quotation = fields.Boolean('人工编程', default=False)
     model_url = fields.Char('模型文件地址')
     model_id = fields.Char('模型ID')
-
     delivery_end_date = fields.Date('交货截止日期')
+    customer_delivery_date = fields.Date('客户交期')
 
     @api.depends('embryo_redundancy_id')
     def _compute_is_incoming_material(self):

sf_sale/views/sale_order_view.xml

@@ -90,6 +90,9 @@
                 <field name="partner_id" position="replace">
                     <field name="partner_id" widget="res_partner_many2one" context="{'is_customer': True }"
                            options='{"always_reload": True,"no_create": True}'/>
+                    <field name="customer_name" readonly="1"/>
+                    <field name="contract_code" readonly="1"/>
+                    <field name="contract_date" readonly="1"/>
                 </field>
                 <field name="payment_term_id" position="attributes">
                     <attribute name="attrs">{'readonly': [('state', 'in', ['cancel','sale'])]}</attribute>
@@ -124,6 +127,7 @@
                 <xpath expr="//field[@name='order_line']/tree/field[@name='name']" position="replace">
                     <field name="name" widget="section_and_note_text" optional="show"
                            string="参数说明(长/宽/高/体积/精度/材质)"/>
+                    <field name="customer_delivery_date" readonly="1"/>
                     <field name="manual_quotation" readonly="1"/>
                     <field name="is_incoming_material" readonly="1"/>
                 </xpath>

sf_tool_management/models/base.py

@@ -818,6 +818,7 @@ class FunctionalToolAssembly(models.Model):
 
     def _get_old_tool_material_lot(self, material_ids):
         """ 根据先进先出原则选择物料批次 """
+        material_ids = material_ids.filtered(lambda m: m.tracking != 'none')
         location_id = self.env['stock.location'].search([('name', '=', '刀具房')])
         stock_quant = self.env['stock.quant'].sudo().search(
             [('location_id', '=', location_id.id), ('product_id', 'in', material_ids.ids), ('quantity', '>', '0')],
@@ -833,8 +834,8 @@ class FunctionalToolAssembly(models.Model):
             location_lots = self.env['sf.shelf.location.lot'].sudo().search([('lot_id', '=', lot_id.id)])
             if location_lots:
                 return location_lots[0]
-        raise ValidationError(f'【{lot_ids[0].product_id.cutting_tool_material_id.name}】物料在货位库存不足，请先进行盘点入库')
+        raise ValidationError(
-
+            f'【{lot_ids[0].product_id.cutting_tool_material_id.name}】物料在货位库存不足，请先进行盘点入库')
 
     def _get_inventory_bom(self, inventory_id):
         """获取BOM的刀具物料产品信息"""
@@ -894,25 +895,25 @@ class FunctionalToolAssembly(models.Model):
             tool_material_ids = self._get_all_material_location_lot(tool_data.get('pad_ids'))
             tool_material_tree_id = self.env.ref('sf_tool_management.view_shelf_location_lot_tree_4')
 
+        action = {
+            "type": "ir.actions.act_window",
+            "target": "new",
+            "domain": [('cutting_tool_type', '=', tool_type)],
+            "context": {'tool_id': self.id, 'search_default_bom_ids': 1, 'tool_material_ids': tool_material_ids.ids}
+        }
         if tool_type == '刀柄':
-            return {
+            action.update({
-                "type": "ir.actions.act_window",
                 "res_model": "product.product",
                 "views": [[tool_material_tree_id.id, "tree"],
-                          [self.env.ref('sf_tool_management.view_tool_product_search').id, "search"]],
+                          [self.env.ref('sf_tool_management.view_tool_product_search').id, "search"]]
-                "target": "new",
+            })
-                "domain": [('id', 'in', tool_material_ids.ids)],
-                "context": {'tool_id': self.id}
-            }
         elif tool_type in ['整体式刀具', '刀片', '刀杆', '刀盘']:
-            return {
+            action.update({
-                "type": "ir.actions.act_window",
                 "res_model": "sf.shelf.location.lot",
-                "views": [[tool_material_tree_id.id, "tree"]],
+                "views": [[tool_material_tree_id.id, "tree"],
-                "target": "new",
+                          [self.env.ref('sf_tool_management.view_shelf_location_lot_search').id, 'search']]
-                "domain": [('id', 'in', tool_material_ids.ids)],
+            })
-                "context": {'tool_id': self.id}
+        return action
-            }
 
     def _get_all_material_location_lot(self, material_ids):
         """ 获取所有满足条件 """

sf_tool_management/models/functional_tool.py

@@ -58,20 +58,6 @@ class FunctionalCuttingToolEntity(models.Model):
     safe_inventory_id = fields.Many2one('sf.real.time.distribution.of.functional.tools',
                                         string='功能刀具安全库存', readonly=True)
 
-    @api.onchange('functional_tool_status')
-    def _onchange_functional_tool_status(self):
-        for item in self:
-            if item:
-                if item.functional_tool_status == '报警':
-                    self.create_tool_dismantle()
-
-    def set_functional_tool_status(self):
-        # self.write({
-        #     'functional_tool_status': '报警'
-        # })
-        self.functional_tool_status = '报警'
-        self.create_tool_dismantle()
-
     def create_tool_dismantle(self):
         for item in self:
             # 创建报警刀具拆解单

sf_tool_management/models/stock.py

@@ -256,6 +256,22 @@ class ProductProduct(models.Model):
         })
         return stock_lot
 
+    def search(self, domain, offset=0, limit=None, order=None, count=False):
+        context = self.env.context
+        tool_material_ids = context.get('tool_material_ids')
+        if tool_material_ids:
+            if context.get('default_tool_bom_id'):
+                domain += [('id', 'in', tool_material_ids)]
+                return super(ProductProduct, self).search(domain, offset=0, limit=None, order=None, count=False)
+            else:
+                domain_1 = domain + [('id', 'in', tool_material_ids)]
+                domain_2 = domain + [('id', 'not in', tool_material_ids)]
+                res_1 = super(ProductProduct, self).search(domain_1, offset=0, limit=None, order=None, count=False)
+                res_2 = super(ProductProduct, self).search(domain_2, offset=0, limit=None, order=None, count=False)
+            return res_1 + res_2
+        else:
+            return super(ProductProduct, self).search(domain, offset=0, limit=None, order=None, count=False)
+
     def get_stock_lot_name(self, obj):
         """
             生成功能刀具序列号
@@ -317,6 +333,22 @@ class SfShelfLocationLot(models.Model):
     fit_blade_shape_id = fields.Many2one('maintenance.equipment.image', '适配刀片形状',
                                          related='product_id.fit_blade_shape_id')
 
+    def search(self, domain, offset=0, limit=None, order=None, count=False):
+        context = self.env.context
+        tool_material_ids = context.get('tool_material_ids')
+        if tool_material_ids:
+            if context.get('default_tool_bom_id'):
+                domain += [('id', 'in', tool_material_ids)]
+                return super(SfShelfLocationLot, self).search(domain, offset=0, limit=None, order=None, count=False)
+            else:
+                domain_1 = domain + [('id', 'in', tool_material_ids)]
+                domain_2 = domain + [('id', 'not in', tool_material_ids)]
+                res_1 = super(SfShelfLocationLot, self).search(domain_1, offset=0, limit=None, order=None, count=False)
+                res_2 = super(SfShelfLocationLot, self).search(domain_2, offset=0, limit=None, order=None, count=False)
+            return res_1 + res_2
+        else:
+            return super(SfShelfLocationLot, self).search(domain, offset=0, limit=None, order=None, count=False)
+
     @api.depends('lot_id')
     def _compute_product_id(self):
         for item in self:

sf_tool_management/views/functional_tool_views.xml

@@ -42,7 +42,6 @@
             <field name="arch" type="xml">
                 <form create="0" edit="0" delete="0">
                     <header>
-                        <button name="set_functional_tool_status" string="报警" type="object" invisible="1"/>
                         <!--                        <button name="enroll_functional_tool_entity" string="功能刀具注册" type="object"-->
                         <!--                                class="btn-primary"/>-->
                         <field name="functional_tool_status" widget="statusbar" statusbar_visible="正常,报警,已拆除"/>
@@ -188,6 +187,7 @@
                                         <field name="current_location" string="当前位置"/>
                                         <field name="current_shelf_location_id" string="当前货位"
                                                attrs="{'invisible': [('current_shelf_location_id', '=', False)]}"/>
+                                        <field name="create_date" string="装刀时间"/>
                                     </group>
                                 </group>
                             </page>

sf_tool_management/views/stock.xml

@@ -33,10 +33,15 @@
     </record>
 
     <record id="view_tool_product_search" model="ir.ui.view">
+        <field name="name">刀柄产品搜索视图</field>
         <field name="model">product.product</field>
+        <field name="priority" eval="10"/>
         <field name="arch" type="xml">
             <search>
                 <field name="name"/>
+                <field name="specification_id"/>
+                <field name="brand_id"/>
+                <filter string="bom物料" name="bom_ids"  domain="[]" context="{'default_tool_bom_id': 1}"/>
             </search>
         </field>
     </record>
@@ -141,4 +146,17 @@
             </tree>
         </field>
     </record>
+
+    <record id="view_shelf_location_lot_search" model="ir.ui.view">
+        <field name="name">sf.shelf.location.lot.search</field>
+        <field name="model">sf.shelf.location.lot</field>
+        <field name="arch" type="xml">
+            <search>
+                <field name="product_id"/>
+                <field name="specification_id"/>
+                <field name="brand_id"/>
+                <filter string="bom物料" name="bom_ids"  domain="[]" context="{'default_tool_bom_id': 1}"/>
+            </search>
+        </field>
+    </record>
 </odoo>

sf_warehouse/migrations/1.2/post-migrate.py

@@ -1,5 +1,8 @@
+import logging
 from odoo import api, SUPERUSER_ID
 
+_logger = logging.getLogger(__name__)
+
 def migrate(cr, version):
     env = api.Environment(cr, SUPERUSER_ID, {})
     sf_shelf_model = env["sf.shelf"]
@@ -9,7 +12,10 @@ def migrate(cr, version):
         shelf_barcode = shelf.barcode or ""
         if not shelf_barcode:
             continue
-        locations = sf_shelf_location_model.search([("shelf_id", "=", shelf.id)], order="id asc")
+        # locations = sf_shelf_location_model.search([("shelf_id", "=", shelf.id)], order="id asc")
+        locations = shelf.location_ids.sorted('id')
         for index, location in enumerate(locations, start=1):
             new_barcode = f"{shelf_barcode}-{index:03d}"
-            location.barcode = new_barcode
+            location.barcode = new_barcode
+        cr.commit()
+        _logger.info('货架【%s】的%d个货位被更新' % (shelf.name, len(locations)))

sf_warehouse/models/sync_common.py

@@ -107,38 +107,47 @@ class MrsShelfLocationDataSync(models.Model):
                     equipment_id.register_equipment_tool()
 
             shelfinfo = self.env['sf.shelf.location'].get_sf_shelf_location_info()
-            total_data = self.get_total_data()
+            self.set_shelf_location(shelfinfo)
-            print('shelfinfo:', shelfinfo)
-            for item in shelfinfo:
-                logging.info('货架已获取信息:%s' % item)
-                shelf_barcode = self.find_our_code(total_data, item['Postion'])
-                location_id = self.env['sf.shelf.location'].search([('barcode', '=', shelf_barcode)], limit=1)
-                if location_id:
-                    # 如果是线边刀库信息,则对功能刀具移动生成记录
-                    if 'Tool' in item['Postion']:
-                        tool = self.env['sf.functional.cutting.tool.entity'].sudo().search(
-                            [('rfid', '=', item['RfidCode']), ('functional_tool_status', '!=', '已拆除')])
-                        tool.tool_in_out_stock_location(location_id)
-                        if tool:
-                            location_id.product_sn_id = tool.barcode_id.id
-                            # 修改功能刀具标准状态值和已使用寿命值、功能刀具状态
-                            if 'LifeStd' in item and 'LifeUse' in item:
-                                tool.sudo().write({
-                                    'max_lifetime_value': item['LifeStd'],
-                                    'used_value': item['LifeUse'],
-                                    'functional_tool_status': item['State'],
-                                })
-                        else:
-                            location_id.product_sn_id = False
-                            if item['RfidCode']:
-                                logging.info('Rfid为【%s】的功能刀具在系统中不存在！' % item['RfidCode'])
-                    else:
-                        stock_lot_obj = self.env['stock.lot'].search([('rfid', '=', item['RfidCode'])], limit=1)
-                        if stock_lot_obj:
-                            location_id.product_sn_id = stock_lot_obj.id
-                        else:
-                            location_id.product_sn_id = False
 
         except Exception as e:
             logging.info("库区信息同步失败:%s" % e)
             raise ValidationError("数据错误导致同步失败,请联系管理员")
+
+    def set_shelf_location(self, shelfinfo):
+        print('shelfinfo:', shelfinfo)
+        total_data = self.get_total_data()
+        for item in shelfinfo:
+            logging.info('货架已获取信息:%s' % item)
+            shelf_barcode = self.env['sf.shelf.location.datasync'].sudo().find_our_code(
+                total_data, item['Postion'])
+            location_id = self.env['sf.shelf.location'].sudo().search(
+                [('barcode', '=', shelf_barcode)],
+                limit=1)
+            if location_id:
+                # 如果是线边刀库信息,则对功能刀具移动生成记录
+                if 'Tool' in item['Postion']:
+                    tool = self.env['sf.functional.cutting.tool.entity'].sudo().search(
+                        [('rfid', '=', item['RfidCode']), ('functional_tool_status', '!=', '已拆除')])
+                    tool.sudo().tool_in_out_stock_location(location_id)
+                    if tool:
+                        location_id.product_sn_id = tool.barcode_id.id
+                        if item.get('State') == '报警' and tool.functional_tool_status != '报警':
+                            # 创建报警刀具拆解单和刀具报警记录
+                            tool.create_tool_dismantle()
+                        # 修改功能刀具标准状态值和已使用寿命值、功能刀具状态
+                        if 'LifeStd' in item and 'LifeUse' in item:
+                            tool.sudo().write({
+                                'max_lifetime_value': item['LifeStd'],
+                                'used_value': item['LifeUse'],
+                                'functional_tool_status': item['State'],
+                            })
+                    else:
+                        location_id.product_sn_id = False
+                        if item['RfidCode']:
+                            logging.info('Rfid为【%s】的功能刀具在系统中不存在！' % item['RfidCode'])
+            else:
+                stock_lot_obj = self.env['stock.lot'].search([('rfid', '=', item['RfidCode'])], limit=1)
+                if stock_lot_obj:
+                    location_id.product_sn_id = stock_lot_obj.id
+                else:
+                    location_id.product_sn_id = False