1.新增刀具物料参数的同步接口及方法

2.修改刀具物料参数的适配刀片型号及适配刀柄型号字段类型及新增刀柄长度，刀柄直径，法兰直径，动平衡等级，适配夹头型号,适用锁紧螺母型号,编码字段

sf_base/models/tool_other_features.py

@@ -6,6 +6,7 @@ class ToolMaterialsBasicParameters(models.Model):
     _description = '刀具物料基本参数'
 
     name = fields.Char('物料号', size=50)
+    code = fields.Char('编码', size=50)
     standard_library_id = fields.Many2one('sf.cutting_tool.standard.library', string='刀具标准库')
     cutting_tool_type = fields.Char(related='standard_library_id.cutting_tool_type', string='刀具物料类型',
                                     store=True)
@@ -73,11 +74,8 @@ class ToolMaterialsBasicParameters(models.Model):
     is_cooling_hole = fields.Boolean('有无冷却孔')
     locating_slot_code = fields.Char('定位槽代号', size=20)
     installing_structure = fields.Char('安装结构', size=20)
-    blade_ids = fields.Many2many(
+    blade_id = fields.Many2one(
-        'sf.cutting.tool.type',
+         'sf.cutting_tool.standard.library',
-        relation='basic_param_pad_blade_rel',
-        column1='model_id_1',
-        column2='model_id_2',
         domain="[('cutting_tool_material_id.name', '=', '刀片')]",
         string='适配刀片型号'  # 使用空列表作为默认值
     )
@@ -91,13 +89,17 @@ class ToolMaterialsBasicParameters(models.Model):
     interface_diameter = fields.Float('接口直径(mm)')
     # 刀柄参数
     flange_shank_length = fields.Float('法兰柄长(mm)')
+    flange_diameter = fields.Float('法兰直径(mm)')
     handle_external_diameter = fields.Float('柄部外径(mm)')
     handle_inside_diameter = fields.Float('柄部内径(mm)')
+    dynamic_balance_class = fields.Char('动平衡等级')
     min_clamping_diameter = fields.Float('最小夹持直径(mm)')
     max_clamping_diameter = fields.Float('最大夹持直径(mm)')
     clamping_mode = fields.Char('夹持方式', size=20)
     max_load_capacity = fields.Float('最大负载能力(kg)')
     taper = fields.Integer('锥度(°)')
+    shank_length = fields.Float('刀柄长度(mm)', digits=(3, 2))
+    shank_diameter = fields.Float('刀柄直径(mm)')
     tool_changing_time = fields.Integer('换刀时间(s)')
     standard_rotate_speed = fields.Integer('标准转速(n/min)')
     max_rotate_speed = fields.Integer('最大转速(n/min)')
@@ -108,6 +110,13 @@ class ToolMaterialsBasicParameters(models.Model):
     is_quick_cutting = fields.Boolean('可高速切削', default=False)
     is_drill_hole = fields.Boolean('可钻孔', default=False)
     is_safe_lock = fields.Boolean('有无安全锁', default=False)
+    chuck_id = fields.Many2one(
+        'sf.cutting_tool.standard.library',
+        domain="[('cutting_tool_material_id.name', '=', '夹头')]",
+        string='适配夹头型号'  # 使用空列表作为默认值
+    )
+    nut = fields.Char('适用锁紧螺母型号')
+
     # 夹头参数
     er_size_model = fields.Char('ER尺寸型号', size=20)
     outer_diameter = fields.Float('外径(mm)')
@@ -118,11 +127,8 @@ class ToolMaterialsBasicParameters(models.Model):
     clamping_length = fields.Float('夹持长度(mm)')
     clamping_tolerance = fields.Char('夹持公差(mm)', size=20)
     cooling_jacket = fields.Char('适用冷却套型号', size=50)
-    handle_ids = fields.Many2many(
+    handle_id = fields.Many2one(
-        'sf.cutting.tool.type',
+        'sf.cutting_tool.standard.library',
-        relation='basic_param_chuck_handle_rel',
-        column1='model_id_1',
-        column2='model_id_2',
         domain="[('cutting_tool_material_id.name', '=', '刀柄')]",
         string='适用刀柄型号'
     )

sf_base/views/tool_views.xml

@@ -277,7 +277,7 @@
                                         <field name="is_cooling_hole" />
                                         <field name="locating_slot_code"/>
                                         <field name="installing_structure"/>
-                                        <field name="blade_ids" widget="many2many_tags" placeholder="请选择"/>
+                                        <field name="blade_id"  placeholder="请选择"/>
                                         <field name="tool_shim"/>
                                         <field name="cotter_pin"/>
                                         <field name="pressing_plate"/>
@@ -300,7 +300,7 @@
                                         <field name="cutting_depth" string="最大切削深度(mm)"/>
                                         <field name="main_included_angle" class="du"/>
                                         <field name="installing_structure"/>
-                                        <field name="blade_ids" widget="many2many_tags" placeholder="请选择"/>
+                                        <field name="blade_id"  placeholder="请选择"/>
                                         <field name="screw"/>
                                         <field name="spanner"/>
                                         <field name="cutting_blade_model"/>
@@ -356,7 +356,7 @@
                                         <field name="clamping_length"/>
                                         <field name="clamping_tolerance"/>
                                         <field name="max_load_capacity"/>
-                                        <field name="handle_ids" widget="many2many_tags" placeholder="请选择"/>
+                                        <field name="handle_id"  placeholder="请选择"/>
                                         <field name="cooling_jacket"/>
                                     </tree>
                                 </field>

sf_dlm_management/__manifest__.py

@@ -11,7 +11,7 @@
     'website': 'https://www.sf.jikimo.com',
     'depends': ['sf_sale', 'sf_dlm', 'sf_manufacturing'],
     'data': [
-        'data/stock_data.xml',
+        # 'data/stock_data.xml',
         'views/product_template_management_view.xml',
     ],
     'demo': [

sf_dlm_management/views/product_template_management_view.xml

@@ -28,13 +28,13 @@
                            options="{'no_create': True}"
                            attrs="{'invisible': ['|',('categ_type', '!=', '表面工艺'),('categ_type', '=', False)]}"/>
                     <field name="cutting_tool_material_id"
-                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('categ_id', '!=', False)]}"
+                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('create_uid', '!=', False)]}"
                            placeholder="请选择"/>
                     <field name="cutting_tool_model_id" placeholder="请选择"
-                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('categ_id', '!=', False)]}"
+                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('create_uid', '!=', False)]}"
                            domain="[('cutting_tool_material_id','=',cutting_tool_material_id)]"/>
                     <field name="specification_id" placeholder="请选择"
-                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('categ_id', '!=', False)]}"
+                           attrs="{'invisible': [('categ_type', '!=', '刀具')],'readonly': [('create_uid', '!=', False)]}"
                            domain="[('standard_library_id','=',cutting_tool_model_id)]"/>
                     <field name="fixture_material_id" attrs="{'invisible': [('categ_type', '!=', '夹具')]}"
                            placeholder="请选择"/>
@@ -42,7 +42,7 @@
                            attrs="{'invisible': [('categ_type', '!=', '夹具')]}"
                            domain="[('fixture_material_id','=',fixture_material_id)]"/>
                     <field name="name" position="attributes">
-                        <attribute name="attrs">{'readonly': [('categ_id', '!=', False)]}</attribute>
+                        <attribute name="attrs">{'readonly': [('create_uid', '!=', False)]}</attribute>
                     </field>
                 </field>
 
@@ -140,23 +140,6 @@
                                        attrs="{'invisible': [('cutting_tool_type', '!=', '刀柄')],'readonly': [('categ_type', '=', '刀具')]}"/>
                                 <field name="cutting_tool_shank_inner_diameter"
                                        attrs="{'invisible': [('cutting_tool_type', '!=', '刀柄')],'readonly': [('categ_type', '=', '刀具')]}"/>
-
-                                <!--                                <field name="materials_type_id" options="{'no_create': True}" string="刀具材质"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '整体式刀具')]}"-->
-                                <!--                                       placeholder="请选择"/>-->
-                                <!--                                <field name="tool_hardness" string="刀具硬度(hrc)"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '整体式刀具')]}"/>-->
-                                <!--                                <field name="materials_type_id" options="{'no_create': True}" string="夹头材质"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '夹头')]}"-->
-                                <!--                                       placeholder="请选择"/>-->
-                                <!--                                <field name="tool_hardness" string="夹头硬度(hrc)"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '夹头')]}"/>-->
-                                <!--                                <field name="materials_type_id" options="{'no_create': True}" string="刀柄材质"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '刀柄')]}"-->
-                                <!--                                       placeholder="请选择"/>-->
-                                <!--                                <field name="tool_hardness" string="刀柄硬度(hrc)"-->
-                                <!--                                       attrs="{'invisible': [('cutting_tool_type', '!=', '刀柄')]}"/>-->
-
                                 <field name="cutting_tool_blade_diameter" string="刃部直径(mm)" class="diameter"
                                        attrs="{'invisible': [('cutting_tool_type', '!=', '整体式刀具')],'readonly': [('categ_type', '=', '刀具')]}"/>
                                 <field name="cutting_tool_blade_length"

sf_manufacturing/models/product_template.py

@@ -6,8 +6,8 @@ import os
 from odoo import models, fields, api, _
 from odoo.exceptions import ValidationError
 from odoo.modules import get_resource_path
-from OCC.Extend.DataExchange import read_step_file
+# from OCC.Extend.DataExchange import read_step_file
-from OCC.Extend.DataExchange import write_stl_file
+# from OCC.Extend.DataExchange import write_stl_file
 
 
 class ResProductMo(models.Model):

sf_mrs_connect/models/res_config_setting.py

@@ -65,6 +65,8 @@ class ResConfigSettings(models.TransientModel):
             _logger.info("同步能力特征库完成")
             self.env['sf.cutting_tool.standard.library'].sync_all_cutting_tool_standard_library()
             _logger.info("同步刀具标准库完成")
+            self.env['sf.tool.materials.basic.parameters'].sync_all_cutting_tool_basic_parameters()
+            _logger.info("同步刀具物料基本参数完成")
         except Exception as e:
             _logger.info("捕获错误信息:%s" % e)
             raise ValidationError("数据错误导致同步失败,请联系管理员")

sf_mrs_connect/models/sync_common.py

@@ -62,6 +62,8 @@ class MrStaticResourceDataSync(models.Model):
             logging.info("能力特征库已每日同步成功")
             self.env['sf.cutting_tool.standard.library'].sync_cutting_tool_standard_library_yesterday()
             logging.info("刀具标准库已每日同步成功")
+            self.env['sf.tool.materials.basic.parameters'].sync_cutting_tool_basic_parameters_yesterday()
+            _logger.info("同步刀具物料基本参数完成")
         except Exception as e:
             logging.info("捕获错误信息:%s" % e)
             raise ValidationError("数据错误导致同步失败,请联系管理员")
@@ -903,7 +905,6 @@ class MachineToolType(models.Model):
                         "jg_image_id": jg_image_id.ids,
                         "lq_image_id": lq_image_id.ids,
 
-
                     })
                 else:
                     machine_tool_type.update({
@@ -1930,54 +1931,6 @@ class Cutting_tool_standard_library(models.Model):
                 materials_model = self.env['sf.materials.model'].search(
                     [("materials_no", '=', item['material_model_code'])])
                 brand = self.env['sf.machine.brand'].search([("code", '=', item['brand_code'])])
-                integral_tool_basic_param_list = []
-                for integral_tool_item in item['integral_tool_basic_parameter']:
-                    integral_tool_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_integral_tool_basic_param(
-                            integral_tool_item))
-                blade_basic_param_list = []
-                for blade_item in item['blade_basic_parameter']:
-                    blade_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_blade_basic_param(blade_item))
-                cutter_arbor_basic_param_list = []
-                for cutter_arbor_item in item['cutter_arbor_basic_parameter']:
-                    cutter_arbor_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_cutter_arbor_basic_param(
-                            cutter_arbor_item))
-                cutter_head_basic_param_list = []
-                for cutter_head_item in item['cutter_head_basic_parameter']:
-                    cutter_head_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_cutter_head_basic_param(cutter_head_item))
-                knife_handle_basic_param_list = []
-                for knife_handle_item in item['knife_handle_basic_parameter']:
-                    knife_handle_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_knife_handle_basic_param(
-                            knife_handle_item))
-                chuck_basic_param_list = []
-                for chuck_item in item['chuck_basic_parameter']:
-                    chuck_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_chuck_basic_param(chuck_item))
-                cutting_speed_list = []
-                for cutting_speed_item in item['cutting_speed']:
-                    cutting_speed_list.append(
-                        self.env['sf.cutting.speed']._json_cutting_speed(cutting_speed_item))
-                feed_per_tooth_list = []
-                for feed_per_tooth_item in item['feed_per_tooth']:
-                    feed_per_tooth_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth(feed_per_tooth_item))
-                feed_per_tooth_2_list = []
-                for feed_per_tooth_2_item in item['feed_per_tooth_2']:
-                    feed_per_tooth_2_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth(feed_per_tooth_2_item))
-                feed_per_tooth_3_list = []
-                for feed_per_tooth_3_item in item['feed_per_tooth_3']:
-                    feed_per_tooth_3_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth(feed_per_tooth_3_item))
-                feed_per_tooth_4_list = []
-                for feed_per_tooth_4_item in item['feed_per_tooth_4']:
-                    feed_per_tooth_4_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth(feed_per_tooth_4_item))
-
                 if not cutting_tool_standard_library:
                     self.create({
                         "code": item['code'].replace("JKM", result['factory_short_name']),
@@ -2014,17 +1967,6 @@ class Cutting_tool_standard_library(models.Model):
                             'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
                         "compaction_way_id": self.env['maintenance.equipment.image'].search(
                             [('name', '=', item['compaction_way'])]).id,
-                        "integral_tool_basic_parameters_ids": integral_tool_basic_param_list,
-                        "blade_basic_parameters_ids": blade_basic_param_list,
-                        "cutter_bar_basic_parameters_ids": cutter_arbor_basic_param_list,
-                        "cutter_head_basic_parameters_ids": cutter_head_basic_param_list,
-                        "knife_handle_basic_parameters_ids": knife_handle_basic_param_list,
-                        "chuck_basic_parameters_ids": chuck_basic_param_list,
-                        "cutting_speed_ids": cutting_speed_list,
-                        "feed_per_tooth_ids": feed_per_tooth_list,
-                        "feed_per_tooth_ids_2": feed_per_tooth_2_list,
-                        "feed_per_tooth_ids_3": feed_per_tooth_3_list,
-                        "feed_per_tooth_ids_4": feed_per_tooth_4_list,
                         "is_cloud": True,
                         "active": item['active'],
                     })
@@ -2063,17 +2005,6 @@ class Cutting_tool_standard_library(models.Model):
                              'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
                          "compaction_way_id": self.env['maintenance.equipment.image'].search(
                              [('name', '=', item['compaction_way'])]).id,
-                         "integral_tool_basic_parameters_ids": integral_tool_basic_param_list,
-                         "blade_basic_parameters_ids": blade_basic_param_list,
-                         "cutter_bar_basic_parameters_ids": cutter_arbor_basic_param_list,
-                         "cutter_head_basic_parameters_ids": cutter_head_basic_param_list,
-                         "knife_handle_basic_parameters_ids": knife_handle_basic_param_list,
-                         "chuck_basic_parameters_ids": chuck_basic_param_list,
-                         "cutting_speed_ids": cutting_speed_list,
-                         "feed_per_tooth_ids": feed_per_tooth_list,
-                         "feed_per_tooth_ids_2": feed_per_tooth_2_list,
-                         "feed_per_tooth_ids_3": feed_per_tooth_3_list,
-                         "feed_per_tooth_ids_4": feed_per_tooth_4_list,
                          "active": item['active'],
                          })
         else:
@@ -2098,53 +2029,6 @@ class Cutting_tool_standard_library(models.Model):
                 materials_model = self.env['sf.materials.model'].search(
                     [("materials_no", '=', item['material_model_code'])])
                 brand = self.env['sf.machine.brand'].search([("code", '=', item['brand_code'])])
-                integral_tool_basic_param_list = []
-                for integral_tool_item in item['integral_tool_basic_parameter']:
-                    integral_tool_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_integral_tool_basic_param(
-                            integral_tool_item))
-                blade_basic_param_list = []
-                for blade_item in item['blade_basic_parameter']:
-                    blade_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_blade_basic_param(blade_item))
-                cutter_arbor_basic_param_list = []
-                for cutter_arbor_item in item['cutter_arbor_basic_parameter']:
-                    cutter_arbor_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_cutter_arbor_basic_param(
-                            cutter_arbor_item))
-                cutter_head_basic_param_list = []
-                for cutter_head_item in item['cutter_head_basic_parameter']:
-                    cutter_head_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_cutter_head_basic_param(cutter_head_item))
-                knife_handle_basic_param_list = []
-                for knife_handle_item in item['knife_handle_basic_parameter']:
-                    knife_handle_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_knife_handle_basic_param(
-                            knife_handle_item))
-                chuck_basic_param_list = []
-                for chuck_item in item['chuck_basic_parameter']:
-                    chuck_basic_param_list.append(
-                        self.env['sf.tool.materials.basic.parameters']._json_chuck_basic_param(chuck_item))
-                cutting_speed_list = []
-                for cutting_speed_item in item['cutting_speed']:
-                    cutting_speed_list.append(
-                        self.env['sf.cutting.speed']._json_cutting_speed(cutting_speed_item))
-                feed_per_tooth_list = []
-                for feed_per_tooth_item in item['feed_per_tooth']:
-                    feed_per_tooth_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth(feed_per_tooth_item))
-                feed_per_tooth_2_list = []
-                for feed_per_tooth_2_item in item['feed_per_tooth_2']:
-                    feed_per_tooth_2_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth_2(feed_per_tooth_2_item))
-                feed_per_tooth_3_list = []
-                for feed_per_tooth_3_item in item['feed_per_tooth_3']:
-                    feed_per_tooth_3_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth_3(feed_per_tooth_3_item))
-                feed_per_tooth_4_list = []
-                for feed_per_tooth_4_item in item['feed_per_tooth_4']:
-                    feed_per_tooth_4_list.append(
-                        self.env['sf.feed.per.tooth']._json_feed_per_tooth_4(feed_per_tooth_4_item))
                 if not cutting_tool_standard_library:
                     self.create({
                         "code": item['code'].replace("JKM", result['factory_short_name']),
@@ -2181,17 +2065,6 @@ class Cutting_tool_standard_library(models.Model):
                             'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
                         "compaction_way_id": self.env['maintenance.equipment.image'].search(
                             [('name', '=', item['compaction_way'])]).id,
-                        "integral_tool_basic_parameters_ids": integral_tool_basic_param_list,
-                        "blade_basic_parameters_ids": blade_basic_param_list,
-                        "cutter_bar_basic_parameters_ids": cutter_arbor_basic_param_list,
-                        "cutter_head_basic_parameters_ids": cutter_head_basic_param_list,
-                        "knife_handle_basic_parameters_ids": knife_handle_basic_param_list,
-                        "chuck_basic_parameters_ids": chuck_basic_param_list,
-                        "cutting_speed_ids": cutting_speed_list,
-                        "feed_per_tooth_ids": feed_per_tooth_list,
-                        "feed_per_tooth_ids_2": feed_per_tooth_2_list,
-                        "feed_per_tooth_ids_3": feed_per_tooth_3_list,
-                        "feed_per_tooth_ids_4": feed_per_tooth_4_list,
                         "is_cloud": True,
                         "active": item['active'],
                     })
@@ -2230,18 +2103,706 @@ class Cutting_tool_standard_library(models.Model):
                              'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
                          "compaction_way_id": self.env['maintenance.equipment.image'].search(
                              [('name', '=', item['compaction_way'])]).id,
-                         "integral_tool_basic_parameters_ids": integral_tool_basic_param_list,
-                         "blade_basic_parameters_ids": blade_basic_param_list,
-                         "cutter_bar_basic_parameters_ids": cutter_arbor_basic_param_list,
-                         "cutter_head_basic_parameters_ids": cutter_head_basic_param_list,
-                         "knife_handle_basic_parameters_ids": knife_handle_basic_param_list,
-                         "chuck_basic_parameters_ids": chuck_basic_param_list,
-                         "cutting_speed_ids": cutting_speed_list,
-                         "feed_per_tooth_ids": feed_per_tooth_list,
-                         "feed_per_tooth_ids_2": feed_per_tooth_2_list,
-                         "feed_per_tooth_ids_3": feed_per_tooth_3_list,
-                         "feed_per_tooth_ids_4": feed_per_tooth_4_list,
                          "active": item['active'],
                          })
         else:
             raise ValidationError("刀具标准库认证未通过")
+
+
+class CuttingToolBasicParameters(models.Model):
+    _inherit = 'sf.tool.materials.basic.parameters'
+    _description = '刀具基本参数'
+    url = '/api/cutting_tool_basic_parameters/list'
+
+    # 同步刀具基本参数
+    def sync_all_cutting_tool_basic_parameters(self):
+        config = self.env['res.config.settings'].get_values()
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        strUrl = config['sf_url'] + self.url
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = r.json()
+        result = json.loads(r['result'])
+        if result['status'] == 1:
+            for item in result['cutting_tool_basic_parameters_all_list']:
+                for integral_tool_item in item['basic_parameters_integral_tool']:
+                    integral_tool = self.search([('code', '=', integral_tool_item['code'])])
+                    if integral_tool:
+                        self.create({
+                            'name': integral_tool_item['name'],
+                            'code': integral_tool_item['code'],
+                            'cutting_tool_type': '整体式刀具',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', integral_tool_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'total_length': integral_tool_item['total_length'],
+                            'blade_diameter': integral_tool_item['blade_diameter'],
+                            'blade_length': integral_tool_item['blade_length'],
+                            'blade_number': integral_tool_item['blade_number'],
+                            'neck_length': integral_tool_item['neck_length'],
+                            'neck_diameter': integral_tool_item['neck_diameter'],
+                            'handle_diameter': integral_tool_item['shank_diameter'],
+                            'handle_length': integral_tool_item['shank_length'],
+                            'blade_tip_diameter': integral_tool_item['tip_diameter'],
+                            'blade_tip_working_size': integral_tool_item['tip_handling_size'],
+                            'blade_tip_taper': integral_tool_item['knife_tip_taper'],
+                            'blade_helix_angle': integral_tool_item['blade_helix_angle'],
+                            'blade_width': integral_tool_item['blade_width'],
+                            'blade_depth': integral_tool_item['blade_depth'],
+                            'pitch': integral_tool_item['pitch'],
+                            'cutting_depth': integral_tool_item['cutting_depth_max'],
+                            'active': integral_tool_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'cutting_tool_type': integral_tool_item['cutting_tool_type'],
+                            'total_length': integral_tool_item['total_length'],
+                            'blade_diameter': integral_tool_item['blade_diameter'],
+                            'blade_length': integral_tool_item['blade_length'],
+                            'blade_number': integral_tool_item['blade_number'],
+                            'neck_length': integral_tool_item['neck_length'],
+                            'neck_diameter': integral_tool_item['neck_diameter'],
+                            'handle_diameter': integral_tool_item['shank_diameter'],
+                            'handle_length': integral_tool_item['shank_length'],
+                            'blade_tip_diameter': integral_tool_item['tip_diameter'],
+                            'blade_tip_working_size': integral_tool_item['tip_handling_size'],
+                            'blade_tip_taper': integral_tool_item['knife_tip_taper'],
+                            'blade_helix_angle': integral_tool_item['blade_helix_angle'],
+                            'blade_width': integral_tool_item['blade_width'],
+                            'blade_depth': integral_tool_item['blade_depth'],
+                            'pitch': integral_tool_item['pitch'],
+                            'cutting_depth': integral_tool_item['cutting_depth_max'],
+                            'active': integral_tool_item['active'],
+                        })
+                for blade_item in item['basic_parameters_blade']:
+                    blade = self.search([('code', '=', blade_item['code'])])
+                    if blade:
+                        self.create({
+                            'name': blade_item['name'],
+                            'code': blade_item['code'],
+                            'cutting_tool_type': '刀片',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', blade_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'length': blade_item['length'],
+                            'thickness': blade_item['thickness'],
+                            'width': blade_item['width'],
+                            'cutting_blade_length': blade_item['cutting_blade_length'],
+                            'relief_angle': blade_item['relief_angle'],
+                            'blade_tip_circular_arc_radius': blade_item['radius_tip_re'],
+                            'inscribed_circle_diameter': blade_item['diameter_inner_circle'],
+                            'install_aperture_diameter': blade_item['diameter_mounting_hole'],
+                            'pitch': blade_item['pitch'],
+                            'chip_breaker_groove': blade_item['is_chip_breaker'],
+                            'blade_teeth_model': '无' if not blade_item['blade_profile'] else blade_item[
+                                'blade_profile'],
+                            'blade_blade_number': blade_item['blade_number'],
+                            'cutting_depth': blade_item['cutting_depth_max'],
+                            'blade_width': blade_item['blade_width'],
+                            'main_included_angle': blade_item['edge_angle'],
+                            'top_angle': blade_item['top_angle'],
+                            'blade_tip_dip_angle': blade_item['blade_tip_dip_angle'],
+                            'side_cutting_edge_angle': blade_item['side_cutting_edge_angle'],
+                            'thread_model': '无' if not blade_item['thread_type'] else blade_item['thread_type'],
+                            'thread_num': blade_item['thread_num'],
+                            'blade_tip_height_tolerance': blade_item['tip_height_tolerance'],
+                            'inscribed_circle_tolerance': blade_item['internal_circle_tolerance'],
+                            'thickness_tolerance': blade_item['thickness_tolerance'],
+                            'active': blade_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'length': blade_item['length'],
+                            'thickness': blade_item['thickness'],
+                            'width': blade_item['width'],
+                            'cutting_blade_length': blade_item['cutting_blade_length'],
+                            'relief_angle': blade_item['relief_angle'],
+                            'blade_tip_circular_arc_radius': blade_item['radius_tip_re'],
+                            'inscribed_circle_diameter': blade_item['diameter_inner_circle'],
+                            'install_aperture_diameter': blade_item['diameter_mounting_hole'],
+                            'pitch': blade_item['pitch'],
+                            'chip_breaker_groove': blade_item['is_chip_breaker'],
+                            'blade_teeth_model': '无' if not blade_item['blade_profile'] else blade_item[
+                                'blade_profile'],
+                            'blade_blade_number': blade_item['blade_number'],
+                            'cutting_depth': blade_item['cutting_depth_max'],
+                            'blade_width': blade_item['blade_width'],
+                            'main_included_angle': blade_item['edge_angle'],
+                            'top_angle': blade_item['top_angle'],
+                            'blade_tip_dip_angle': blade_item['blade_tip_dip_angle'],
+                            'side_cutting_edge_angle': blade_item['side_cutting_edge_angle'],
+                            'thread_model': '无' if not blade_item['thread_type'] else blade_item['thread_type'],
+                            'thread_num': blade_item['thread_num'],
+                            'blade_tip_height_tolerance': blade_item['tip_height_tolerance'],
+                            'inscribed_circle_tolerance': blade_item['internal_circle_tolerance'],
+                            'thickness_tolerance': blade_item['thickness_tolerance'],
+                            'active': blade_item['active'],
+                        })
+                for chuck_item in item['basic_parameters_chuck']:
+                    chuck = self.search([('code', '=', chuck_item['code'])])
+                    if chuck:
+                        self.create({
+                            'name': chuck_item['name'],
+                            'code': chuck_item['code'],
+                            'cutting_tool_type': '夹头',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'er_size_model': chuck_item['size_model'],
+                            'min_clamping_diameter': chuck_item['clamping_diameter_min'],
+                            'max_clamping_diameter': chuck_item['clamping_diameter_max'],
+                            'outer_diameter': chuck_item['outer_diameter'],
+                            'inner_diameter': chuck_item['inner_diameter'],
+                            'run_out_accuracy': chuck_item['run_out_accuracy'],
+                            'total_length': chuck_item['total_length'],
+                            'taper': chuck_item['taper'],
+                            'top_diameter': chuck_item['top_diameter'],
+                            'weight': chuck_item['weight'],
+                            'max_load_capacity': chuck_item['load_capacity_max'],
+                            'handle_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['fit_knife_handle_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'cooling_jacket': chuck_item['cooling_sleeve_model'],
+                            'active': chuck_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'er_size_model': chuck_item['size_model'],
+                            'min_clamping_diameter': chuck_item['clamping_diameter_min'],
+                            'max_clamping_diameter': chuck_item['clamping_diameter_max'],
+                            'outer_diameter': chuck_item['outer_diameter'],
+                            'inner_diameter': chuck_item['inner_diameter'],
+                            'run_out_accuracy': chuck_item['run_out_accuracy'],
+                            'total_length': chuck_item['total_length'],
+                            'taper': chuck_item['taper'],
+                            'top_diameter': chuck_item['top_diameter'],
+                            'weight': chuck_item['weight'],
+                            'max_load_capacity': chuck_item['load_capacity_max'],
+                            'handle_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['fit_knife_handle_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'cooling_jacket': chuck_item['cooling_sleeve_model'],
+                            'active': chuck_item['active'],
+                        })
+                for cutter_arbor_item in item['basic_parameters_cutter_arbor']:
+                    cutter_arbor = self.search([('code', '=', cutter_arbor_item['code'])])
+                    if cutter_arbor:
+                        self.create({
+                            'name': cutter_arbor_item['name'],
+                            'code': cutter_arbor_item['code'],
+                            'cutting_tool_type': '刀杆',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'height': cutter_arbor_item['height'],
+                            'width': cutter_arbor_item['width'],
+                            'total_length': cutter_arbor_item['total_length'],
+                            'knife_head_height': cutter_arbor_item['head_length'],
+                            'knife_head_width': cutter_arbor_item['head_width'],
+                            'knife_head_length': cutter_arbor_item['head_length'],
+                            'cutter_arbor_diameter': cutter_arbor_item['arbor_diameter'],
+                            'main_included_angle': cutter_arbor_item['edge_angle'],
+                            'relief_angle': cutter_arbor_item['relief_angle'],
+                            'cutting_depth': cutter_arbor_item['cutting_depth_max'],
+                            'min_machining_aperture': cutter_arbor_item['machining_aperture_min'],
+                            'install_blade_tip_num': cutter_arbor_item['number_blade_installed'],
+                            'cutting_blade_model': cutter_arbor_item['cutting_blade_model'],
+                            'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_arbor_item['locator_slot_code'],
+                            'installing_structure': cutter_arbor_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'tool_shim': cutter_arbor_item['fit_knife_pad_model'],
+                            'cotter_pin': cutter_arbor_item['fit_pin_model'],
+                            'pressing_plate': cutter_arbor_item['fit_plate_model'],
+                            'screw': cutter_arbor_item['fit_screw_model'],
+                            'spanner': cutter_arbor_item['fit_wrench_model'],
+                            'active': cutter_arbor_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': cutter_arbor_item['name'],
+                            'height': cutter_arbor_item['height'],
+                            'width': cutter_arbor_item['width'],
+                            'total_length': cutter_arbor_item['total_length'],
+                            'knife_head_height': cutter_arbor_item['head_length'],
+                            'knife_head_width': cutter_arbor_item['head_width'],
+                            'knife_head_length': cutter_arbor_item['head_length'],
+                            'cutter_arbor_diameter': cutter_arbor_item['arbor_diameter'],
+                            'main_included_angle': cutter_arbor_item['edge_angle'],
+                            'relief_angle': cutter_arbor_item['relief_angle'],
+                            'cutting_depth': cutter_arbor_item['cutting_depth_max'],
+                            'min_machining_aperture': cutter_arbor_item['machining_aperture_min'],
+                            'install_blade_tip_num': cutter_arbor_item['number_blade_installed'],
+                            'cutting_blade_model': cutter_arbor_item['cutting_blade_model'],
+                            'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_arbor_item['locator_slot_code'],
+                            'installing_structure': cutter_arbor_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'tool_shim': cutter_arbor_item['fit_knife_pad_model'],
+                            'cotter_pin': cutter_arbor_item['fit_pin_model'],
+                            'pressing_plate': cutter_arbor_item['fit_plate_model'],
+                            'screw': cutter_arbor_item['fit_screw_model'],
+                            'spanner': cutter_arbor_item['fit_wrench_model'],
+                            'active': cutter_arbor_item['active'],
+                        })
+                for cutter_head_item in item['basic_parameters_cutter_head']:
+                    cutter_head = self.search([('code', '=', cutter_head_item['code'])])
+                    if cutter_head:
+                        self.create({
+                            'name': cutter_head_item['name'],
+                            'code': cutter_head_item['code'],
+                            'cutting_tool_type': '刀盘',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'install_blade_tip_num': cutter_head_item['number_blade_installed'],
+                            'blade_diameter': cutter_head_item['blade_diameter'],
+                            'cutter_head_diameter': cutter_head_item['cutter_diameter'],
+                            'interface_diameter': cutter_head_item['interface_diameter'],
+                            'total_length': cutter_head_item['total_length'],
+                            'blade_length': cutter_head_item['blade_length'],
+                            'cutting_depth': cutter_head_item['cutting_depth_max'],
+                            'main_included_angle': cutter_head_item['edge_angle'],
+                            'installing_structure': cutter_head_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'screw': cutter_head_item['fit_screw_model'],
+                            'spanner': cutter_head_item['fit_wrench_model'],
+                            'is_cooling_hole': cutter_head_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_head_item['locator_slot_code'],
+                            'active': cutter_head_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': cutter_arbor_item['name'],
+                            'install_blade_tip_num': cutter_head_item['number_blade_installed'],
+                            'blade_diameter': cutter_head_item['blade_diameter'],
+                            'cutter_head_diameter': cutter_head_item['cutter_diameter'],
+                            'interface_diameter': cutter_head_item['interface_diameter'],
+                            'total_length': cutter_head_item['total_length'],
+                            'blade_length': cutter_head_item['blade_length'],
+                            'cutting_depth': cutter_head_item['cutting_depth_max'],
+                            'main_included_angle': cutter_head_item['edge_angle'],
+                            'installing_structure': cutter_head_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'screw': cutter_head_item['fit_screw_model'],
+                            'spanner': cutter_head_item['fit_wrench_model'],
+                            'is_cooling_hole': cutter_head_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_head_item['locator_slot_code'],
+                            'active': cutter_head_item['active'],
+                        })
+
+                for knife_handle_item in item['basic_parameters_knife_handle']:
+                    knife_handle = self.search([('code', '=', knife_handle_item['code'])])
+                    if knife_handle:
+                        self.create({
+                            'name': knife_handle_item['name'],
+                            'code': knife_handle_item['code'],
+                            'cutting_tool_type': '刀柄',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'total_length': knife_handle_item['total_length'],
+                            'flange_shank_length': knife_handle_item['flange_length'],
+                            'flange_diameter': knife_handle_item['flange_diameter'],
+                            'shank_length': knife_handle_item['shank_length'],
+                            'shank_diameter': knife_handle_item['shank_diameter'],
+                            'min_clamping_diameter': knife_handle_item['clamping_diameter_min'],
+                            'max_clamping_diameter': knife_handle_item['clamping_diameter_max'],
+                            'clamping_mode': knife_handle_item['clamping_way'],
+                            'tool_changing_time': knife_handle_item['tool_changing_time'],
+                            'max_rotate_speed': knife_handle_item['rotate_speed_max'],
+                            'diameter_slip_accuracy': knife_handle_item['diameter_slip_accuracy'],
+                            'cooling_model': knife_handle_item['cooling_model'],
+                            'is_quick_cutting': knife_handle_item['is_quick_cutting'],
+                            'is_safe_lock': knife_handle_item['is_safe_lock'],
+                            'screw': knife_handle_item['fit_wrench_model'],
+                            'nut': knife_handle_item['fit_nut_model'],
+                            'dynamic_balance_class': knife_handle_item['dynamic_balance_class'],
+                            'chuck_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['fit_chuck_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'active': knife_handle_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': knife_handle_item['name'],
+                            'total_length': knife_handle_item['total_length'],
+                            'flange_shank_length': knife_handle_item['flange_length'],
+                            'flange_diameter': knife_handle_item['flange_diameter'],
+                            'shank_length': knife_handle_item['shank_length'],
+                            'shank_diameter': knife_handle_item['shank_diameter'],
+                            'min_clamping_diameter': knife_handle_item['clamping_diameter_min'],
+                            'max_clamping_diameter': knife_handle_item['clamping_diameter_max'],
+                            'clamping_mode': knife_handle_item['clamping_way'],
+                            'tool_changing_time': knife_handle_item['tool_changing_time'],
+                            'max_rotate_speed': knife_handle_item['rotate_speed_max'],
+                            'diameter_slip_accuracy': knife_handle_item['diameter_slip_accuracy'],
+                            'cooling_model': knife_handle_item['cooling_model'],
+                            'is_quick_cutting': knife_handle_item['is_quick_cutting'],
+                            'is_safe_lock': knife_handle_item['is_safe_lock'],
+                            'screw': knife_handle_item['fit_wrench_model'],
+                            'nut': knife_handle_item['fit_nut_model'],
+                            'dynamic_balance_class': knife_handle_item['dynamic_balance_class'],
+                            'chuck_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['fit_chuck_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'active': knife_handle_item['active'],
+                        })
+        else:
+            raise ValidationError("刀具物料基本参数认证未通过")
+
+    def sync_cutting_tool_basic_parameters_yesterday(self):
+        config = self.env['res.config.settings'].get_values()
+        headers = Common.get_headers(self, config['token'], config['sf_secret_key'])
+        strUrl = config['sf_url'] + self.url
+        r = requests.post(strUrl, json={}, data=None, headers=headers)
+        r = r.json()
+        result = json.loads(r['result'])
+        if result['status'] == 1:
+            for item in result['cutting_tool_basic_parameters_yesterday_list']:
+                for integral_tool_item in item['basic_parameters_integral_tool']:
+                    integral_tool = self.search([('code', '=', integral_tool_item['code'])])
+                    if integral_tool:
+                        self.create({
+                            'name': integral_tool_item['name'],
+                            'code': integral_tool_item['code'],
+                            'cutting_tool_type': '整体式刀具',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', integral_tool_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'total_length': integral_tool_item['total_length'],
+                            'blade_diameter': integral_tool_item['blade_diameter'],
+                            'blade_length': integral_tool_item['blade_length'],
+                            'blade_number': integral_tool_item['blade_number'],
+                            'neck_length': integral_tool_item['neck_length'],
+                            'neck_diameter': integral_tool_item['neck_diameter'],
+                            'handle_diameter': integral_tool_item['shank_diameter'],
+                            'handle_length': integral_tool_item['shank_length'],
+                            'blade_tip_diameter': integral_tool_item['tip_diameter'],
+                            'blade_tip_working_size': integral_tool_item['tip_handling_size'],
+                            'blade_tip_taper': integral_tool_item['knife_tip_taper'],
+                            'blade_helix_angle': integral_tool_item['blade_helix_angle'],
+                            'blade_width': integral_tool_item['blade_width'],
+                            'blade_depth': integral_tool_item['blade_depth'],
+                            'pitch': integral_tool_item['pitch'],
+                            'cutting_depth': integral_tool_item['cutting_depth_max'],
+                            'active': integral_tool_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'cutting_tool_type': integral_tool_item['cutting_tool_type'],
+                            'total_length': integral_tool_item['total_length'],
+                            'blade_diameter': integral_tool_item['blade_diameter'],
+                            'blade_length': integral_tool_item['blade_length'],
+                            'blade_number': integral_tool_item['blade_number'],
+                            'neck_length': integral_tool_item['neck_length'],
+                            'neck_diameter': integral_tool_item['neck_diameter'],
+                            'handle_diameter': integral_tool_item['shank_diameter'],
+                            'handle_length': integral_tool_item['shank_length'],
+                            'blade_tip_diameter': integral_tool_item['tip_diameter'],
+                            'blade_tip_working_size': integral_tool_item['tip_handling_size'],
+                            'blade_tip_taper': integral_tool_item['knife_tip_taper'],
+                            'blade_helix_angle': integral_tool_item['blade_helix_angle'],
+                            'blade_width': integral_tool_item['blade_width'],
+                            'blade_depth': integral_tool_item['blade_depth'],
+                            'pitch': integral_tool_item['pitch'],
+                            'cutting_depth': integral_tool_item['cutting_depth_max'],
+                            'active': integral_tool_item['active'],
+                        })
+                for blade_item in item['basic_parameters_blade']:
+                    blade = self.search([('code', '=', blade_item['code'])])
+                    if blade:
+                        self.create({
+                            'name': blade_item['name'],
+                            'code': blade_item['code'],
+                            'cutting_tool_type': '刀片',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', blade_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'length': blade_item['length'],
+                            'thickness': blade_item['thickness'],
+                            'width': blade_item['width'],
+                            'cutting_blade_length': blade_item['cutting_blade_length'],
+                            'relief_angle': blade_item['relief_angle'],
+                            'blade_tip_circular_arc_radius': blade_item['radius_tip_re'],
+                            'inscribed_circle_diameter': blade_item['diameter_inner_circle'],
+                            'install_aperture_diameter': blade_item['diameter_mounting_hole'],
+                            'pitch': blade_item['pitch'],
+                            'chip_breaker_groove': blade_item['is_chip_breaker'],
+                            'blade_teeth_model': '无' if not blade_item['blade_profile'] else blade_item[
+                                'blade_profile'],
+                            'blade_blade_number': blade_item['blade_number'],
+                            'cutting_depth': blade_item['cutting_depth_max'],
+                            'blade_width': blade_item['blade_width'],
+                            'main_included_angle': blade_item['edge_angle'],
+                            'top_angle': blade_item['top_angle'],
+                            'blade_tip_dip_angle': blade_item['blade_tip_dip_angle'],
+                            'side_cutting_edge_angle': blade_item['side_cutting_edge_angle'],
+                            'thread_model': '无' if not blade_item['thread_type'] else blade_item['thread_type'],
+                            'thread_num': blade_item['thread_num'],
+                            'blade_tip_height_tolerance': blade_item['tip_height_tolerance'],
+                            'inscribed_circle_tolerance': blade_item['internal_circle_tolerance'],
+                            'thickness_tolerance': blade_item['thickness_tolerance'],
+                            'active': blade_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'length': blade_item['length'],
+                            'thickness': blade_item['thickness'],
+                            'width': blade_item['width'],
+                            'cutting_blade_length': blade_item['cutting_blade_length'],
+                            'relief_angle': blade_item['relief_angle'],
+                            'blade_tip_circular_arc_radius': blade_item['radius_tip_re'],
+                            'inscribed_circle_diameter': blade_item['diameter_inner_circle'],
+                            'install_aperture_diameter': blade_item['diameter_mounting_hole'],
+                            'pitch': blade_item['pitch'],
+                            'chip_breaker_groove': blade_item['is_chip_breaker'],
+                            'blade_teeth_model': '无' if not blade_item['blade_profile'] else blade_item[
+                                'blade_profile'],
+                            'blade_blade_number': blade_item['blade_number'],
+                            'cutting_depth': blade_item['cutting_depth_max'],
+                            'blade_width': blade_item['blade_width'],
+                            'main_included_angle': blade_item['edge_angle'],
+                            'top_angle': blade_item['top_angle'],
+                            'blade_tip_dip_angle': blade_item['blade_tip_dip_angle'],
+                            'side_cutting_edge_angle': blade_item['side_cutting_edge_angle'],
+                            'thread_model': '无' if not blade_item['thread_type'] else blade_item['thread_type'],
+                            'thread_num': blade_item['thread_num'],
+                            'blade_tip_height_tolerance': blade_item['tip_height_tolerance'],
+                            'inscribed_circle_tolerance': blade_item['internal_circle_tolerance'],
+                            'thickness_tolerance': blade_item['thickness_tolerance'],
+                            'active': blade_item['active'],
+                        })
+                for chuck_item in item['basic_parameters_chuck']:
+                    chuck = self.search([('code', '=', chuck_item['code'])])
+                    if chuck:
+                        self.create({
+                            'name': chuck_item['name'],
+                            'code': chuck_item['code'],
+                            'cutting_tool_type': '夹头',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'er_size_model': chuck_item['size_model'],
+                            'min_clamping_diameter': chuck_item['clamping_diameter_min'],
+                            'max_clamping_diameter': chuck_item['clamping_diameter_max'],
+                            'outer_diameter': chuck_item['outer_diameter'],
+                            'inner_diameter': chuck_item['inner_diameter'],
+                            'run_out_accuracy': chuck_item['run_out_accuracy'],
+                            'total_length': chuck_item['total_length'],
+                            'taper': chuck_item['taper'],
+                            'top_diameter': chuck_item['top_diameter'],
+                            'weight': chuck_item['weight'],
+                            'max_load_capacity': chuck_item['load_capacity_max'],
+                            'handle_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['fit_knife_handle_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'cooling_jacket': chuck_item['cooling_sleeve_model'],
+                            'active': chuck_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': integral_tool_item['name'],
+                            'er_size_model': chuck_item['size_model'],
+                            'min_clamping_diameter': chuck_item['clamping_diameter_min'],
+                            'max_clamping_diameter': chuck_item['clamping_diameter_max'],
+                            'outer_diameter': chuck_item['outer_diameter'],
+                            'inner_diameter': chuck_item['inner_diameter'],
+                            'run_out_accuracy': chuck_item['run_out_accuracy'],
+                            'total_length': chuck_item['total_length'],
+                            'taper': chuck_item['taper'],
+                            'top_diameter': chuck_item['top_diameter'],
+                            'weight': chuck_item['weight'],
+                            'max_load_capacity': chuck_item['load_capacity_max'],
+                            'handle_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', chuck_item['fit_knife_handle_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'cooling_jacket': chuck_item['cooling_sleeve_model'],
+                            'active': chuck_item['active'],
+                        })
+                for cutter_arbor_item in item['basic_parameters_cutter_arbor']:
+                    cutter_arbor = self.search([('code', '=', cutter_arbor_item['code'])])
+                    if cutter_arbor:
+                        self.create({
+                            'name': cutter_arbor_item['name'],
+                            'code': cutter_arbor_item['code'],
+                            'cutting_tool_type': '刀杆',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'height': cutter_arbor_item['height'],
+                            'width': cutter_arbor_item['width'],
+                            'total_length': cutter_arbor_item['total_length'],
+                            'knife_head_height': cutter_arbor_item['head_length'],
+                            'knife_head_width': cutter_arbor_item['head_width'],
+                            'knife_head_length': cutter_arbor_item['head_length'],
+                            'cutter_arbor_diameter': cutter_arbor_item['arbor_diameter'],
+                            'main_included_angle': cutter_arbor_item['edge_angle'],
+                            'relief_angle': cutter_arbor_item['relief_angle'],
+                            'cutting_depth': cutter_arbor_item['cutting_depth_max'],
+                            'min_machining_aperture': cutter_arbor_item['machining_aperture_min'],
+                            'install_blade_tip_num': cutter_arbor_item['number_blade_installed'],
+                            'cutting_blade_model': cutter_arbor_item['cutting_blade_model'],
+                            'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_arbor_item['locator_slot_code'],
+                            'installing_structure': cutter_arbor_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'tool_shim': cutter_arbor_item['fit_knife_pad_model'],
+                            'cotter_pin': cutter_arbor_item['fit_pin_model'],
+                            'pressing_plate': cutter_arbor_item['fit_plate_model'],
+                            'screw': cutter_arbor_item['fit_screw_model'],
+                            'spanner': cutter_arbor_item['fit_wrench_model'],
+                            'active': cutter_arbor_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': cutter_arbor_item['name'],
+                            'height': cutter_arbor_item['height'],
+                            'width': cutter_arbor_item['width'],
+                            'total_length': cutter_arbor_item['total_length'],
+                            'knife_head_height': cutter_arbor_item['head_length'],
+                            'knife_head_width': cutter_arbor_item['head_width'],
+                            'knife_head_length': cutter_arbor_item['head_length'],
+                            'cutter_arbor_diameter': cutter_arbor_item['arbor_diameter'],
+                            'main_included_angle': cutter_arbor_item['edge_angle'],
+                            'relief_angle': cutter_arbor_item['relief_angle'],
+                            'cutting_depth': cutter_arbor_item['cutting_depth_max'],
+                            'min_machining_aperture': cutter_arbor_item['machining_aperture_min'],
+                            'install_blade_tip_num': cutter_arbor_item['number_blade_installed'],
+                            'cutting_blade_model': cutter_arbor_item['cutting_blade_model'],
+                            'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_arbor_item['locator_slot_code'],
+                            'installing_structure': cutter_arbor_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_arbor_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'tool_shim': cutter_arbor_item['fit_knife_pad_model'],
+                            'cotter_pin': cutter_arbor_item['fit_pin_model'],
+                            'pressing_plate': cutter_arbor_item['fit_plate_model'],
+                            'screw': cutter_arbor_item['fit_screw_model'],
+                            'spanner': cutter_arbor_item['fit_wrench_model'],
+                            'active': cutter_arbor_item['active'],
+                        })
+                for cutter_head_item in item['basic_parameters_cutter_head']:
+                    cutter_head = self.search([('code', '=', cutter_head_item['code'])])
+                    if cutter_head:
+                        self.create({
+                            'name': cutter_head_item['name'],
+                            'code': cutter_head_item['code'],
+                            'cutting_tool_type': '刀盘',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'install_blade_tip_num': cutter_head_item['number_blade_installed'],
+                            'blade_diameter': cutter_head_item['blade_diameter'],
+                            'cutter_head_diameter': cutter_head_item['cutter_diameter'],
+                            'interface_diameter': cutter_head_item['interface_diameter'],
+                            'total_length': cutter_head_item['total_length'],
+                            'blade_length': cutter_head_item['blade_length'],
+                            'cutting_depth': cutter_head_item['cutting_depth_max'],
+                            'main_included_angle': cutter_head_item['edge_angle'],
+                            'installing_structure': cutter_head_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'screw': cutter_head_item['fit_screw_model'],
+                            'spanner': cutter_head_item['fit_wrench_model'],
+                            'is_cooling_hole': cutter_head_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_head_item['locator_slot_code'],
+                            'active': cutter_head_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': cutter_arbor_item['name'],
+                            'install_blade_tip_num': cutter_head_item['number_blade_installed'],
+                            'blade_diameter': cutter_head_item['blade_diameter'],
+                            'cutter_head_diameter': cutter_head_item['cutter_diameter'],
+                            'interface_diameter': cutter_head_item['interface_diameter'],
+                            'total_length': cutter_head_item['total_length'],
+                            'blade_length': cutter_head_item['blade_length'],
+                            'cutting_depth': cutter_head_item['cutting_depth_max'],
+                            'main_included_angle': cutter_head_item['edge_angle'],
+                            'installing_structure': cutter_head_item['installing_structure'],
+                            'blade_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', cutter_head_item['fit_blade_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'screw': cutter_head_item['fit_screw_model'],
+                            'spanner': cutter_head_item['fit_wrench_model'],
+                            'is_cooling_hole': cutter_head_item['is_cooling_hole'],
+                            'locating_slot_code': cutter_head_item['locator_slot_code'],
+                            'active': cutter_head_item['active'],
+                        })
+
+                for knife_handle_item in item['basic_parameters_knife_handle']:
+                    knife_handle = self.search([('code', '=', knife_handle_item['code'])])
+                    if knife_handle:
+                        self.create({
+                            'name': knife_handle_item['name'],
+                            'code': knife_handle_item['code'],
+                            'cutting_tool_type': '刀柄',
+                            'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['standard_library_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'total_length': knife_handle_item['total_length'],
+                            'flange_shank_length': knife_handle_item['flange_length'],
+                            'flange_diameter': knife_handle_item['flange_diameter'],
+                            'shank_length': knife_handle_item['shank_length'],
+                            'shank_diameter': knife_handle_item['shank_diameter'],
+                            'min_clamping_diameter': knife_handle_item['clamping_diameter_min'],
+                            'max_clamping_diameter': knife_handle_item['clamping_diameter_max'],
+                            'clamping_mode': knife_handle_item['clamping_way'],
+                            'tool_changing_time': knife_handle_item['tool_changing_time'],
+                            'max_rotate_speed': knife_handle_item['rotate_speed_max'],
+                            'diameter_slip_accuracy': knife_handle_item['diameter_slip_accuracy'],
+                            'cooling_model': knife_handle_item['cooling_model'],
+                            'is_quick_cutting': knife_handle_item['is_quick_cutting'],
+                            'is_safe_lock': knife_handle_item['is_safe_lock'],
+                            'screw': knife_handle_item['fit_wrench_model'],
+                            'nut': knife_handle_item['fit_nut_model'],
+                            'dynamic_balance_class': knife_handle_item['dynamic_balance_class'],
+                            'chuck_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['fit_chuck_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'active': knife_handle_item['active'],
+                        })
+                    else:
+                        self.write({
+                            'name': knife_handle_item['name'],
+                            'total_length': knife_handle_item['total_length'],
+                            'flange_shank_length': knife_handle_item['flange_length'],
+                            'flange_diameter': knife_handle_item['flange_diameter'],
+                            'shank_length': knife_handle_item['shank_length'],
+                            'shank_diameter': knife_handle_item['shank_diameter'],
+                            'min_clamping_diameter': knife_handle_item['clamping_diameter_min'],
+                            'max_clamping_diameter': knife_handle_item['clamping_diameter_max'],
+                            'clamping_mode': knife_handle_item['clamping_way'],
+                            'tool_changing_time': knife_handle_item['tool_changing_time'],
+                            'max_rotate_speed': knife_handle_item['rotate_speed_max'],
+                            'diameter_slip_accuracy': knife_handle_item['diameter_slip_accuracy'],
+                            'cooling_model': knife_handle_item['cooling_model'],
+                            'is_quick_cutting': knife_handle_item['is_quick_cutting'],
+                            'is_safe_lock': knife_handle_item['is_safe_lock'],
+                            'screw': knife_handle_item['fit_wrench_model'],
+                            'nut': knife_handle_item['fit_nut_model'],
+                            'dynamic_balance_class': knife_handle_item['dynamic_balance_class'],
+                            'chuck_id': self.env['sf.cutting_tool.standard.library'].search(
+                                [('code', '=', knife_handle_item['fit_chuck_model_code'].replace("JKM", result[
+                                    'factory_short_name']))]).id,
+                            'active': knife_handle_item['active'],
+                        })
+        else:
+            raise ValidationError("刀具物料基本参数认证未通过")

sf_sale/models/auto_quatotion_common.py

@@ -2,7 +2,7 @@
 import logging
 from odoo.modules import get_resource_path
 from odoo import fields, models, api
-from quatotion import readSql, feature_recognize, auto_quatotion
+# from quatotion import readSql, feature_recognize, auto_quatotion
 
 __author__ = 'jinling.yang'
 _logger = logging.getLogger(__name__)

sf_sale/models/quick_easy_order.py

@@ -5,8 +5,8 @@ import os
 import json
 from datetime import datetime
 import requests
-from OCC.Extend.DataExchange import read_step_file
+# from OCC.Extend.DataExchange import read_step_file
-from OCC.Extend.DataExchange import write_stl_file
+# from OCC.Extend.DataExchange import write_stl_file
 from odoo import models, fields, api
 from odoo.modules import get_resource_path
 from odoo.exceptions import ValidationError, UserError