jikimo/test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3baf3e60e8879d09d21f3e05df185665ff662aa3
test/sf_mrs_connect/models/sync_common.py
liaodanlong 0cb73b6d29 切割工单过滤掉回退按钮
2025-02-26 14:36:50 +08:00

3221 lines
193 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
import logging
import json
import base64
import traceback
import requests
from odoo import models
from odoo.exceptions import ValidationError
from odoo.addons.sf_base.commons.common import Common
_logger = logging.getLogger(__name__)
class MrStaticResourceDataSync(models.Model):
_name = 'sf.static.resource.datasync'
_description = '同步cloud的静态资源库'
def _cron_static_resource_yesterday_func(self):
try:
self.env['sf.machine.brand.tags'].sync_machine_brand_tags_yesterday()
logging.info("品牌类别已每日同步成功")
self.env['sf.machine.brand'].sync_machine_brand_yesterday()
logging.info("品牌已每日同步成功")
self.env['sf.machine_tool.category'].sync_machine_tool_category_yesterday()
logging.info("机床类型已每日同步成功")
self.env['sf.machine_tool.type'].sync_machine_tool_type_yesterday()
logging.info("机床型号已每日同步成功")
self.env['sf.machine.control_system'].sync_machine_control_system_yesterday()
logging.info("数控系统已每日同步成功")
self.env['sf.production.materials'].sync_production_materials_yesterday()
logging.info("材料已每日同步成功")
self.env['sf.materials.model'].sync_materials_model_yesterday()
# logging.info("材料型号已每日同步成功")
# self.env['mrs.international.standards']._cron_mrs_international_standards_func()
# logging.info("材料型号材料应用已每日同步成功")
self.env['material.apply'].sync_material_apply()
logging.info("材料型号材料应用已每日同步成功")
self.env['sf.production.process.category'].sync_production_process_category_yesterday()
logging.info("表面工艺类别已每日同步成功")
self.env['sf.production.process'].sync_production_process_yesterday()
logging.info("表面工艺已每日同步成功")
self.env['sf.production.process.parameter'].sync_production_process_parameter_yesterday()
logging.info("表面工艺可选参数已每日同步成功")
# self.env['sf.processing.technology'].sync_processing_technology_yesterday()
# logging.info("加工工艺已每日同步成功")
# self.env['sf.processing.order'].sync_processing_order_yesterday()
# logging.info("工序已同步已每日同步成功")
self.env['sf.fixture.material'].sync_fixture_material_yesterday()
logging.info("夹具物料已每日同步成功")
self.env['sf.multi_mounting.type'].sync_multi_mounting_type_yesterday()
logging.info("联装类型已每日同步成功")
self.env['sf.fixture.model'].sync_fixture_model_yesterday()
logging.info("夹具型号已每日同步成功")
self.env['sf.fixture.materials.basic.parameters'].sync_fixture_materials_basic_parameters_yesterday()
logging.info("夹具型号基本参数已每日同步成功")
self.env['sf.functional.fixture.type'].sync_functional_fixture_type_yesterday()
logging.info("功能夹具类型已每日同步成功")
self.env['sf.cutting.tool.material'].sync_cutting_tool_material_yesterday()
logging.info("刀具物料已每日同步成功")
self.env['sf.cutting.tool.type'].sync_tool_type_yesterday()
logging.info("刀具类型已每日同步成功")
self.env['sf.functional.cutting.tool.model'].sync_functional_cutting_tool_model_yesterday()
logging.info("功能刀具类型已每日同步成功")
self.env['maintenance.equipment.image'].sync_maintenance_equipment_image_yesterday()
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("同步刀具物料基本参数完成")
self.env['sf.cutting.width.depth'].sync_cutting_width_depth_yesterday()
_logger.info("同步刀具物料切削宽度和深度完成")
self.env['sf.cutting.speed'].sync_cutting_speed_yesterday()
_logger.info("同步刀具物料切削速度完成")
self.env['sf.feed.per.tooth'].sync_feed_per_tooth_yesterday()
_logger.info("同步刀具物料每齿走刀量完成")
self.env['sf.machining.accuracy'].sync_machining_accuracy_all()
_logger.info("同步加工精度完成")
self.env['sf.embryo.redundancy'].sync_embryo_redundancy_all()
_logger.info("同步坯料冗余完成")
except Exception as e:
traceback_error = traceback.format_exc()
logging.error("同步静态资源库失败:%s" % traceback_error)
raise ValidationError("数据错误导致同步失败,请联系管理员")
class sfProductionMaterials(models.Model):
_inherit = "sf.production.materials"
_description = "材料"
url = '/api/production_materials/list'
# 定时同步每日材料
def sync_production_materials_yesterday(self):
# 配置中获取token
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['production_materials_yesterday_list']:
for item in result['production_materials_all_list']:
if item:
materials = self.search(
[("materials_no", '=', item['materials_no']), ('active', 'in', [True, False])])
if not materials:
self.create({
"name": item['name'],
"materials_no": item['materials_no'],
"remark": item['remark'],
"active": item['active'],
})
else:
materials.name = item['name']
materials.remark = item['remark']
materials.active = item['active']
else:
raise ValidationError("材料认证未通过")
# 同步所有材料
def sync_all_production_materials(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['production_materials_all_list']:
if item:
materials = self.search(
[("materials_no", '=', item['materials_no']), ('active', 'in', [True, False])])
if not materials:
self.create({
"name": item['name'],
"materials_no": item['materials_no'],
"remark": item['remark'],
"active": item['active'],
})
else:
materials.name = item['name']
materials.remark = item['remark']
materials.active = item['active']
else:
raise ValidationError("材料认证未通过")
class sfMaterialModel(models.Model):
_inherit = 'sf.materials.model'
_description = '材料型号'
url = '/api/materials_model/list'
# 定时同步每日材料型号
def sync_materials_model_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['materials_model_yesterday_list']:
if item:
materials_model = self.search(
[("materials_no", '=', item['materials_no']), ('active', 'in', [True, False])])
materials = self.env['sf.production.materials'].search(
[("materials_no", '=', item['materials_id.materials_no'])])
if materials_model:
materials_model.name = item['name']
materials_model.materials_no = item['materials_no']
materials_model.remark = item['remark']
materials_model.tensile_strength = item['tensile_strength']
materials_model.hardness = item['hardness']
materials_model.materials_no = item['materials_no']
materials_model.rough_machining = item['rough_machining']
materials_model.finish_machining = item['finish_machining']
materials_model.mf_materia_post = item['mf_materia_post']
materials_model.materials_id = materials.id
materials_model.need_h = item['need_h']
materials_model.density = item['density']
materials_model.active = item['active']
else:
self.create({
"name": item['name'],
"materials_no": item['materials_no'],
"remark": item['remark'],
"tensile_strength": item['tensile_strength'],
"hardness": item['hardness'],
"rough_machining": item['rough_machining'],
"finish_machining": item['finish_machining'],
"active": item['active'],
"materials_id": materials.id,
"need_h": item['need_h'],
"mf_materia_post": item['mf_materia_post'],
"density": item['density'],
})
else:
raise ValidationError("材料型号认证未通过")
# 同步所有材料型号
def sync_all_materials_model(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['materials_model_all_list']:
if item:
materials_model = self.search(
[("materials_no", '=', item['materials_no']), ('active', 'in', [True, False])])
materials = self.env['sf.production.materials'].search(
[("materials_no", '=', item['materials_id.materials_no'])])
if not materials_model:
self.create({
"name": item['name'],
"materials_no": item['materials_no'],
"remark": item['remark'],
"active": item['active'],
"tensile_strength": item['tensile_strength'],
"hardness": item['hardness'],
"rough_machining": item['rough_machining'],
"finish_machining": item['finish_machining'],
"materials_id": self.env['sf.production.materials'].search(
[("materials_no", '=', item['materials_id.materials_no'])]).id,
"standards_id": self.env['sf.international.standards'].search(
[("name", '=', item['standards_id'])]).id,
"need_h": item['need_h'],
"alloy_code": item['alloy_code'],
"mf_materia_post": item['mf_materia_post'],
"density": item['density'],
"materials_code": item['materials_code'],
"apply": self.env['material.apply'].search(
[("name", 'in', item['apply'])]).ids
# "tag_ids": item['tag_ids']
})
else:
materials_model.name = item['name']
materials_model.remark = item['remark']
materials_model.tensile_strength = item['tensile_strength']
materials_model.hardness = item['hardness']
materials_model.materials_no = item['materials_no']
materials_model.rough_machining = item['rough_machining']
materials_model.finish_machining = item['finish_machining']
materials_model.mf_materia_post = item['mf_materia_post']
materials_model.materials_id = materials.id
materials_model.need_h = item['need_h']
materials_model.density = item['density']
materials_model.active = item['active']
else:
raise ValidationError("材料型号认证未通过")
class sfProductionProcessCategory(models.Model):
_inherit = 'sf.production.process.category'
_description = '表面工艺类别'
url = '/api/production_process_category/list'
# 定时同步每日表面工艺类别
def sync_production_process_category_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['production_process_category_yesterday_list']:
if item:
production_process_category = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if production_process_category:
production_process_category.name = item['name']
production_process_category.code = item['code']
production_process_category.active = item['active']
else:
self.create({
"name": item['name'],
"code": item['code'],
"active": item['active'],
})
else:
raise ValidationError("表面工艺类别认证未通过")
# 同步所有表面工艺类别
def sync_all_production_process_category(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['production_process_category_all_list']:
if item:
category = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if not category:
self.create({
"name": item['name'],
"code": item['code'],
"active": item['active'],
})
else:
category.name = item['name']
category.active = item['active']
else:
raise ValidationError("表面工艺类别认证未通过")
class sfProductionProcess(models.Model):
_inherit = 'sf.production.process'
_description = '表面工艺'
url = '/api/production_process/list'
# 定时同步每日表面工艺
def sync_production_process_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['production_process_yesterday_list']:
if item:
production_process = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
category = self.env['sf.production.process.category'].search(
[("code", '=', item['category_code'])])
if production_process:
production_process.name = item['name']
production_process.category_id = category.id
production_process.remark = item['remark']
production_process.processing_day = item['processing_day']
production_process.travel_day = item['travel_day']
production_process.active = item['active']
production_process.sequence = item['sequence']
else:
self.create({
"name": item['name'],
"category_id": category.id,
"code": item['code'],
"remark": item['remark'],
"processing_day": item['processing_day'],
"travel_day": item['travel_day'],
"active": item['active'],
"sequence": item['sequence']
})
else:
raise ValidationError("表面工艺认证未通过")
# 同步所有表面工艺
def sync_all_production_process(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['production_process_all_list']:
if item:
production_process = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
category = self.env['sf.production.process.category'].search(
[("code", '=', item['category_code'])])
if not production_process:
self.create({
"name": item['name'],
"category_id": category.id,
"code": item['code'],
"remark": item['remark'],
"processing_day": item['processing_day'],
"travel_day": item['travel_day'],
"active": item['active'],
"sequence": item['sequence']
})
else:
production_process.name = item['name']
production_process.category_id = category.id
production_process.remark = item['remark']
production_process.processing_day = item['processing_day']
production_process.travel_day = item['travel_day']
production_process.active = item['active']
production_process.sequence = item['sequence']
else:
raise ValidationError("表面工艺认证未通过")
# class sfProcessingTechnology(models.Model):
# _inherit = 'sf.processing.technology'
# _description = '加工工艺'
# url = '/api/processing_technology/list'
#
# # 定时同步加工工艺
# def sync_processing_technology_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['processing_technology_yesterday_list']:
# if item:
# processing_technology = self.search(
# [("code", '=', item['process_encode']), ('active', 'in', [True, False])])
# if processing_technology:
# processing_technology.name = item['name']
# processing_technology.remark = item['remark']
# processing_technology.active = item['active']
# else:
# self.create({
# "name": item['name'],
# "code": item['process_encode'],
# "remark": item['remark'],
# "active": item['active'],
# })
# else:
# raise ValidationError("加工工艺认证未通过")
#
# # 同步所有加工工艺
# def sync_all_processing_technology(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['processing_technology_all_list']:
# if item:
# processing_technology = self.search(
# [("code", '=', item['process_encode']), ('active', 'in', [True, False])])
# if not processing_technology:
# self.create({
# "name": item['name'],
# "code": item['process_encode'],
# "remark": item['remark'],
# "active": item['active'],
# })
# else:
# processing_technology.name = item['name']
# processing_technology.remark = item['remark']
# processing_technology.active = item['active']
# else:
# raise ValidationError("加工工艺认证未通过")
class MachineBrandTags(models.Model):
_inherit = 'sf.machine.brand.tags'
_description = '品牌类别'
url = '/api/machine_brand_tags/list'
# 定时同步品牌类别
def sync_machine_brand_tags_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['machine_brand_tags_yesterday_list']:
brand_tags = self.search([("id", '=', item['id'])])
if brand_tags:
brand_tags.name = item['name']
brand_tags.color = item['color']
else:
self.create({
"name": item['name'],
"color": item['color'],
})
else:
raise ValidationError("品牌类别认证未通过")
# 同步所有品牌类别
def sync_all_machine_brand_tags(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['machine_brand_tags_all_list']:
brand_tags = self.search([("name", '=', item['name'])])
if not brand_tags:
self.create({
"name": item['name'],
"color": item['color'],
})
else:
brand_tags.name = item['name']
brand_tags.color = item['color']
else:
raise ValidationError("品牌类别认证未通过")
class MachineControlSystem(models.Model):
_inherit = 'sf.machine.control_system'
_description = '数控系统'
url = '/api/machine_control_system/list'
# 定时同步控制系统
def sync_machine_control_system_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['machine_control_system_yesterday_list']:
if item:
control_system = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
brand = self.env['sf.machine.brand'].search([('code', '=', item['brand_id'])])
if control_system:
control_system.name = item['name']
control_system.remark = item['remark']
control_system.brand_id = brand.id
control_system.active = item['active']
else:
self.create({
"remark": item['remark'],
"name": item['name'],
"code": item['code'],
'brand_id': brand.id,
"active": item['active'],
})
else:
raise ValidationError("数控系统认证未通过")
# 同步所有控制系统
def sync_all_machine_control_system(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['machine_control_system_all_list']:
if item:
control_system = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
brand = self.env['sf.machine.brand'].search([('code', '=', item['brand_id'])])
if not control_system:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
'brand_id': brand.id,
"active": item['active'],
})
else:
control_system.name = item['name']
control_system.remark = item['remark']
control_system.brand_id = brand.id
control_system.active = item['active']
else:
raise ValidationError("数控系统认证未通过")
class MachineBrand(models.Model):
_inherit = 'sf.machine.brand'
_description = '品牌'
url = '/api/machine_brand/list'
# 定时同步品牌
def sync_machine_brand_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['machine_brand_yesterday_list']:
brand = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if brand:
brand.name = item['name']
brand.image_brand = '' if not item['image_brand'] else base64.b64decode(item['image_brand'])
brand.active = item['active']
brand.remark = item['remark']
brand.tag_ids = self.env['sf.machine.brand.tags'].search([("name", 'in', item['tag_ids'])]).ids
else:
self.create({
"name": item['name'],
"code": item['code'],
"image_brand": '' if not item['image_brand'] else base64.b64decode(item['image_brand']),
"active": item['active'],
"remark": item['remark'],
"tag_ids": self.env['sf.machine.brand.tags'].search([("name", 'in', item['tag_ids'])]).ids,
})
else:
raise ValidationError("品牌认证未通过")
# 同步所有品牌
def sync_all_machine_brand(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['machine_brand_all_list']:
brand = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if not brand:
self.create({
"name": item['name'],
"active": item['active'],
"code": item['code'],
"remark": item['remark'],
"image_brand": '' if not item['image_brand'] else base64.b64decode(item['image_brand']),
"tag_ids": self.env['sf.machine.brand.tags'].search(
[("name", 'in', item['tag_ids'])]).ids
})
else:
brand.name = item['name']
brand.active = item['active']
brand.remark = item['remark']
brand.image_brand = '' if not item['image_brand'] else base64.b64decode(item['image_brand'])
brand.tag_ids = self.env['sf.machine.brand.tags'].search(
[("name", 'in', item['tag_ids'])]).ids
else:
raise ValidationError("品牌认证未通过")
class MachineToolType(models.Model):
_inherit = 'sf.machine_tool.type'
_description = '机床型号'
url = '/api/machine_tool_type/list'
# 定时同步机床型号
def sync_machine_tool_type_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['machine_tool_type_yesterday_list']:
if item.get('machine_tool_picture'):
image = base64.b64decode(item['machine_tool_picture'])
else:
image = ''
taper_type_id = self.env['spindle.taper.type'].search([('name', '=', item['taper_type_id'])])
machine_tool_type = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
control_system = self.env['sf.machine.control_system'].search(
[('code', '=', item['control_system_id'])])
jg_image_id = self.env['maintenance.equipment.image'].search([('name', 'in', item['jg_image_id'])])
lq_image_id = self.env['maintenance.equipment.image'].search([('name', 'in', item['lq_image_id'])])
brand = self.env['sf.machine.brand'].search([('code', '=', item['brand_id'])])
category = self.env['sf.machine_tool.category'].search([('code', '=', item['machine_tool_category'])])
if machine_tool_type:
machine_tool_type.update({
'code': item['code'],
"name": item['name'],
"number_of_knife_library": item['number_of_knife_library'],
"rotate_speed": item['rotate_speed'],
"number_of_axles": item['number_of_axles'],
"x_axis": item['x_axis'],
"y_axis": item['y_axis'],
"z_axis": item['z_axis'],
"b_axis": item['b_axis'],
"knife_type": item['knife_type'],
"c_axis": item['c_axis'],
"remark": item['remark'],
# "precision_min": item['precision_min'],
# "precision_max": item['precision_max'],
'control_system_id': control_system.id,
"active": item['active'],
'brand_id': brand.id,
'machine_tool_picture': image,
"heightened_way": item['heightened_way'],
"workpiece_load": item['workpiece_load'],
# "lead_screw": item['lead_screw'],
"workbench_L": item['workbench_L'],
"workbench_W": item['workbench_W'],
"workbench_H": item['workbench_H'],
# "guide_rail": item['guide_rail'],
"machine_tool_L": item['machine_tool_L'],
"machine_tool_W": item['machine_tool_W'],
"machine_tool_H": item['machine_tool_H'],
# "feed_speed": item['feed_speed'],
# "tool_speed": item['tool_speed'],
"distance_min": item['distance_min'],
"distance_max": item['distance_max'],
# "taper": item['taper'],
# "torque": item['torque'],
# "motor_power": item['motor_power'],
"tool_quality_max": item['tool_quality_max'],
"tool_long_max": item['tool_long_max'],
# "tool_diameter_max": item['tool_diameter_max'],
# "tool_diameter_min": item['tool_diameter_min'],
"machine_tool_category": category.id,
'taper_type_id': taper_type_id.id,
"function_type": item['function_type'],
"a_axis": item['a_axis'],
"T_trough_num": item['T_trough_num'],
"T_trough_wide": item['T_trough_wide'],
"T_trough_distance": item['T_trough_distance'],
"spindle_center_distance": item['spindle_center_distance'],
"spindle_continuous_power": item['spindle_continuous_power'],
"spindle_peak_power": item['spindle_peak_power'],
"spindle_sustained_torque": item['spindle_sustained_torque'],
"spindle_peak_torque": item['spindle_peak_torque'],
"linear_axis_guides_type": item['linear_axis_guides_type'],
"axis_driven_type": item['axis_driven_type'],
"X_axis_rapid_traverse_speed": item['X_axis_rapid_traverse_speed'],
"Y_axis_rapid_traverse_speed": item['Y_axis_rapid_traverse_speed'],
"Z_axis_rapid_traverse_speed": item['Z_axis_rapid_traverse_speed'],
"a_axis_rapid_traverse_speed": item['a_axis_rapid_traverse_speed'],
"b_axis_rapid_traverse_speed": item['b_axis_rapid_traverse_speed'],
"c_axis_rapid_traverse_speed": item['c_axis_rapid_traverse_speed'],
"straight_cutting_feed_rate": item['straight_cutting_feed_rate'],
"rotary_cutting_feed_rate": item['rotary_cutting_feed_rate'],
"X_precision": item['X_precision'],
"X_precision_repeat": item['X_precision_repeat'],
"Y_precision": item['Y_precision'],
"Y_precision_repeat": item['Y_precision_repeat'],
"Z_precision": item['Z_precision'],
"Z_precision_repeat": item['Z_precision_repeat'],
"a_precision": item['a_precision'],
"a_precision_repeat": item['a_precision_repeat'],
"b_precision": item['b_precision'],
"b_precision_repeat": item['b_precision_repeat'],
"c_precision": item['c_precision'],
"c_precision_repeat": item['c_precision_repeat'],
"tool_full_diameter_max": item['tool_full_diameter_max'],
"tool_perimeter_diameter_max": item['tool_perimeter_diameter_max'],
"T_tool_time": item['T_tool_time'],
"C_tool_time": item['C_tool_time'],
"jg_image_id": jg_image_id.ids,
"lq_image_id": lq_image_id.ids,
})
else:
self.create({
'code': item['code'],
"name": item['name'],
"number_of_knife_library": item['number_of_knife_library'],
"rotate_speed": item['rotate_speed'],
"number_of_axles": item['number_of_axles'],
"x_axis": item['x_axis'],
"y_axis": item['y_axis'],
"z_axis": item['z_axis'],
"b_axis": item['b_axis'],
"knife_type": item['knife_type'],
"c_axis": item['c_axis'],
"remark": item['remark'],
# "precision_min": item['precision_min'],
# "precision_max": item['precision_max'],
'control_system_id': control_system.id,
"active": item['active'],
'brand_id': brand.id,
'machine_tool_picture': image,
"heightened_way": item['heightened_way'],
"workpiece_load": item['workpiece_load'],
# "lead_screw": item['lead_screw'],
"workbench_L": item['workbench_L'],
"workbench_W": item['workbench_W'],
"workbench_H": item['workbench_H'],
# "guide_rail": item['guide_rail'],
"machine_tool_L": item['machine_tool_L'],
"machine_tool_W": item['machine_tool_W'],
"machine_tool_H": item['machine_tool_H'],
# "feed_speed": item['feed_speed'],
# "tool_speed": item['tool_speed'],
"distance_min": item['distance_min'],
"distance_max": item['distance_max'],
# "taper": item['taper'],
# "torque": item['torque'],
# "motor_power": item['motor_power'],
"tool_quality_max": item['tool_quality_max'],
"tool_long_max": item['tool_long_max'],
# "tool_diameter_max": item['tool_diameter_max'],
# "tool_diameter_min": item['tool_diameter_min'],
"machine_tool_category": category.id,
'taper_type_id': taper_type_id.id,
"function_type": item['function_type'],
"a_axis": item['a_axis'],
"T_trough_num": item['T_trough_num'],
"T_trough_wide": item['T_trough_wide'],
"T_trough_distance": item['T_trough_distance'],
"spindle_center_distance": item['spindle_center_distance'],
"spindle_continuous_power": item['spindle_continuous_power'],
"spindle_peak_power": item['spindle_peak_power'],
"spindle_sustained_torque": item['spindle_sustained_torque'],
"spindle_peak_torque": item['spindle_peak_torque'],
"linear_axis_guides_type": item['linear_axis_guides_type'],
"axis_driven_type": item['axis_driven_type'],
"X_axis_rapid_traverse_speed": item['X_axis_rapid_traverse_speed'],
"Y_axis_rapid_traverse_speed": item['Y_axis_rapid_traverse_speed'],
"Z_axis_rapid_traverse_speed": item['Z_axis_rapid_traverse_speed'],
"a_axis_rapid_traverse_speed": item['a_axis_rapid_traverse_speed'],
"b_axis_rapid_traverse_speed": item['b_axis_rapid_traverse_speed'],
"c_axis_rapid_traverse_speed": item['c_axis_rapid_traverse_speed'],
"straight_cutting_feed_rate": item['straight_cutting_feed_rate'],
"rotary_cutting_feed_rate": item['rotary_cutting_feed_rate'],
"X_precision": item['X_precision'],
"X_precision_repeat": item['X_precision_repeat'],
"Y_precision": item['Y_precision'],
"Y_precision_repeat": item['Y_precision_repeat'],
"Z_precision": item['Z_precision'],
"Z_precision_repeat": item['Z_precision_repeat'],
"a_precision": item['a_precision'],
"a_precision_repeat": item['a_precision_repeat'],
"b_precision": item['b_precision'],
"b_precision_repeat": item['b_precision_repeat'],
"c_precision": item['c_precision'],
"c_precision_repeat": item['c_precision_repeat'],
"tool_full_diameter_max": item['tool_full_diameter_max'],
"tool_perimeter_diameter_max": item['tool_perimeter_diameter_max'],
"T_tool_time": item['T_tool_time'],
"C_tool_time": item['C_tool_time'],
"jg_image_id": jg_image_id.ids,
"lq_image_id": lq_image_id.ids,
})
else:
raise ValidationError("机床型号认证未通过")
# 同步所有机床型号
def sync_all_machine_tool_type(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['machine_tool_type_all_list']:
if item.get('machine_tool_picture'):
image = base64.b64decode(item['machine_tool_picture'])
else:
image = ''
taper_type_id = self.env['spindle.taper.type'].search([('name', '=', item['taper_type_id'])])
if not taper_type_id:
taper_type_id = self.env['spindle.taper.type'].create({
'name': item['taper_type_id']
})
machine_tool_type = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
control_system = self.env['sf.machine.control_system'].search(
[('code', '=', item['control_system_id'])])
brand = self.env['sf.machine.brand'].search([('code', '=', item['brand_id'])])
jg_image_id = self.env['maintenance.equipment.image'].search([('name', 'in', item['jg_image_id'])]).ids
lq_image_id = self.env['maintenance.equipment.image'].search([('name', 'in', item['lq_image_id'])]).ids
category = self.env['sf.machine_tool.category'].search(
[('code', '=', item['machine_tool_category']), ('active', '=', True)], limit=1)
if not machine_tool_type:
self.create({
'code': item['code'],
"name": item['name'],
"number_of_knife_library": item['number_of_knife_library'],
"rotate_speed": item['rotate_speed'],
"number_of_axles": item['number_of_axles'],
"x_axis": item['x_axis'],
"y_axis": item['y_axis'],
"z_axis": item['z_axis'],
"b_axis": item['b_axis'],
"knife_type": item['knife_type'],
"c_axis": item['c_axis'],
"remark": item['remark'],
# "precision_min": item['precision_min'],
# "precision_max": item['precision_max'],
'control_system_id': control_system.id,
"active": item['active'],
'brand_id': brand.id,
'machine_tool_picture': image,
"heightened_way": item['heightened_way'],
"workpiece_load": item['workpiece_load'],
# "lead_screw": item['lead_screw'],
"workbench_L": item['workbench_L'],
"workbench_W": item['workbench_W'],
"workbench_H": item['workbench_H'],
# "guide_rail": item['guide_rail'],
"machine_tool_L": item['machine_tool_L'],
"machine_tool_W": item['machine_tool_W'],
"machine_tool_H": item['machine_tool_H'],
# "feed_speed": item['feed_speed'],
# "tool_speed": item['tool_speed'],
"distance_min": item['distance_min'],
"distance_max": item['distance_max'],
# "taper": item['taper'],
# "torque": item['torque'],
# "motor_power": item['motor_power'],
"tool_quality_max": item['tool_quality_max'],
"tool_long_max": item['tool_long_max'],
# "tool_diameter_max": item['tool_diameter_max'],
# "tool_diameter_min": item['tool_diameter_min'],
"machine_tool_category": category.id,
'taper_type_id': taper_type_id.id,
"function_type": item['function_type'],
"a_axis": item['a_axis'],
"T_trough_num": item['T_trough_num'],
"T_trough_wide": item['T_trough_wide'],
"T_trough_distance": item['T_trough_distance'],
"spindle_center_distance": item['spindle_center_distance'],
"spindle_continuous_power": item['spindle_continuous_power'],
"spindle_peak_power": item['spindle_peak_power'],
"spindle_sustained_torque": item['spindle_sustained_torque'],
"spindle_peak_torque": item['spindle_peak_torque'],
"linear_axis_guides_type": item['linear_axis_guides_type'],
"axis_driven_type": item['axis_driven_type'],
"X_axis_rapid_traverse_speed": item['X_axis_rapid_traverse_speed'],
"Y_axis_rapid_traverse_speed": item['Y_axis_rapid_traverse_speed'],
"Z_axis_rapid_traverse_speed": item['Z_axis_rapid_traverse_speed'],
"a_axis_rapid_traverse_speed": item['a_axis_rapid_traverse_speed'],
"b_axis_rapid_traverse_speed": item['b_axis_rapid_traverse_speed'],
"c_axis_rapid_traverse_speed": item['c_axis_rapid_traverse_speed'],
"straight_cutting_feed_rate": item['straight_cutting_feed_rate'],
"rotary_cutting_feed_rate": item['rotary_cutting_feed_rate'],
"X_precision": item['X_precision'],
"X_precision_repeat": item['X_precision_repeat'],
"Y_precision": item['Y_precision'],
"Y_precision_repeat": item['Y_precision_repeat'],
"Z_precision": item['Z_precision'],
"Z_precision_repeat": item['Z_precision_repeat'],
"a_precision": item['a_precision'],
"a_precision_repeat": item['a_precision_repeat'],
"b_precision": item['b_precision'],
"b_precision_repeat": item['b_precision_repeat'],
"c_precision": item['c_precision'],
"c_precision_repeat": item['c_precision_repeat'],
"tool_full_diameter_max": item['tool_full_diameter_max'],
"tool_perimeter_diameter_max": item['tool_perimeter_diameter_max'],
"T_tool_time": item['T_tool_time'],
"C_tool_time": item['C_tool_time'],
"jg_image_id": jg_image_id,
"lq_image_id": lq_image_id,
})
else:
machine_tool_type.update({
'code': item['code'],
"name": item['name'],
"number_of_knife_library": item['number_of_knife_library'],
"rotate_speed": item['rotate_speed'],
"number_of_axles": item['number_of_axles'],
"x_axis": item['x_axis'],
"y_axis": item['y_axis'],
"z_axis": item['z_axis'],
"b_axis": item['b_axis'],
"knife_type": item['knife_type'],
"c_axis": item['c_axis'],
"remark": item['remark'],
# "precision_min": item['precision_min'],
# "precision_max": item['precision_max'],
'control_system_id': control_system.id,
"active": item['active'],
'brand_id': brand.id,
'machine_tool_picture': image,
"heightened_way": item['heightened_way'],
"workpiece_load": item['workpiece_load'],
# "lead_screw": item['lead_screw'],
"workbench_L": item['workbench_L'],
"workbench_W": item['workbench_W'],
"workbench_H": item['workbench_H'],
# "guide_rail": item['guide_rail'],
"machine_tool_L": item['machine_tool_L'],
"machine_tool_W": item['machine_tool_W'],
"machine_tool_H": item['machine_tool_H'],
# "feed_speed": item['feed_speed'],
# "tool_speed": item['tool_speed'],
"distance_min": item['distance_min'],
"distance_max": item['distance_max'],
# "taper": item['taper'],
# "torque": item['torque'],
# "motor_power": item['motor_power'],
"tool_quality_max": item['tool_quality_max'],
"tool_long_max": item['tool_long_max'],
# "tool_diameter_max": item['tool_diameter_max'],
# "tool_diameter_min": item['tool_diameter_min'],
"machine_tool_category": category.id,
'taper_type_id': taper_type_id.id,
"function_type": item['function_type'],
"a_axis": item['a_axis'],
"T_trough_num": item['T_trough_num'],
"T_trough_wide": item['T_trough_wide'],
"T_trough_distance": item['T_trough_distance'],
"spindle_center_distance": item['spindle_center_distance'],
"spindle_continuous_power": item['spindle_continuous_power'],
"spindle_peak_power": item['spindle_peak_power'],
"spindle_sustained_torque": item['spindle_sustained_torque'],
"spindle_peak_torque": item['spindle_peak_torque'],
"linear_axis_guides_type": item['linear_axis_guides_type'],
"axis_driven_type": item['axis_driven_type'],
"X_axis_rapid_traverse_speed": item['X_axis_rapid_traverse_speed'],
"Y_axis_rapid_traverse_speed": item['Y_axis_rapid_traverse_speed'],
"Z_axis_rapid_traverse_speed": item['Z_axis_rapid_traverse_speed'],
"a_axis_rapid_traverse_speed": item['a_axis_rapid_traverse_speed'],
"b_axis_rapid_traverse_speed": item['b_axis_rapid_traverse_speed'],
"c_axis_rapid_traverse_speed": item['c_axis_rapid_traverse_speed'],
"straight_cutting_feed_rate": item['straight_cutting_feed_rate'],
"rotary_cutting_feed_rate": item['rotary_cutting_feed_rate'],
"X_precision": item['X_precision'],
"X_precision_repeat": item['X_precision_repeat'],
"Y_precision": item['Y_precision'],
"Y_precision_repeat": item['Y_precision_repeat'],
"Z_precision": item['Z_precision'],
"Z_precision_repeat": item['Z_precision_repeat'],
"a_precision": item['a_precision'],
"a_precision_repeat": item['a_precision_repeat'],
"b_precision": item['b_precision'],
"b_precision_repeat": item['b_precision_repeat'],
"c_precision": item['c_precision'],
"c_precision_repeat": item['c_precision_repeat'],
"tool_full_diameter_max": item['tool_full_diameter_max'],
"tool_perimeter_diameter_max": item['tool_perimeter_diameter_max'],
"T_tool_time": item['T_tool_time'],
"C_tool_time": item['C_tool_time'],
"jg_image_id": jg_image_id,
"lq_image_id": lq_image_id,
})
else:
raise ValidationError("机床型号认证未通过")
# class sfProcessingOrder(models.Model):
# _inherit = 'sf.processing.order'
# _description = '工序'
# url = '/api/processing_order/list'
#
# # 定时同步工序
# def sync_processing_order_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['processing_order_yesterday_list']:
# processing_order = self.search([("id", '=', item['id']), ('active', 'in', [True, False])])
# if processing_order:
# processing_order.sequence = item['sequence']
# else:
# self.create({
# "sequence": item['sequence'],
# })
# else:
# raise ValidationError("工序认证未通过")
#
# # 同步所有工序
# def sync_all_processing_order(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['processing_order_all_list']:
# processing_order = self.search([("id", '=', item['id']), ('active', 'in', [True, False])])
# if not processing_order:
# self.create({
# "sequence": item['sequence'],
# })
# else:
# processing_order.sequence = item['sequence']
# else:
# raise ValidationError("工序认证未通过")
class sfProductionProcessParameter(models.Model):
_inherit = 'sf.production.process.parameter'
_description = '表面工艺可选参数'
url = '/api/production_process_parameter/list'
# 定时同步每日表面工艺可选参数
def sync_production_process_parameter_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['mrs_production_process_parameter_yesterday_list']:
if item:
production_process_parameter = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
process = self.env['sf.production.process'].search(
[('code', '=', item['process_id_code'])])
if production_process_parameter:
production_process_parameter.name = item['name']
production_process_parameter.process_description = item['process_description']
production_process_parameter.processing_day = item['processing_day']
production_process_parameter.travel_day = item['travel_day']
production_process_parameter.active = item['active']
production_process_parameter.process_id = process.id
production_process_parameter.materials_model_ids = self.env['sf.materials.model'].search(
[('materials_no', 'in', item['materials_model_ids_codes'])])
production_process_parameter.processing_mm = item['processing_mm']
else:
self.create({
"name": item['name'],
"process_description": item['process_description'],
"processing_day": item['processing_day'],
"travel_day": item['travel_day'],
"code": item['code'],
"active": item['active'],
"process_id": process.id,
"materials_model_ids": self.env['sf.materials.model'].search(
[('materials_no', 'in', item['materials_model_ids_codes'])]),
"processing_mm": item['processing_mm']
})
else:
raise ValidationError("表面工艺可选参数认证未通过") # 定时同步表面工艺
# 同步所有表面工艺可选参数
def sync_all_production_process_parameter(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['mrs_production_process_parameter_all_list']:
if item:
production_process_parameter = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
process = self.env['sf.production.process'].search(
[('code', '=', item['process_id_code'])], limit=1)
if not production_process_parameter:
self.create({
"name": item['name'],
"process_description": item['process_description'],
"processing_day": item['processing_day'],
"travel_day": item['travel_day'],
"code": item['code'],
"active": item['active'],
"process_id": process.id,
'materials_model_ids': self.env['sf.materials.model'].search(
[('materials_no', 'in', item['materials_model_ids_codes'])]),
'processing_mm': item['processing_mm']
})
else:
production_process_parameter.name = item['name']
production_process_parameter.process_description = item['process_description']
production_process_parameter.processing_day = item['processing_day']
production_process_parameter.travel_day = item['travel_day']
production_process_parameter.process_id = process.id
production_process_parameter.materials_model_ids = self.env['sf.materials.model'].search(
[('materials_no', 'in', item['materials_model_ids_codes'])])
production_process_parameter.active = item['active']
production_process_parameter.processing_mm = item['processing_mm']
else:
raise ValidationError("表面工艺可选参数认证未通过")
class MachineToolCategory(models.Model):
_inherit = 'sf.machine_tool.category'
_description = '机床类型'
url = '/api/machine_tool_category/list'
# 定时同步机床类型
def sync_machine_tool_category_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['machine_tool_category_yesterday_list']:
machine_tool_category = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if machine_tool_category:
machine_tool_category.name = item['name']
machine_tool_category.category = item['category']
machine_tool_category.remark = item['remark']
machine_tool_category.active = item['active']
else:
self.create({
"name": item['name'],
"code": item['code'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("机床类型认证未通过")
# 同步所有机床类型
def sync_all_machine_tool_category(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['machine_tool_category_all_list']:
machine_tool_category = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if not machine_tool_category:
self.create({
"name": item['name'],
"code": item['code'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
machine_tool_category.name = item['name']
machine_tool_category.category = item['category']
machine_tool_category.remark = item['remark']
machine_tool_category.active = item['active']
else:
raise ValidationError("机床类型认证未通过")
# 同步刀具物料
class sfSyncCutting_tool_Material(models.Model):
_inherit = 'sf.cutting.tool.material'
_description = '刀具物料同步'
url = '/api/mrs_cutting_tool_material/list'
# 定时同步每日刀具物料
def sync_cutting_tool_material_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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('mrs_cutting_tool_material_yesterday_list'):
for item in result['mrs_cutting_tool_material_yesterday_list']:
if item:
cutting_tool_material = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not cutting_tool_material:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
cutting_tool_material.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("刀具物料认证未通过")
# 同步所有刀具物料
def sync_all_cutting_tool_material(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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('mrs_cutting_tool_material_all_list'):
for item in result['mrs_cutting_tool_material_all_list']:
if item:
cutting_tool_material = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not cutting_tool_material:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
cutting_tool_material.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("刀具物料认证未通过")
# 同步功能刀具类型列表
class SyncFunctionalCuttingToolModel(models.Model):
_inherit = 'sf.functional.cutting.tool.model'
_description = '同步功能刀具类型列表'
url = '/api/mrs_functional_cutting_tool_model/list'
# 定时同步每日功能刀具类型列表
def sync_functional_cutting_tool_model_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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('mrs_functional_cutting_tool_model_yesterday_list'):
for item in result['mrs_functional_cutting_tool_model_yesterday_list']:
if item:
functional_cutting_tool_model = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not functional_cutting_tool_model:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
functional_cutting_tool_model.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("功能刀具类型认证未通过")
# 同步所有功能刀具类型列表
def sync_all_functional_cutting_tool_model(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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('mrs_functional_cutting_tool_model_all_list'):
for item in result['mrs_functional_cutting_tool_model_all_list']:
if item:
functional_cutting_tool_model = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not functional_cutting_tool_model:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
functional_cutting_tool_model.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("功能刀具类型认证未通过")
class SyncFixtureMaterial(models.Model):
_inherit = 'sf.fixture.material'
_description = '同步夹具物料列表'
url = '/api/fixture_material/list'
# 定时同步夹具物料列表
def sync_fixture_material_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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('fixture_material_yesterday_list'):
for item in result['fixture_material_yesterday_list']:
if item:
fixture_material = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if not fixture_material:
self.create({
"name": item['name'],
"code": item['code'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
fixture_material.write({
"name": item['name'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("夹具物料认证未通过")
# 定时同步所有夹具物料列表
def sync_all_fixture_material(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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('fixture_material_all_list'):
for item in result['fixture_material_all_list']:
if item:
fixture_material = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
if not fixture_material:
self.create({
"name": item['name'],
"code": item['code'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
fixture_material.write({
"name": item['name'],
"category": item['category'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("夹具物料认证未通过")
class SyncMulti_Mounting_Type(models.Model):
_inherit = 'sf.multi_mounting.type'
_description = '同步联装类型列表'
url = '/api/multi_mounting_type/list'
# 定时同步联装类型列表
def sync_multi_mounting_type_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:
if result.get('multi_mounting_type_yesterday_list'):
for item in result['multi_mounting_type_yesterday_list']:
if item:
multi_mounting_type = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not multi_mounting_type:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
multi_mounting_type.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("联装类型认证未通过")
# 定时同步所有联装类型列表
def sync_all_multi_mounting_type(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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('multi_mounting_type_all_list'):
for item in result['multi_mounting_type_all_list']:
if item:
multi_mounting_type = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not multi_mounting_type:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
multi_mounting_type.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("联装类型认证未通过")
class SyncFixtureModel(models.Model):
_inherit = 'sf.fixture.model'
_description = '同步夹具型号列表'
url = '/api/fixture_model/list'
# 定时同步夹具型号列表
def sync_fixture_model_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:
if result.get('fixture_model_yesterday_list'):
for item in result['fixture_model_yesterday_list']:
if item:
fixture_model = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
val = {
"name": item['name'],
"code": item['code'],
"fixture_material_id": self.env['sf.fixture.material'].search(
[('code', '=', item['fixture_material_code'])]).id,
"multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
[('code', '=', item['multi_mounting_type_code'])]).id,
"brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
"model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
"status": item['status'],
"active": item['active'],
}
if not fixture_model:
self.create(val)
else:
fixture_model.write(val)
else:
raise ValidationError("夹具型号认证未通过")
# 定时同步所有夹具型号列表
def sync_all_fixture_model(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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('fixture_model_all_list'):
for item in result['fixture_model_all_list']:
if item:
fixture_model = self.search([('code', '=', item['code']), ('active', 'in', [True, False])])
val = {
"name": item['name'],
"code": item['code'],
"fixture_material_id": self.env['sf.fixture.material'].search(
[('code', '=', item['fixture_material_code'])]).id,
"multi_mounting_type_id": self.env['sf.multi_mounting.type'].search(
[('code', '=', item['multi_mounting_type_code'])]).id,
"brand_id": self.env['sf.machine.brand'].search([('code', '=', item['brand_code'])]).id,
"model_file": '' if not item['model_file'] else base64.b64decode(item['model_file']),
"status": item['status'],
"active": item['active'],
}
if not fixture_model:
self.create(val)
else:
fixture_model.write(val)
else:
raise ValidationError("夹具型号认证未通过")
class SyncfixtureMaterialsBasicParameters(models.Model):
_inherit = 'sf.fixture.materials.basic.parameters'
_description = '同步夹具型号基本参数列表'
url = '/api/fixture_parameters/list'
# 定时同步夹具型号基本信息
def sync_fixture_materials_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:
if result.get('fixture_parameters_yesterday_list'):
all_list = result.get('fixture_parameters_yesterday_list')
if all_list.get('zero_chuck_all_list'):
self._write_or_create(all_list.get('zero_chuck_yesterday_list'), '零点卡盘')
if all_list.get('zero_tray_all_list'):
self._write_or_create(all_list.get('zero_tray_yesterday_list'), '零点托盘')
if all_list.get('pneumatic_fixture_all_list'):
self._write_or_create(all_list.get('pneumatic_fixture_yesterday_list'), '气动夹具')
if all_list.get('jaw_vice_all_list'):
self._write_or_create(all_list.get('jaw_vice_yesterday_list'), '虎钳夹具')
if all_list.get('magnet_fixture_all_list'):
self._write_or_create(all_list.get('magnet_fixture_yesterday_list'), '磁吸夹具')
if all_list.get('adapter_board_all_list'):
self._write_or_create(all_list.get('adapter_board_yesterday_list'), '转接板(锁板)夹具')
if all_list.get('scroll_chuck_all_list'):
self._write_or_create(all_list.get('scroll_chuck_yesterday_list'), '三爪卡盘')
else:
raise ValidationError("夹具型号基本参数认证未通过")
# 定时同步所有夹具型号基本信息
def sync_all_fixture_materials_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:
if result.get('fixture_parameters_all_list'):
all_list = result.get('fixture_parameters_all_list')
if all_list.get('zero_chuck_all_list'):
self._write_or_create(all_list.get('zero_chuck_all_list'), '零点卡盘')
if all_list.get('zero_tray_all_list'):
self._write_or_create(all_list.get('zero_tray_all_list'), '零点托盘')
if all_list.get('pneumatic_fixture_all_list'):
self._write_or_create(all_list.get('pneumatic_fixture_all_list'), '气动夹具')
if all_list.get('jaw_vice_all_list'):
self._write_or_create(all_list.get('jaw_vice_all_list'), '虎钳夹具')
if all_list.get('magnet_fixture_all_list'):
self._write_or_create(all_list.get('magnet_fixture_all_list'), '磁吸夹具')
if all_list.get('adapter_board_all_list'):
self._write_or_create(all_list.get('adapter_board_all_list'), '转接板(锁板)夹具')
if all_list.get('scroll_chuck_all_list'):
self._write_or_create(all_list.get('scroll_chuck_all_list'), '三爪卡盘')
else:
raise ValidationError("夹具型号基本参数认证未通过")
def _write_or_create(self, fixture_parameters_list, material_name):
for item in fixture_parameters_list:
if item:
basic_parameters = self.search([('code', '=', item.get('code')), ('active', 'in', [True, False])])
if not basic_parameters:
self.create(self._get_basic_parameters_list(item, material_name))
else:
basic_parameters.write(self._get_basic_parameters_list(item, material_name))
class SyncFunctionalFixtureType(models.Model):
_inherit = 'sf.functional.fixture.type'
_description = '同步功能夹具类型列表'
url = '/api/functional_fixture_type/list'
# 定时同步功能夹具类型列表
def sync_functional_fixture_type_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'])
# print('result:%s' % result)
if result['status'] == 1:
if result.get('functional_fixture_type_yesterday_list'):
for item in result['functional_fixture_type_yesterday_list']:
if item:
functional_fixture_type = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not functional_fixture_type:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
functional_fixture_type.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("功能夹具类型认证未通过")
# 定时同步所有功能夹具类型列表
def sync_all_functional_fixture_type(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:
if result.get('functional_fixture_type_all_list'):
for item in result['functional_fixture_type_all_list']:
if item:
functional_fixture_type = self.search(
[("code", '=', item['code']), ('active', 'in', [True, False])])
if not functional_fixture_type:
self.create({
"name": item['name'],
"code": item['code'],
"remark": item['remark'],
"active": item['active'],
})
else:
functional_fixture_type.write({
"name": item['name'],
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("功能夹具类型认证未通过")
# 同步刀具类型
class SfToolType(models.Model):
_inherit = 'sf.cutting.tool.type'
_description = '同步刀具类型'
url = '/api/mrs_cutting_tool_type/list'
# 定时同步每日刀具类型
def sync_tool_type_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['mrs_cutting_tool_type_yesterday_list']:
if item:
cutting_tool_type = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
cutting_tool_material = self.env['sf.cutting.tool.material'].search(
[("code", '=', item['cutting_tool_material_code'])])
if not cutting_tool_type:
self.create({
"name": item['name'],
"code": item['code'],
"cutting_tool_material_id": cutting_tool_material.id,
"remark": item['remark'],
"active": item['active'],
})
else:
cutting_tool_type.write({
"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("刀具类型认证未通过")
# 同步所有刀具类型列表
def sync_all_tool_type(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['mrs_cutting_tool_type_all_list']:
if item:
cutting_tool_type = self.search([("code", '=', item['code']), ('active', 'in', [True, False])])
cutting_tool_material = self.env['sf.cutting.tool.material'].search(
[("code", '=', item['cutting_tool_material_code'])])
if not cutting_tool_type:
self.create({
"name": item['name'],
"code": item['code'],
"cutting_tool_material_id": cutting_tool_material.id,
"remark": item['remark'],
"active": item['active'],
})
else:
cutting_tool_type.write({
"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"remark": item['remark'],
"active": item['active'],
})
else:
raise ValidationError("刀具类型认证未通过")
# 同步能力特征库
class SfMaintenanceEquipmentImage(models.Model):
_inherit = 'maintenance.equipment.image'
_description = '能力特征库'
url = '/api/maintenance_equipment_image/list'
# 定时同步每日能力特征库
def sync_maintenance_equipment_image_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['ability_feature_library_yesterday_list']:
if item:
ability_feature_library = self.search(
[("name", '=', item['name']), ('active', 'in', [True, False])])
if not ability_feature_library:
self.create({
"name": item['name'],
"type": item['type'],
"image": '' if not item['image'] else base64.b64decode(item['image']),
"active": item['active'],
})
else:
ability_feature_library.write({
"type": item['type'],
"image": '' if not item['image'] else base64.b64decode(item['image']),
"active": item['active'],
})
else:
raise ValidationError("能力特征库认证未通过")
# 同步所有能力特征库
def sync_all_maintenance_equipment_image(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['ability_feature_library_all_list']:
if item:
ability_feature_library = self.search(
[("name", '=', item['name']), ('active', 'in', [True, False])])
if not ability_feature_library:
self.create({
"name": item['name'],
"type": item['type'],
"image": '' if not item['image'] else base64.b64decode(item['image']),
"active": item['active'],
})
else:
ability_feature_library.write({
"type": item['type'],
"image": '' if not item['image'] else base64.b64decode(item['image']),
"active": item['active'],
})
else:
raise ValidationError("认证未通过")
class MaterialApply(models.Model):
_inherit = 'material.apply'
_description = '材料应用'
url = '/api/material_apply/list'
# 定时同步材料应用
def sync_material_apply(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['material_apply_yesterday_list']:
material_apply = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if material_apply:
material_apply.name = item['name']
material_apply.active = item['active']
else:
self.create({
"name": item['name'],
"active": item['active'],
})
else:
raise ValidationError("材料应用认证未通过")
# 同步所有材料应用
def sync_all_material_apply(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['material_apply_all_list']:
material_apply = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not material_apply:
self.create({
"name": item['name'],
"active": item['active'],
})
else:
material_apply.name = item['name']
material_apply.active = item['active']
else:
raise ValidationError("材料应用认证未通过")
class ModelInternationalStandards(models.Model):
_inherit = 'sf.international.standards'
_description = '制造标准'
url = '/api/mrs_international_standards/list'
# 定时同步制造标准
def sync_mrs_international_standards(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['mrs_international_standards_yesterday_list']:
international_standards = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if international_standards:
international_standards.name = item['name']
international_standards.active = item['active']
else:
self.create({
"name": item['name'],
"code": item['code'],
"active": item['active'],
})
else:
raise ValidationError("制造标准认证未通过")
# 同步所有制造标准
def sync_all_mrs_international_standards(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['mrs_international_standards_all_list']:
international_standards = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not international_standards:
self.create({
"name": item['name'],
"code": item['code'],
"active": item['active'],
})
else:
international_standards.name = item['name']
international_standards.active = item['active']
else:
raise ValidationError("制造标准认证未通过")
class CuttingSpeed(models.Model):
_inherit = 'sf.cutting.speed'
_description = '切削速度'
url = '/api/cutting_speed/list'
def sync_cutting_speed_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_speed_yesterday_list']:
cutting_speed = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not cutting_speed:
self.create({
'name': item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'execution_standard_id': self.env['sf.international.standards'].search(
[('code', '=', item['execution_standard_code'])]).id,
'material_name_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['material_name'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'ability_feature_library': self.env['maintenance.equipment.image'].search(
[('name', '=', item['ability_feature_library']), ('type', '=', '加工能力')]).id,
'material_code': item['material_code'],
'material_grade': item['material_grade'],
'tensile_strength': item['tensile_strength'],
'hardness': item['hardness'],
'cutting_speed': item['cutting_speed'],
'application': item['application'],
'active': item['active'],
})
else:
cutting_speed.write({
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'execution_standard_id': self.env['sf.international.standards'].search(
[('code', '=', item['execution_standard_code'])]).id,
'material_name_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['material_name'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'ability_feature_library': self.env['maintenance.equipment.image'].search(
[('name', '=', item['ability_feature_library']), ('type', '=', '加工能力')]).id,
'material_code': item['material_code'],
'material_grade': item['material_grade'],
'tensile_strength': item['tensile_strength'],
'hardness': item['hardness'],
'cutting_speed': item['cutting_speed'],
'application': item['application'],
'active': item['active']})
else:
raise ValidationError("切削速度认证未通过")
def sync_all_cutting_speed(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_speed_all_list']:
cutting_speed = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not cutting_speed:
self.create({
'name': item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'execution_standard_id': self.env['sf.international.standards'].search(
[('code', '=', item['execution_standard_code'])]).id,
'material_name_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['material_name'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'ability_feature_library': self.env['maintenance.equipment.image'].search(
[('name', '=', item['ability_feature_library']), ('type', '=', '加工能力')]).id,
'material_code': item['material_code'],
'material_grade': item['material_grade'],
'tensile_strength': item['tensile_strength'],
'hardness': item['hardness'],
'cutting_speed': item['cutting_speed'],
'application': item['application'],
'active': item['active'],
})
else:
cutting_speed.write({
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'execution_standard_id': self.env['sf.international.standards'].search(
[('code', '=', item['execution_standard_code'])]).id,
'material_name_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['material_name'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'ability_feature_library': self.env['maintenance.equipment.image'].search(
[('name', '=', item['ability_feature_library']), ('type', '=', '加工能力')]).id,
'material_code': item['material_code'],
'material_grade': item['material_grade'],
'tensile_strength': item['tensile_strength'],
'hardness': item['hardness'],
'cutting_speed': item['cutting_speed'],
'application': item['application'],
'active': item['active']})
else:
raise ValidationError("切削速度认证未通过")
class CuttingWidthDepth(models.Model):
_inherit = 'sf.cutting.width.depth'
_description = '切削宽度和深度'
url = '/api/cutting_width_depth/list'
def sync_cutting_width_depth_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_width_depth_yesterday_list']:
cutting_width_depth = self.search([("name", '=', item['name'])])
if not cutting_width_depth:
self.create({
'name': item['name'],
})
else:
raise ValidationError("切削宽度和深度认证未通过")
def sync_all_cutting_width_depth(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_width_depth_all_list']:
cutting_width_depth = self.search([("name", '=', item['name'])])
if not cutting_width_depth:
self.create({
'name': item['name'],
})
else:
raise ValidationError("切削宽度和深度认证未通过")
class CuttingSpeed(models.Model):
_inherit = 'sf.feed.per.tooth'
_description = '每齿走刀量'
url = '/api/feed_per_tooth/list'
def sync_feed_per_tooth_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['feed_per_tooth_yesterday_list']:
feed_per_tooth = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not feed_per_tooth:
self.create({
'name': item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'materials_type_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['materials_type_code'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'blade_diameter': item['blade_diameter'],
'feed_per_tooth': item['feed_per_tooth'],
'active': item['active'],
})
else:
feed_per_tooth.write({
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'materials_type_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['materials_type_code'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'blade_diameter': item['blade_diameter'],
'feed_per_tooth': item['feed_per_tooth'],
'active': item['active']})
else:
raise ValidationError("每齿走刀量认证未通过")
def sync_all_feed_per_tooth(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['feed_per_tooth_all_list']:
feed_per_tooth = self.search([("name", '=', item['name']), ('active', 'in', [True, False])])
if not feed_per_tooth:
_logger.info("item[standard_library_code] %s" % item.get('standard_library_code'))
if item.get('standard_library_code'):
self.create({
'name': item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'materials_type_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['materials_type_code'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'blade_diameter': item['blade_diameter'],
'feed_per_tooth': item['feed_per_tooth'],
'active': item['active'],
})
else:
feed_per_tooth.write({
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', item['standard_library_code'])]).id,
'materials_type_id': self.env['sf.materials.model'].search(
[('materials_no', '=', item['materials_type_code'])]).id,
'cutting_width_depth_id': self.env['sf.cutting.width.depth'].search(
[('name', '=', item['cutting_width_depth'])]).id,
'blade_diameter': item['blade_diameter'],
'feed_per_tooth': item['feed_per_tooth'],
'active': item['active']})
else:
raise ValidationError("每齿走刀量认证未通过")
class Cutting_tool_standard_library(models.Model):
_inherit = 'sf.cutting_tool.standard.library'
_description = '刀具标准库'
url = '/api/cutting_tool_standard_library/list'
# 定时同步刀具标准库
def sync_cutting_tool_standard_library_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_standard_library_yesterday_list']:
cutting_tool_standard_library = self.search(
[("code", '=', item['code']),
('active', 'in', [True, False])])
cutting_tool_type = self.env['sf.cutting.tool.type'].search(
[("code", '=', item['cutting_tool_type_code'])])
cutting_tool_material = self.env['sf.cutting.tool.material'].search(
[("code", '=', item['cutting_tool_material_code'])])
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'])])
if not cutting_tool_standard_library:
self.create({
"code": item['code'],
"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"cutting_tool_type_id": cutting_tool_type.id,
"brand_id": brand.id,
"material_model_id": materials_model.id,
"tool_hardness": item['tool_hardness'],
"coating_material": item['coating_material'],
"blade_type": item['blade_type'],
"integral_coarse_medium_fine": item['integral_coarse_medium_fine'],
"integral_run_out_accuracy_max": item['integral_run_out_accuracy_max'],
"integral_run_out_accuracy_min": item['integral_run_out_accuracy_min'],
"cutter_bar_ids": [(6, 0, [])] if not item.get('cutter_bar_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_bar_codes'],
result['factory_short_name']),
"cutter_pad_ids": [(6, 0, [])] if not item.get('cutter_pad_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_pad_codes'],
result['factory_short_name']),
"fit_blade_shape_id": False if not item['fit_blade_shape'] else self.env[
'maintenance.equipment.image'].search(
[('name', '=', item['fit_blade_shape'])]).id,
"chuck_id": False if not item['chuck_code'] else self.search(
[('code', '=', item['chuck_code'])]).id,
"handle_id": False if not item['handle_code'] else self.search(
[('code', '=', item['handle_code'])]).id,
"suitable_machining_method_ids": [(6, 0, [])] if not item.get(
'suitable_machining_methods') else self.env['maintenance.equipment.image']._get_ids(
item['suitable_machining_methods']),
"blade_tip_characteristics_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['blade_tip_characteristics'])]).id,
"handle_type_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['handle_type'])]).id,
"cutting_direction_ids": [(6, 0, [])] if not item.get('cutting_direction') else self.env[
'maintenance.equipment.image']._get_ids(item['cutting_direction']),
"suitable_coolant_ids": [(6, 0, [])] if not item.get('suitable_coolant') else self.env[
'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
"compaction_way_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['compaction_way'])]).id,
"is_cloud": True,
"active": item['active'],
})
else:
cutting_tool_standard_library.write(
{"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"cutting_tool_type_id": cutting_tool_type.id,
"brand_id": brand.id,
"material_model_id": materials_model.id,
"tool_hardness": item['tool_hardness'],
"coating_material": item['coating_material'],
"blade_type": item['blade_type'],
"integral_coarse_medium_fine": item['integral_coarse_medium_fine'],
"integral_run_out_accuracy_max": item['integral_run_out_accuracy_max'],
"integral_run_out_accuracy_min": item['integral_run_out_accuracy_min'],
"cutter_bar_ids": [(6, 0, [])] if not item.get('cutter_bar_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_bar_codes'],
result['factory_short_name']),
"cutter_pad_ids": [(6, 0, [])] if not item.get('cutter_pad_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_pad_codes'],
result['factory_short_name']),
"fit_blade_shape_id": False if not item['fit_blade_shape'] else self.env[
'maintenance.equipment.image'].search(
[('name', '=', item['fit_blade_shape'])]).id,
"chuck_id": False if not item['chuck_code'] else self.search(
[('code', '=', item['chuck_code'])]).id,
"handle_id": False if not item['handle_code'] else self.search(
[('code', '=', item['handle_code'])]).id,
"suitable_machining_method_ids": [(6, 0, [])] if not item.get(
'suitable_machining_methods') else self.env['maintenance.equipment.image']._get_ids(
item['suitable_machining_methods']),
"blade_tip_characteristics_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['blade_tip_characteristics'])]).id,
"handle_type_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['handle_type'])]).id,
"cutting_direction_ids": [(6, 0, [])] if not item.get('cutting_direction') else self.env[
'maintenance.equipment.image']._get_ids(item['cutting_direction']),
"suitable_coolant_ids": [(6, 0, [])] if not item.get('suitable_coolant') else self.env[
'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
"compaction_way_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['compaction_way'])]).id,
"active": item['active'],
})
else:
raise ValidationError("刀具标准库认证未通过")
# 同步所有刀具标准库
def sync_all_cutting_tool_standard_library(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_standard_library_all_list']:
cutting_tool_standard_library = self.search(
[("code", '=', item['code']),
("active", 'in', [True, False])])
cutting_tool_type = self.env['sf.cutting.tool.type'].search(
[("code", '=', item['cutting_tool_type_code'])])
cutting_tool_material = self.env['sf.cutting.tool.material'].search(
[("code", '=', item['cutting_tool_material_code'])])
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'])])
if not cutting_tool_standard_library:
self.create({
"code": item['code'],
"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"cutting_tool_type_id": cutting_tool_type.id,
"brand_id": brand.id,
"material_model_id": materials_model.id,
"tool_hardness": item['tool_hardness'],
"coating_material": item['coating_material'],
"blade_type": item['blade_type'],
"integral_coarse_medium_fine": item['integral_coarse_medium_fine'],
"integral_run_out_accuracy_max": item['integral_run_out_accuracy_max'],
"integral_run_out_accuracy_min": item['integral_run_out_accuracy_min'],
"cutter_bar_ids": [(6, 0, [])] if not item.get('cutter_bar_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_bar_codes'],
result['factory_short_name']),
"cutter_pad_ids": [(6, 0, [])] if not item.get('cutter_pad_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_pad_codes'],
result['factory_short_name']),
"fit_blade_shape_id": False if not item['fit_blade_shape'] else self.env[
'maintenance.equipment.image'].search(
[('name', '=', item['fit_blade_shape'])]).id,
"chuck_id": False if not item['chuck_code'] else self.search(
[('code', '=', item['chuck_code'])]).id,
"handle_id": False if not item['handle_code'] else self.search(
[('code', '=', item['handle_code'])]).id,
"suitable_machining_method_ids": [(6, 0, [])] if not item.get(
'suitable_machining_method') else self.env['maintenance.equipment.image']._get_ids(
item['suitable_machining_method']),
"blade_tip_characteristics_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['blade_tip_characteristics'])]).id,
"handle_type_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['handle_type'])]).id,
"cutting_direction_ids": [(6, 0, [])] if not item.get('cutting_direction') else self.env[
'maintenance.equipment.image']._get_ids(item['cutting_direction']),
"suitable_coolant_ids": [(6, 0, [])] if not item.get('suitable_coolant') else self.env[
'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
"compaction_way_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['compaction_way'])]).id,
"is_cloud": True,
"active": item['active'],
})
else:
cutting_tool_standard_library.write(
{"name": item['name'],
"cutting_tool_material_id": cutting_tool_material.id,
"cutting_tool_type_id": cutting_tool_type.id,
"brand_id": brand.id,
"material_model_id": materials_model.id,
"tool_hardness": item['tool_hardness'],
"coating_material": item['coating_material'],
"blade_type": item['blade_type'],
"integral_coarse_medium_fine": item['integral_coarse_medium_fine'],
"integral_run_out_accuracy_max": item['integral_run_out_accuracy_max'],
"integral_run_out_accuracy_min": item['integral_run_out_accuracy_min'],
"cutter_bar_ids": [(6, 0, [])] if not item.get('cutter_bar_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_bar_codes'],
result['factory_short_name']),
"cutter_pad_ids": [(6, 0, [])] if not item.get('cutter_pad_codes') else self.env[
'sf.cutting_tool.standard.library']._get_ids(item['cutter_pad_codes'],
result['factory_short_name']),
"fit_blade_shape_id": False if not item['fit_blade_shape'] else self.env[
'maintenance.equipment.image'].search(
[('name', '=', item['fit_blade_shape'])]).id,
"chuck_id": False if not item['chuck_code'] else self.search(
[('code', '=', item['chuck_code'])]).id,
"handle_id": False if not item['handle_code'] else self.search(
[('code', '=', item['handle_code'])]).id,
"suitable_machining_method_ids": [(6, 0, [])] if not item.get(
'suitable_machining_method') else self.env['maintenance.equipment.image']._get_ids(
item['suitable_machining_method']),
"blade_tip_characteristics_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['blade_tip_characteristics'])]).id,
"handle_type_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['handle_type'])]).id,
"cutting_direction_ids": [(6, 0, [])] if not item.get('cutting_direction') else self.env[
'maintenance.equipment.image']._get_ids(item['cutting_direction']),
"suitable_coolant_ids": [(6, 0, [])] if not item.get('suitable_coolant') else self.env[
'maintenance.equipment.image']._get_ids(item['suitable_coolant']),
"compaction_way_id": self.env['maintenance.equipment.image'].search(
[('name', '=', item['compaction_way'])]).id,
"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'])
logging.info(result)
if result['status'] == 1:
if 'basic_parameters_integral_tool' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_integral_tool']:
basic_parameters_integral_tool_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_integral_tool'])
if basic_parameters_integral_tool_list:
for integral_tool_item in basic_parameters_integral_tool_list:
integral_tool = self.search(
[('code', '=', integral_tool_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'tip_r_size': integral_tool_item['tip_r_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.search([('code', '=', integral_tool_item['code'])]).write({
'name': integral_tool_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[(
'code', '=',
integral_tool_item['standard_library_code'])]).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'],
'tip_r_size': integral_tool_item['tip_r_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'],
})
if 'basic_parameters_blade' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_blade']:
basic_parameters_blade_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_blade'])
if basic_parameters_blade_list:
for blade_item in basic_parameters_blade_list:
blade = self.search([('code', '=', blade_item['code']), ('active', 'in', [True, False])])
if not 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'])]).id,
'length': blade_item['length'],
'thickness': blade_item['thickness'],
'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'],
'chip_breaker_type_code': blade_item['chip_breaker_type_code'],
'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'],
'thread_model': '无' if not blade_item['thread_type'] else blade_item[
'thread_type'],
'thread_num': blade_item['threads_per_inch'],
'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.search([('code', '=', blade_item['code'])]).write({
'name': blade_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', blade_item['standard_library_code'])]).id,
'length': blade_item['length'],
'thickness': blade_item['thickness'],
'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'],
'chip_breaker_type_code': blade_item['chip_breaker_type_code'],
'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'],
'thread_model': '无' if not blade_item['thread_type'] else blade_item[
'thread_type'],
'thread_num': blade_item['threads_per_inch'],
'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'],
})
if 'basic_parameters_chuck' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_chuck']:
basic_parameters_chuck_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_chuck'])
if basic_parameters_chuck_list:
for chuck_item in basic_parameters_chuck_list:
chuck = self.search([('code', '=', chuck_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'cooling_jacket': chuck_item['cooling_sleeve_model'],
'active': chuck_item['active'],
})
else:
self.search([('code', '=', chuck_item['code'])]).write({
'name': chuck_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', chuck_item['standard_library_code'])]).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'],
'cooling_jacket': chuck_item['cooling_sleeve_model'],
'active': chuck_item['active'],
})
if 'basic_parameters_cutter_arbor' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_cutter_arbor']:
basic_parameters_cutter_arbor_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_cutter_arbor'])
if basic_parameters_cutter_arbor_list:
for cutter_arbor_item in basic_parameters_cutter_arbor_list:
cutter_arbor = self.search(
[('code', '=', cutter_arbor_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
'locating_slot_code': cutter_arbor_item['locator_slot_code'],
'installing_structure': cutter_arbor_item['mounting_structure'],
'blade_id': False if not cutter_arbor_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_arbor_item['fit_blade_model_code'])]).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.search([('code', '=', cutter_arbor_item['code'])]).write({
'name': cutter_arbor_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_arbor_item['standard_library_code'])]).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'],
'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
'locating_slot_code': cutter_arbor_item['locator_slot_code'],
'installing_structure': cutter_arbor_item['mounting_structure'],
'blade_id': False if not cutter_arbor_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_arbor_item['fit_blade_model_code'])]).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'],
})
if 'basic_parameters_cutter_head' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_cutter_head']:
basic_parameters_cutter_head_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_cutter_head'])
if basic_parameters_cutter_head_list:
for cutter_head_item in basic_parameters_cutter_head_list:
cutter_head = self.search(
[('code', '=', cutter_head_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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_blade_length': cutter_head_item['cutting_blade_length'],
'cut_depth_max': cutter_head_item['cutting_depth_max'],
'main_included_angle': cutter_head_item['edge_angle'],
'installing_structure': cutter_head_item['mounting_structure'],
'blade_id': False if not cutter_head_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_head_item['fit_blade_model_code'])]).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.search([('code', '=', cutter_head_item['code'])]).write({
'name': cutter_head_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_head_item['standard_library_code'])]).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_blade_length': cutter_head_item['cutting_blade_length'],
'cut_depth_max': cutter_head_item['cutting_depth_max'],
'main_included_angle': cutter_head_item['edge_angle'],
'installing_structure': cutter_head_item['mounting_structure'],
'blade_id': False if not cutter_head_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_head_item['fit_blade_model_code'])]).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'],
})
if 'basic_parameters_knife_handle' in result['cutting_tool_basic_parameters_all_list']:
if result['cutting_tool_basic_parameters_all_list']['basic_parameters_knife_handle']:
basic_parameters_knife_handle_list = json.loads(
result['cutting_tool_basic_parameters_all_list']['basic_parameters_knife_handle'])
if basic_parameters_knife_handle_list:
for knife_handle_item in basic_parameters_knife_handle_list:
knife_handle = self.search(
[('code', '=', knife_handle_item['code']), ('active', 'in', [True, False])])
val = {
'name': knife_handle_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', knife_handle_item['standard_library_code'])]).id,
'taper_shank_model': knife_handle_item['taper_shank_model'],
'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'],
'fit_chuck_size': knife_handle_item['fit_chuck_size'],
'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'],
'active': knife_handle_item['active'],
}
if not knife_handle:
val['code'] = knife_handle_item['code']
val['cutting_tool_type'] = '刀柄'
self.create(val)
else:
self.search([('code', '=', knife_handle_item['code'])]).write(val)
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:
if 'basic_parameters_integral_tool' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_integral_tool']:
cutting_tool_basic_parameters_yesterday_list= result['cutting_tool_basic_parameters_yesterday_list']
basic_parameters_integral_tool_list = cutting_tool_basic_parameters_yesterday_list['basic_parameters_integral_tool']
if basic_parameters_integral_tool_list:
for integral_tool_item in basic_parameters_integral_tool_list:
integral_tool = self.search(
[('code', '=', integral_tool_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'tip_r_size': integral_tool_item['tip_r_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:
integral_tool.write({
'name': integral_tool_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[(
'code', '=',
integral_tool_item['standard_library_code'])]).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'],
'tip_r_size': integral_tool_item['tip_r_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'],
})
if 'basic_parameters_blade' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_blade']:
basic_parameters_blade_list = json.loads(
result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_blade'])
if basic_parameters_blade_list:
for blade_item in basic_parameters_blade_list:
blade = self.search([('code', '=', blade_item['code']), ('active', 'in', [True, False])])
if not 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'])]).id,
'length': blade_item['length'],
'thickness': blade_item['thickness'],
'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'],
'chip_breaker_type_code': blade_item['chip_breaker_type_code'],
'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'],
'thread_model': '无' if not blade_item['thread_type'] else blade_item[
'thread_type'],
'thread_num': blade_item['threads_per_inch'],
'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:
blade.write({
'name': blade_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', blade_item['standard_library_code'])]).id,
'length': blade_item['length'],
'thickness': blade_item['thickness'],
'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'],
'chip_breaker_type_code': blade_item['chip_breaker_type_code'],
'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'],
'thread_model': '无' if not blade_item['thread_type'] else blade_item[
'thread_type'],
'thread_num': blade_item['threads_per_inch'],
'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']
})
if 'basic_parameters_chuck' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_chuck']:
basic_parameters_chuck_list = json.loads(
result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_chuck'])
if basic_parameters_chuck_list:
for chuck_item in basic_parameters_chuck_list:
chuck = self.search([('code', '=', chuck_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'cooling_jacket': chuck_item['cooling_sleeve_model'],
'active': chuck_item['active'],
})
else:
chuck.write({
'name': chuck_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', chuck_item['standard_library_code'])]).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'],
'cooling_jacket': chuck_item['cooling_sleeve_model'],
'active': chuck_item['active']
})
if 'basic_parameters_cutter_arbor' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_cutter_arbor']:
basic_parameters_cutter_arbor_list = json.loads(
result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_cutter_arbor'])
if basic_parameters_cutter_arbor_list:
for cutter_arbor_item in basic_parameters_cutter_arbor_list:
cutter_arbor = self.search(
[('code', '=', cutter_arbor_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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'],
'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
'locating_slot_code': cutter_arbor_item['locator_slot_code'],
'installing_structure': cutter_arbor_item['mounting_structure'],
'blade_id': False if not cutter_arbor_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_arbor_item['fit_blade_model_code'])]).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:
cutter_arbor.write({
'name': cutter_arbor_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_arbor_item['standard_library_code'])]).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'],
'is_cooling_hole': cutter_arbor_item['is_cooling_hole'],
'locating_slot_code': cutter_arbor_item['locator_slot_code'],
'installing_structure': cutter_arbor_item['mounting_structure'],
'blade_id': False if not cutter_arbor_item['fit_blade_model_code'] else
self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=',
cutter_arbor_item['fit_blade_model_code'])]).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']
})
if 'basic_parameters_cutter_head' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_cutter_head']:
basic_parameters_cutter_head_list = result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_cutter_head']
if basic_parameters_cutter_head_list:
for cutter_head_item in basic_parameters_cutter_head_list:
cutter_head = self.search(
[('code', '=', cutter_head_item['code']), ('active', 'in', [True, False])])
if not 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'])]).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_blade_length': cutter_head_item['cutting_blade_length'],
'cut_depth_max': cutter_head_item['cutting_depth_max'],
'main_included_angle': cutter_head_item['edge_angle'],
'installing_structure': cutter_head_item['mounting_structure'],
'blade_id': False if not cutter_head_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_head_item['fit_blade_model_code'])]).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:
cutter_head.write({
'name': cutter_head_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', cutter_head_item['standard_library_code'])]).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_blade_length': cutter_head_item['cutting_blade_length'],
'cut_depth_max': cutter_head_item['cutting_depth_max'],
'main_included_angle': cutter_head_item['edge_angle'],
'installing_structure': cutter_head_item['mounting_structure'],
'blade_id': False if not cutter_head_item['fit_blade_model_code'] else self.env[
'sf.cutting_tool.standard.library'].search(
[('code', '=',
cutter_head_item['fit_blade_model_code'])]).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']
})
if 'basic_parameters_knife_handle' in result['cutting_tool_basic_parameters_yesterday_list']:
if result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_knife_handle']:
basic_parameters_knife_handle_list = json.loads(
result['cutting_tool_basic_parameters_yesterday_list']['basic_parameters_knife_handle'])
if basic_parameters_knife_handle_list:
for knife_handle_item in basic_parameters_knife_handle_list:
knife_handle = self.search(
[('code', '=', knife_handle_item['code']), ('active', 'in', [True, False])])
if not 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'])]).id,
'total_length': knife_handle_item['total_length'],
'taper_shank_model': knife_handle_item['taper_shank_model'],
'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'],
'fit_chuck_size': knife_handle_item['fit_chuck_size'],
'screw': knife_handle_item['fit_wrench_model'],
'nut': knife_handle_item['fit_nut_model'],
'dynamic_balance_class': knife_handle_item['dynamic_balance_class'],
'active': knife_handle_item['active'],
})
else:
knife_handle.write({
'name': knife_handle_item['name'],
'standard_library_id': self.env['sf.cutting_tool.standard.library'].search(
[('code', '=', knife_handle_item['standard_library_code'])]).id,
'total_length': knife_handle_item['total_length'],
'taper_shank_model': knife_handle_item['taper_shank_model'],
'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'],
'fit_chuck_size': knife_handle_item['fit_chuck_size'],
'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'],
'active': knife_handle_item['active']
})
else:
raise ValidationError("刀具物料基本参数认证未通过")
class MachiningAccuracySync(models.Model):
_inherit = 'sf.machining.accuracy'
_description = '加工精度'
url = '/api/machining_accuracy/list'
def sync_machining_accuracy_all(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'])
# _logger.info('加工精度:%s' % result)
if result['status'] == 1:
machining_accuracy_all_list = result['machining_accuracy_all_list']
# 获取同步的id集合
ids = [obj['id'] for obj in machining_accuracy_all_list]
self.env['sf.machining.accuracy'].sudo().search(
[('sync_id', 'not in', ids)]).unlink()
for time in machining_accuracy_all_list:
machining_accuracy = self.env['sf.machining.accuracy'].sudo().search(
[('sync_id', '=', time['id'])])
if machining_accuracy:
machining_accuracy.name = time['name']
machining_accuracy.standard_tolerance = time['standard_tolerance']
else:
self.env['sf.machining.accuracy'].sudo().create({
"sync_id": time['id'],
"name": time['name'],
"standard_tolerance": time['standard_tolerance'],
})
class EmbryoRedundancySync(models.Model):
_inherit = 'sf.embryo.redundancy'
_description = '坯料冗余'
url = '/api/embryo_redundancy/list'
def sync_embryo_redundancy_all(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'])
# _logger.info('加工精度:%s' % result)
if result['status'] == 1:
embryo_redundancy_all_list = result['embryo_redundancy_all_list']
# 获取同步的id集合
codes = [obj['code'] for obj in embryo_redundancy_all_list]
self.env['sf.embryo.redundancy'].sudo().search(
[('code', 'not in', codes)]).unlink()
for item in embryo_redundancy_all_list:
embryo_redundancy = self.env['sf.embryo.redundancy'].sudo().search(
[('code', '=', item['code'])])
if embryo_redundancy:
embryo_redundancy.name = item['name']
embryo_redundancy.code = item['code']
embryo_redundancy.long = item['long']
embryo_redundancy.width = item['width']
embryo_redundancy.height = item['height']
embryo_redundancy.active = item['active']
else:
self.env['sf.embryo.redundancy'].sudo().create({
"name": item['name'],
"code": item['code'],
"long": item['long'],
"width": item['width'],
"height": item['height'],
"active": item['active'],
})
Reference in New Issue View Git Blame Copy Permalink