2019-08-29 18:47:58 +02:00
|
|
|
# This file is part of lims_industry module for Tryton.
|
|
|
|
# The COPYRIGHT file at the top level of this repository contains
|
|
|
|
# the full copyright notices and license terms.
|
|
|
|
|
2019-09-30 22:28:50 +02:00
|
|
|
from trytond.model import ModelSQL, ModelView, fields, Unique
|
2019-09-04 23:06:00 +02:00
|
|
|
from trytond.pool import Pool
|
2020-11-18 15:54:04 +01:00
|
|
|
from trytond.pyson import Eval, If
|
2019-09-21 00:12:45 +02:00
|
|
|
from trytond.transaction import Transaction
|
2021-04-06 23:30:16 +02:00
|
|
|
from trytond.exceptions import UserError
|
|
|
|
from trytond.i18n import gettext
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
class Plant(ModelSQL, ModelView):
|
|
|
|
'Plant'
|
|
|
|
__name__ = 'lims.plant'
|
|
|
|
|
|
|
|
party = fields.Many2One('party.party', 'Party', required=True,
|
2020-07-03 05:12:59 +02:00
|
|
|
ondelete='CASCADE', select=True)
|
2019-08-29 18:47:58 +02:00
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
street = fields.Char('Street', required=True)
|
|
|
|
zip = fields.Char('Zip', required=True)
|
|
|
|
city = fields.Char('City', required=True)
|
|
|
|
subdivision = fields.Many2One('country.subdivision',
|
|
|
|
'Subdivision', required=True, domain=[
|
|
|
|
('country', '=', Eval('country', -1)),
|
|
|
|
('parent', '=', None),
|
|
|
|
],
|
|
|
|
depends=['country'])
|
|
|
|
country = fields.Many2One('country.country', 'Country',
|
|
|
|
required=True)
|
|
|
|
equipments = fields.One2Many('lims.equipment', 'plant',
|
|
|
|
'Equipments')
|
|
|
|
contacts = fields.One2Many('party.address', 'plant',
|
|
|
|
'Contacts', domain=[('party', '=', Eval('party'))],
|
|
|
|
depends=['party'])
|
|
|
|
invoice_party = fields.Many2One('party.party', 'Invoice Party')
|
|
|
|
latitude = fields.Numeric('Latitude', digits=(3, 14))
|
|
|
|
longitude = fields.Numeric('Longitude', digits=(4, 14))
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2019-08-29 18:47:58 +02:00
|
|
|
cls._order.insert(0, ('party', 'ASC'))
|
|
|
|
cls._order.insert(1, ('name', 'ASC'))
|
2019-09-30 22:28:50 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('name_unique', Unique(t, t.party, t.name),
|
|
|
|
'lims_industry.msg_plant_name_unique'),
|
|
|
|
]
|
2019-08-29 18:47:58 +02:00
|
|
|
|
2019-09-21 00:12:45 +02:00
|
|
|
@staticmethod
|
|
|
|
def default_country():
|
|
|
|
Company = Pool().get('company.company')
|
|
|
|
company_id = Transaction().context.get('company')
|
|
|
|
if company_id:
|
|
|
|
address = Company(company_id).party.address_get()
|
|
|
|
if address and address.country:
|
|
|
|
return address.country.id
|
|
|
|
|
2020-11-18 15:52:35 +01:00
|
|
|
def get_rec_name(self, name):
|
|
|
|
res = '%s [%s]' % (self.name, self.party.name)
|
|
|
|
return res
|
|
|
|
|
2019-09-30 22:28:50 +02:00
|
|
|
@classmethod
|
2021-07-23 15:14:58 +02:00
|
|
|
def copy(cls, records, default=None):
|
2019-09-30 22:28:50 +02:00
|
|
|
if default is None:
|
|
|
|
default = {}
|
2021-07-23 15:14:58 +02:00
|
|
|
current_default = default.copy()
|
|
|
|
current_default['equipments'] = None
|
2019-09-30 22:28:50 +02:00
|
|
|
|
2021-07-23 15:14:58 +02:00
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['name'] = '%s (copy)' % record.name
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
2019-09-30 22:28:50 +02:00
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class EquipmentType(ModelSQL, ModelView):
|
|
|
|
'Equipment Type'
|
|
|
|
__name__ = 'lims.equipment.type'
|
|
|
|
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
|
2020-06-14 19:25:55 +02:00
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2020-06-14 19:25:55 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('name_unique', Unique(t, t.name),
|
|
|
|
'lims_industry.msg_equipment_type_name_unique'),
|
|
|
|
]
|
|
|
|
|
2021-07-23 15:14:58 +02:00
|
|
|
@classmethod
|
|
|
|
def copy(cls, records, default=None):
|
|
|
|
if default is None:
|
|
|
|
default = {}
|
|
|
|
current_default = default.copy()
|
|
|
|
|
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['name'] = '%s (copy)' % record.name
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class Brand(ModelSQL, ModelView):
|
|
|
|
'Brand'
|
|
|
|
__name__ = 'lims.brand'
|
|
|
|
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
|
2020-06-14 19:25:55 +02:00
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2020-06-14 19:25:55 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('name_unique', Unique(t, t.name),
|
|
|
|
'lims_industry.msg_brand_name_unique'),
|
|
|
|
]
|
|
|
|
|
2021-07-23 15:14:58 +02:00
|
|
|
@classmethod
|
|
|
|
def copy(cls, records, default=None):
|
|
|
|
if default is None:
|
|
|
|
default = {}
|
|
|
|
current_default = default.copy()
|
|
|
|
|
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['name'] = '%s (copy)' % record.name
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class ComponentType(ModelSQL, ModelView):
|
|
|
|
'Component Type'
|
|
|
|
__name__ = 'lims.component.type'
|
|
|
|
|
|
|
|
name = fields.Char('Name', required=True)
|
2019-11-13 22:01:19 +01:00
|
|
|
product_type = fields.Many2One('lims.product.type', 'Product type',
|
|
|
|
required=True)
|
2019-08-29 18:47:58 +02:00
|
|
|
|
2020-06-14 19:25:55 +02:00
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2020-06-14 19:25:55 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('name_unique', Unique(t, t.name),
|
|
|
|
'lims_industry.msg_component_type_name_unique'),
|
|
|
|
]
|
|
|
|
|
2021-07-23 15:14:58 +02:00
|
|
|
@classmethod
|
|
|
|
def copy(cls, records, default=None):
|
|
|
|
if default is None:
|
|
|
|
default = {}
|
|
|
|
current_default = default.copy()
|
|
|
|
|
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['name'] = '%s (copy)' % record.name
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class EquipmentTemplate(ModelSQL, ModelView):
|
|
|
|
'Equipment Template'
|
|
|
|
__name__ = 'lims.equipment.template'
|
|
|
|
|
|
|
|
type = fields.Many2One('lims.equipment.type', 'Type', required=True)
|
|
|
|
brand = fields.Many2One('lims.brand', 'Brand', required=True)
|
2019-09-04 23:06:00 +02:00
|
|
|
model = fields.Char('Model')
|
2019-08-29 18:47:58 +02:00
|
|
|
power = fields.Char('Power')
|
|
|
|
component_types = fields.Many2Many(
|
|
|
|
'lims.equipment.template-component.type',
|
|
|
|
'template', 'type', 'Component types')
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2019-08-29 18:47:58 +02:00
|
|
|
cls._order.insert(0, ('type', 'ASC'))
|
|
|
|
cls._order.insert(1, ('brand', 'ASC'))
|
|
|
|
cls._order.insert(2, ('model', 'ASC'))
|
2020-06-14 19:25:55 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('type_brand_model_unique', Unique(t, t.type, t.brand, t.model),
|
|
|
|
'lims_industry.msg_equipment_template_unique'),
|
|
|
|
]
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
def get_rec_name(self, name):
|
2019-09-04 23:06:00 +02:00
|
|
|
res = '%s - %s' % (self.type.rec_name, self.brand.rec_name)
|
|
|
|
if self.model:
|
|
|
|
res += ' - ' + self.model
|
|
|
|
return res
|
2019-08-29 18:47:58 +02:00
|
|
|
|
2019-09-21 00:14:46 +02:00
|
|
|
@classmethod
|
|
|
|
def search_rec_name(cls, name, clause):
|
|
|
|
return ['OR',
|
|
|
|
('type.name',) + tuple(clause[1:]),
|
|
|
|
('brand.name',) + tuple(clause[1:]),
|
|
|
|
('model',) + tuple(clause[1:]),
|
|
|
|
]
|
|
|
|
|
2021-07-16 22:41:07 +02:00
|
|
|
@classmethod
|
2021-07-23 15:14:58 +02:00
|
|
|
def copy(cls, records, default=None):
|
2021-07-16 22:41:07 +02:00
|
|
|
if default is None:
|
|
|
|
default = {}
|
2021-07-23 15:14:58 +02:00
|
|
|
current_default = default.copy()
|
2021-07-16 22:41:07 +02:00
|
|
|
|
2021-07-23 15:14:58 +02:00
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['model'] = '%s (copy)' % record.model
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
2021-07-16 22:41:07 +02:00
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class EquipmentTemplateComponentType(ModelSQL):
|
|
|
|
'Equipment Template - Component Type'
|
|
|
|
__name__ = 'lims.equipment.template-component.type'
|
|
|
|
_table = 'lims_equipment_template_component_type'
|
|
|
|
|
|
|
|
template = fields.Many2One('lims.equipment.template', 'Template',
|
|
|
|
required=True, ondelete='CASCADE', select=True)
|
|
|
|
type = fields.Many2One('lims.component.type', 'Type',
|
|
|
|
required=True, ondelete='CASCADE', select=True)
|
|
|
|
|
|
|
|
|
|
|
|
class Equipment(ModelSQL, ModelView):
|
|
|
|
'Equipment'
|
|
|
|
__name__ = 'lims.equipment'
|
|
|
|
|
|
|
|
template = fields.Many2One('lims.equipment.template', 'Template',
|
|
|
|
required=True)
|
|
|
|
name = fields.Char('Name', required=True)
|
2020-07-17 02:58:32 +02:00
|
|
|
type = fields.Function(fields.Many2One('lims.equipment.type', 'Type'),
|
|
|
|
'get_type', searcher='search_type')
|
2019-09-21 00:15:59 +02:00
|
|
|
brand = fields.Function(fields.Many2One('lims.brand', 'Brand'),
|
|
|
|
'get_brand', searcher='search_brand')
|
2019-09-04 23:06:00 +02:00
|
|
|
model = fields.Char('Model', required=True)
|
2019-09-23 15:10:13 +02:00
|
|
|
power = fields.Char('Power')
|
2021-07-15 01:07:56 +02:00
|
|
|
voltage = fields.Char('Primary Voltage')
|
|
|
|
voltage_secondary = fields.Char('Secondary Voltage')
|
|
|
|
amperage = fields.Char('Secondary Amperage')
|
2019-08-29 18:47:58 +02:00
|
|
|
serial_number = fields.Char('Serial number')
|
|
|
|
internal_id = fields.Char('Internal ID Code')
|
|
|
|
latitude = fields.Numeric('Latitude', digits=(3, 14))
|
|
|
|
longitude = fields.Numeric('Longitude', digits=(4, 14))
|
|
|
|
plant = fields.Many2One('lims.plant', 'Plant',
|
2020-11-18 15:54:04 +01:00
|
|
|
required=True, select=True,
|
|
|
|
domain=[If(Eval('context', {}).contains('party'),
|
|
|
|
('party', '=', Eval('context', {}).get('party', -1)),
|
|
|
|
())])
|
2019-08-29 18:47:58 +02:00
|
|
|
components = fields.One2Many('lims.component', 'equipment',
|
|
|
|
'Components')
|
|
|
|
year_manufacturing = fields.Integer('Year of manufacturing')
|
2021-07-15 01:07:56 +02:00
|
|
|
year_service_start = fields.Integer('Year of service start')
|
2019-08-29 18:47:58 +02:00
|
|
|
internal_location = fields.Char('Internal location')
|
|
|
|
contacts = fields.One2Many('party.address', 'equipment',
|
|
|
|
'Contacts', domain=[('party', '=', Eval('party'))],
|
2019-09-21 00:13:53 +02:00
|
|
|
context={'plant': Eval('plant')},
|
|
|
|
depends=['party', 'plant'])
|
2019-08-29 18:47:58 +02:00
|
|
|
party = fields.Function(fields.Many2One('party.party', 'Party'),
|
|
|
|
'get_party', searcher='search_party')
|
2019-09-04 23:06:00 +02:00
|
|
|
missing_data = fields.Boolean('Missing data')
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2019-08-29 18:47:58 +02:00
|
|
|
cls._order.insert(0, ('template', 'ASC'))
|
|
|
|
cls._order.insert(1, ('name', 'ASC'))
|
2019-09-30 22:28:50 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
|
|
|
('name_unique', Unique(t, t.plant, t.name),
|
|
|
|
'lims_industry.msg_equipment_name_unique'),
|
|
|
|
]
|
2019-08-29 18:47:58 +02:00
|
|
|
|
2019-11-13 22:00:43 +01:00
|
|
|
@classmethod
|
|
|
|
def create(cls, vlist):
|
|
|
|
TaskTemplate = Pool().get('lims.administrative.task.template')
|
2020-08-06 19:52:36 +02:00
|
|
|
equipments = super().create(vlist)
|
2019-11-13 22:00:43 +01:00
|
|
|
TaskTemplate.create_tasks('equipment_missing_data',
|
|
|
|
cls._for_task_missing_data(equipments))
|
|
|
|
return equipments
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _for_task_missing_data(cls, equipments):
|
|
|
|
AdministrativeTask = Pool().get('lims.administrative.task')
|
|
|
|
res = []
|
|
|
|
for equipment in equipments:
|
|
|
|
if not equipment.missing_data:
|
|
|
|
continue
|
|
|
|
if AdministrativeTask.search([
|
|
|
|
('type', '=', 'equipment_missing_data'),
|
|
|
|
('origin', '=', '%s,%s' % (cls.__name__, equipment.id)),
|
|
|
|
('state', 'not in', ('done', 'discarded')),
|
|
|
|
]):
|
|
|
|
continue
|
|
|
|
res.append(equipment)
|
|
|
|
return res
|
|
|
|
|
2020-06-26 02:33:43 +02:00
|
|
|
def get_rec_name(self, name):
|
2020-06-26 02:26:54 +02:00
|
|
|
res = '%s [%s]' % (self.name, self.plant.name)
|
|
|
|
return res
|
|
|
|
|
2020-11-11 00:00:04 +01:00
|
|
|
@classmethod
|
|
|
|
def search_rec_name(cls, name, clause):
|
|
|
|
return ['OR',
|
|
|
|
('name',) + tuple(clause[1:]),
|
|
|
|
('serial_number',) + tuple(clause[1:]),
|
2020-11-18 16:26:39 +01:00
|
|
|
('brand.name',) + tuple(clause[1:]),
|
|
|
|
('plant.name',) + tuple(clause[1:]),
|
2021-09-17 14:15:42 +02:00
|
|
|
('components.customer_description',) + tuple(clause[1:]),
|
2020-11-11 00:00:04 +01:00
|
|
|
]
|
|
|
|
|
2020-03-05 05:24:51 +01:00
|
|
|
@fields.depends('plant', '_parent_plant.party')
|
2019-10-07 16:01:57 +02:00
|
|
|
def on_change_with_party(self, name=None):
|
|
|
|
return self.get_party([self], name)[self.id]
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def get_party(cls, equipments, name):
|
|
|
|
result = {}
|
|
|
|
for e in equipments:
|
|
|
|
result[e.id] = e.plant and e.plant.party.id or None
|
|
|
|
return result
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_party(cls, name, clause):
|
|
|
|
return [('plant.party',) + tuple(clause[1:])]
|
|
|
|
|
2020-07-17 02:58:32 +02:00
|
|
|
@fields.depends('template', '_parent_template.type')
|
|
|
|
def on_change_with_type(self, name=None):
|
|
|
|
return self.get_type([self], name)[self.id]
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def get_type(cls, equipments, name):
|
|
|
|
result = {}
|
|
|
|
for e in equipments:
|
|
|
|
result[e.id] = e.template and e.template.type.id or None
|
|
|
|
return result
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_type(cls, name, clause):
|
|
|
|
return [('template.type',) + tuple(clause[1:])]
|
|
|
|
|
2020-03-05 05:24:51 +01:00
|
|
|
@fields.depends('template', '_parent_template.brand')
|
2019-10-07 16:01:57 +02:00
|
|
|
def on_change_with_brand(self, name=None):
|
|
|
|
return self.get_brand([self], name)[self.id]
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def get_brand(cls, equipments, name):
|
|
|
|
result = {}
|
|
|
|
for e in equipments:
|
|
|
|
result[e.id] = e.template and e.template.brand.id or None
|
|
|
|
return result
|
2019-09-21 00:15:59 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_brand(cls, name, clause):
|
|
|
|
return [('template.brand',) + tuple(clause[1:])]
|
|
|
|
|
2020-12-31 00:03:30 +01:00
|
|
|
@fields.depends('template', 'components')
|
2019-09-04 23:06:00 +02:00
|
|
|
def on_change_template(self):
|
|
|
|
pool = Pool()
|
|
|
|
Component = pool.get('lims.component')
|
|
|
|
|
2020-12-31 00:03:30 +01:00
|
|
|
if not self.template:
|
|
|
|
return
|
|
|
|
current_components_ids = [component.type.id
|
|
|
|
for component in self.components]
|
|
|
|
components = list(self.components)
|
|
|
|
for type in self.template.component_types:
|
|
|
|
if type.id in current_components_ids:
|
|
|
|
continue
|
|
|
|
value = Component(**Component.default_get(
|
|
|
|
list(Component._fields.keys()), with_rec_name=False))
|
|
|
|
value.type = type.id
|
|
|
|
components.append(value)
|
|
|
|
self.model = self.template.model
|
|
|
|
self.power = self.template.power
|
2019-09-04 23:06:00 +02:00
|
|
|
self.components = components
|
|
|
|
|
2019-09-30 22:28:50 +02:00
|
|
|
@classmethod
|
2021-07-23 15:14:58 +02:00
|
|
|
def copy(cls, records, default=None):
|
2019-09-30 22:28:50 +02:00
|
|
|
if default is None:
|
|
|
|
default = {}
|
2021-07-23 15:14:58 +02:00
|
|
|
current_default = default.copy()
|
|
|
|
|
|
|
|
new_records = []
|
|
|
|
for record in records:
|
|
|
|
current_default['name'] = '%s (copy)' % record.name
|
|
|
|
new_record, = super().copy([record], default=current_default)
|
|
|
|
new_records.append(new_record)
|
|
|
|
return new_records
|
2019-09-30 22:28:50 +02:00
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
class Component(ModelSQL, ModelView):
|
|
|
|
'Component'
|
|
|
|
__name__ = 'lims.component'
|
|
|
|
|
|
|
|
equipment = fields.Many2One('lims.equipment', 'Equipment',
|
2019-11-13 22:01:19 +01:00
|
|
|
required=True, ondelete='CASCADE', select=True)
|
2019-08-29 18:47:58 +02:00
|
|
|
type = fields.Many2One('lims.component.type', 'Type',
|
2019-09-04 23:06:00 +02:00
|
|
|
required=True)
|
2019-11-13 22:01:19 +01:00
|
|
|
product_type = fields.Function(fields.Many2One('lims.product.type',
|
|
|
|
'Product type'), 'get_product_type')
|
|
|
|
comercial_product = fields.Many2One('lims.comercial.product',
|
|
|
|
'Comercial product')
|
2019-08-29 18:47:58 +02:00
|
|
|
capacity = fields.Char('Capacity (lts)')
|
|
|
|
serial_number = fields.Char('Serial number')
|
|
|
|
model = fields.Char('Model')
|
|
|
|
power = fields.Char('Power')
|
|
|
|
brand = fields.Many2One('lims.brand', 'Brand')
|
|
|
|
internal_id = fields.Char('Internal ID Code')
|
|
|
|
customer_description = fields.Char('Customer description')
|
|
|
|
year_manufacturing = fields.Integer('Year of manufacturing')
|
2019-09-30 22:25:28 +02:00
|
|
|
plant = fields.Function(fields.Many2One('lims.plant', 'Plant'),
|
|
|
|
'get_plant', searcher='search_plant')
|
2019-08-29 18:47:58 +02:00
|
|
|
party = fields.Function(fields.Many2One('party.party', 'Party'),
|
|
|
|
'get_party', searcher='search_party')
|
2019-11-13 22:00:43 +01:00
|
|
|
missing_data = fields.Boolean('Missing data')
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def __setup__(cls):
|
2020-08-06 19:52:36 +02:00
|
|
|
super().__setup__()
|
2019-08-29 18:47:58 +02:00
|
|
|
cls._order.insert(0, ('equipment', 'ASC'))
|
|
|
|
cls._order.insert(1, ('type', 'ASC'))
|
2019-09-30 22:28:50 +02:00
|
|
|
t = cls.__table__()
|
|
|
|
cls._sql_constraints = [
|
2020-12-23 20:10:43 +01:00
|
|
|
('type_description_unique', Unique(t, t.equipment, t.type,
|
|
|
|
t.customer_description),
|
|
|
|
'lims_industry.msg_component_unique'),
|
2019-09-30 22:28:50 +02:00
|
|
|
]
|
2019-08-29 18:47:58 +02:00
|
|
|
|
2021-06-07 16:04:21 +02:00
|
|
|
@classmethod
|
|
|
|
def __register__(cls, module_name):
|
|
|
|
super().__register__(module_name)
|
|
|
|
table = cls.__table_handler__(module_name)
|
|
|
|
table.drop_constraint('type_unique')
|
|
|
|
|
2019-11-13 22:00:43 +01:00
|
|
|
@classmethod
|
|
|
|
def create(cls, vlist):
|
|
|
|
TaskTemplate = Pool().get('lims.administrative.task.template')
|
2020-08-06 19:52:36 +02:00
|
|
|
components = super().create(vlist)
|
2019-11-13 22:00:43 +01:00
|
|
|
TaskTemplate.create_tasks('component_missing_data',
|
|
|
|
cls._for_task_missing_data(components))
|
|
|
|
return components
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _for_task_missing_data(cls, components):
|
|
|
|
AdministrativeTask = Pool().get('lims.administrative.task')
|
|
|
|
res = []
|
|
|
|
for component in components:
|
|
|
|
if not component.missing_data:
|
|
|
|
continue
|
|
|
|
if AdministrativeTask.search([
|
|
|
|
('type', '=', 'component_missing_data'),
|
|
|
|
('origin', '=', '%s,%s' % (cls.__name__, component.id)),
|
|
|
|
('state', 'not in', ('done', 'discarded')),
|
|
|
|
]):
|
|
|
|
continue
|
|
|
|
res.append(component)
|
|
|
|
return res
|
|
|
|
|
2021-04-06 23:30:16 +02:00
|
|
|
@classmethod
|
|
|
|
def delete(cls, components):
|
|
|
|
cls.check_delete(components)
|
|
|
|
super().delete(components)
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def check_delete(cls, components):
|
|
|
|
Sample = Pool().get('lims.sample')
|
|
|
|
for component in components:
|
|
|
|
samples = Sample.search_count([
|
|
|
|
('component', '=', component.id),
|
|
|
|
])
|
|
|
|
if samples != 0:
|
|
|
|
raise UserError(gettext('lims_industry.msg_delete_component',
|
|
|
|
component=component.get_rec_name(None)))
|
|
|
|
|
2019-08-29 18:47:58 +02:00
|
|
|
def get_rec_name(self, name):
|
|
|
|
res = self.type.rec_name
|
|
|
|
if self.brand:
|
|
|
|
res += ' - ' + self.brand.rec_name
|
|
|
|
if self.model:
|
|
|
|
res += ' - ' + self.model
|
2020-06-26 02:26:54 +02:00
|
|
|
if self.customer_description:
|
|
|
|
res += ' [' + self.customer_description + ']'
|
2019-08-29 18:47:58 +02:00
|
|
|
return res
|
|
|
|
|
2020-11-18 16:26:39 +01:00
|
|
|
@classmethod
|
|
|
|
def search_rec_name(cls, name, clause):
|
|
|
|
return ['OR',
|
|
|
|
('type.name',) + tuple(clause[1:]),
|
|
|
|
('brand.name',) + tuple(clause[1:]),
|
|
|
|
('model',) + tuple(clause[1:]),
|
|
|
|
]
|
|
|
|
|
2019-10-07 16:01:57 +02:00
|
|
|
@classmethod
|
|
|
|
def get_plant(cls, component, name):
|
|
|
|
result = {}
|
|
|
|
for c in component:
|
|
|
|
result[c.id] = c.equipment and c.equipment.plant.id or None
|
|
|
|
return result
|
2019-09-30 22:25:28 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_plant(cls, name, clause):
|
|
|
|
return [('equipment.plant',) + tuple(clause[1:])]
|
|
|
|
|
2019-10-07 16:01:57 +02:00
|
|
|
@classmethod
|
|
|
|
def get_party(cls, component, name):
|
|
|
|
result = {}
|
|
|
|
for c in component:
|
|
|
|
result[c.id] = c.equipment and c.equipment.plant.party.id or None
|
|
|
|
return result
|
2019-08-29 18:47:58 +02:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_party(cls, name, clause):
|
|
|
|
return [('equipment.plant.party',) + tuple(clause[1:])]
|
2019-11-13 22:01:19 +01:00
|
|
|
|
2020-03-05 05:24:51 +01:00
|
|
|
@fields.depends('type', '_parent_type.product_type')
|
2019-11-13 22:01:19 +01:00
|
|
|
def on_change_with_product_type(self, name=None):
|
|
|
|
return self.get_product_type([self], name)[self.id]
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def get_product_type(cls, components, name):
|
|
|
|
result = {}
|
|
|
|
for c in components:
|
|
|
|
result[c.id] = c.type and c.type.product_type.id or None
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
|
|
|
class ComercialProductBrand(ModelSQL, ModelView):
|
|
|
|
'Comercial Product Brand'
|
|
|
|
__name__ = 'lims.comercial.product.brand'
|
|
|
|
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
|
|
|
|
|
|
|
|
class ComercialProduct(ModelSQL, ModelView):
|
|
|
|
'Comercial Product'
|
|
|
|
__name__ = 'lims.comercial.product'
|
|
|
|
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
brand = fields.Many2One('lims.comercial.product.brand', 'Brand',
|
|
|
|
required=True)
|
|
|
|
matrix = fields.Many2One('lims.matrix', 'Base/Matrix', required=True)
|
2020-06-26 02:26:54 +02:00
|
|
|
|
|
|
|
def get_rec_name(self, name):
|
|
|
|
res = '%s %s' % (self.brand.name, self.name)
|
|
|
|
return res
|
2020-11-18 16:26:39 +01:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def search_rec_name(cls, name, clause):
|
|
|
|
return ['OR',
|
|
|
|
('name',) + tuple(clause[1:]),
|
|
|
|
('brand.name',) + tuple(clause[1:]),
|
|
|
|
]
|