666 lines
23 KiB
Python
666 lines
23 KiB
Python
# 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.
|
|
|
|
from trytond.model import ModelSQL, ModelView, DeactivableMixin, fields, Unique
|
|
from trytond.pool import Pool
|
|
from trytond.pyson import Eval, If
|
|
from trytond.transaction import Transaction
|
|
from trytond.exceptions import UserError
|
|
from trytond.i18n import gettext
|
|
from trytond import backend
|
|
|
|
|
|
class Plant(ModelSQL, ModelView):
|
|
'Plant'
|
|
__name__ = 'lims.plant'
|
|
|
|
party = fields.Many2One('party.party', 'Party', required=True,
|
|
ondelete='CASCADE', select=True)
|
|
name = fields.Char('Name', required=True)
|
|
street = fields.Char('Street', required=True)
|
|
postal_code = fields.Char('Postal Code', 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):
|
|
super().__setup__()
|
|
cls._order.insert(0, ('party', 'ASC'))
|
|
cls._order.insert(1, ('name', 'ASC'))
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.party, t.name),
|
|
'lims_industry.msg_plant_name_unique'),
|
|
]
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
table = cls.__table_handler__(module_name)
|
|
table.column_rename('zip', 'postal_code')
|
|
super().__register__(module_name)
|
|
|
|
@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
|
|
|
|
def get_rec_name(self, name):
|
|
res = '%s [%s]' % (self.name, self.party.name)
|
|
return res
|
|
|
|
@classmethod
|
|
def copy(cls, records, default=None):
|
|
if default is None:
|
|
default = {}
|
|
current_default = default.copy()
|
|
current_default['equipments'] = None
|
|
|
|
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
|
|
|
|
|
|
class EquipmentType(ModelSQL, ModelView):
|
|
'Equipment Type'
|
|
__name__ = 'lims.equipment.type'
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.name),
|
|
'lims_industry.msg_equipment_type_name_unique'),
|
|
]
|
|
|
|
@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
|
|
|
|
|
|
class Brand(ModelSQL, ModelView):
|
|
'Brand'
|
|
__name__ = 'lims.brand'
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.name),
|
|
'lims_industry.msg_brand_name_unique'),
|
|
]
|
|
|
|
@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
|
|
|
|
|
|
class ComponentKind(ModelSQL, ModelView):
|
|
'Component Kind'
|
|
__name__ = 'lims.component.kind'
|
|
|
|
name = fields.Char('Name', required=True)
|
|
product_type = fields.Many2One('lims.product.type', 'Product type',
|
|
required=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.name),
|
|
'lims_industry.msg_component_kind_name_unique'),
|
|
]
|
|
|
|
@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
|
|
|
|
|
|
class ComponentLocation(ModelSQL, ModelView):
|
|
'Component Location'
|
|
__name__ = 'lims.component.location'
|
|
|
|
name = fields.Char('Name', required=True)
|
|
|
|
|
|
class ComponentType(ModelSQL, ModelView):
|
|
'Component Type'
|
|
__name__ = 'lims.component.type'
|
|
|
|
name = fields.Char('Name', required=True)
|
|
product_type = fields.Many2One('lims.product.type', 'Product type',
|
|
required=True)
|
|
kind = fields.Many2One('lims.component.kind', 'Kind')
|
|
location = fields.Many2One('lims.component.location', 'Location')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.name),
|
|
'lims_industry.msg_component_type_name_unique'),
|
|
]
|
|
|
|
@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
|
|
|
|
|
|
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)
|
|
model = fields.Char('Model')
|
|
power = fields.Char('Power')
|
|
component_kinds = fields.One2Many(
|
|
'lims.equipment.template-component.kind',
|
|
'template', 'Component kinds')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls._order.insert(0, ('type', 'ASC'))
|
|
cls._order.insert(1, ('brand', 'ASC'))
|
|
cls._order.insert(2, ('model', 'ASC'))
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('type_brand_model_unique', Unique(t, t.type, t.brand, t.model),
|
|
'lims_industry.msg_equipment_template_unique'),
|
|
]
|
|
|
|
def get_rec_name(self, name):
|
|
res = '%s - %s' % (self.type.rec_name, self.brand.rec_name)
|
|
if self.model:
|
|
res += ' - ' + self.model
|
|
return res
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
return ['OR',
|
|
('type.name',) + tuple(clause[1:]),
|
|
('brand.name',) + tuple(clause[1:]),
|
|
('model',) + tuple(clause[1:]),
|
|
]
|
|
|
|
@classmethod
|
|
def copy(cls, records, default=None):
|
|
if default is None:
|
|
default = {}
|
|
current_default = default.copy()
|
|
|
|
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
|
|
|
|
|
|
class EquipmentTemplateComponentKind(ModelSQL, ModelView):
|
|
'Equipment Template - Component Kind'
|
|
__name__ = 'lims.equipment.template-component.kind'
|
|
_table = 'lims_equipment_template_component_kind'
|
|
|
|
template = fields.Many2One('lims.equipment.template', 'Template',
|
|
required=True, ondelete='CASCADE', select=True)
|
|
kind = fields.Many2One('lims.component.kind', 'Kind',
|
|
required=True, ondelete='CASCADE', select=True)
|
|
location = fields.Many2One('lims.component.location', 'Location')
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
cursor = Transaction().connection.cursor()
|
|
TableHandler = backend.TableHandler
|
|
sql_table = cls.__table__()
|
|
super().__register__(module_name)
|
|
old_table_name = 'lims_equipment_template_component_type'
|
|
if TableHandler.table_exist(old_table_name):
|
|
cursor.execute('SELECT etct.template, ct.kind, ct.location '
|
|
'FROM lims_equipment_template_component_type etct '
|
|
'INNER JOIN lims_component_type ct '
|
|
'ON ct.id = etct.type '
|
|
'WHERE ct.kind IS NOT NULL')
|
|
res = cursor.fetchall()
|
|
if res:
|
|
cursor.execute(*sql_table.insert(
|
|
columns=[sql_table.template, sql_table.kind,
|
|
sql_table.location],
|
|
values=[[x[0], x[1], x[2]] for x in res]))
|
|
TableHandler.drop_table('', old_table_name)
|
|
|
|
|
|
class Equipment(DeactivableMixin, ModelSQL, ModelView):
|
|
'Equipment'
|
|
__name__ = 'lims.equipment'
|
|
|
|
template = fields.Many2One('lims.equipment.template', 'Template',
|
|
required=True)
|
|
name = fields.Char('Name', required=True)
|
|
type = fields.Function(fields.Many2One('lims.equipment.type', 'Type'),
|
|
'get_type', searcher='search_type')
|
|
brand = fields.Function(fields.Many2One('lims.brand', 'Brand'),
|
|
'get_brand', searcher='search_brand')
|
|
model = fields.Char('Model', required=True)
|
|
power = fields.Char('Power')
|
|
voltage = fields.Char('Primary Voltage')
|
|
voltage_secondary = fields.Char('Secondary Voltage')
|
|
amperage = fields.Char('Secondary Amperage')
|
|
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',
|
|
required=True, select=True,
|
|
domain=[If(Eval('context', {}).contains('party'),
|
|
('party', '=', Eval('context', {}).get('party', -1)),
|
|
())])
|
|
components = fields.One2Many('lims.component', 'equipment',
|
|
'Components')
|
|
year_manufacturing = fields.Integer('Year of manufacturing')
|
|
year_service_start = fields.Integer('Year of service start')
|
|
internal_location = fields.Char('Internal location')
|
|
contacts = fields.One2Many('party.address', 'equipment',
|
|
'Contacts', domain=[('party', '=', Eval('party'))],
|
|
context={'plant': Eval('plant')},
|
|
depends=['party', 'plant'])
|
|
party = fields.Function(fields.Many2One('party.party', 'Party'),
|
|
'get_party', searcher='search_party')
|
|
missing_data = fields.Boolean('Missing data')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls._order.insert(0, ('template', 'ASC'))
|
|
cls._order.insert(1, ('name', 'ASC'))
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('name_unique', Unique(t, t.plant, t.name),
|
|
'lims_industry.msg_equipment_name_unique'),
|
|
]
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
TaskTemplate = Pool().get('lims.administrative.task.template')
|
|
equipments = super().create(vlist)
|
|
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
|
|
|
|
def get_rec_name(self, name):
|
|
res = '%s [%s]' % (self.name, self.plant.name)
|
|
return res
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
return ['OR',
|
|
('name',) + tuple(clause[1:]),
|
|
('serial_number',) + tuple(clause[1:]),
|
|
('brand.name',) + tuple(clause[1:]),
|
|
('plant.name',) + tuple(clause[1:]),
|
|
('components.customer_description',) + tuple(clause[1:]),
|
|
]
|
|
|
|
@fields.depends('plant', '_parent_plant.party')
|
|
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
|
|
|
|
@classmethod
|
|
def search_party(cls, name, clause):
|
|
return [('plant.party',) + tuple(clause[1:])]
|
|
|
|
@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:])]
|
|
|
|
@fields.depends('template', '_parent_template.brand')
|
|
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
|
|
|
|
@classmethod
|
|
def search_brand(cls, name, clause):
|
|
return [('template.brand',) + tuple(clause[1:])]
|
|
|
|
@fields.depends('template', 'components')
|
|
def on_change_template(self):
|
|
pool = Pool()
|
|
Component = pool.get('lims.component')
|
|
|
|
if not self.template:
|
|
return
|
|
current_components_ids = [(component.kind.id,
|
|
component.location and component.location.id or None)
|
|
for component in self.components]
|
|
components = list(self.components)
|
|
for record in self.template.component_kinds:
|
|
kind_id = record.kind.id
|
|
location_id = record.location and record.location.id or None
|
|
if (kind_id, location_id) in current_components_ids:
|
|
continue
|
|
value = Component(**Component.default_get(
|
|
list(Component._fields.keys()), with_rec_name=False))
|
|
value.kind = kind_id
|
|
value.location = location_id
|
|
components.append(value)
|
|
self.model = self.template.model
|
|
self.power = self.template.power
|
|
self.components = components
|
|
|
|
@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
|
|
|
|
|
|
class Component(ModelSQL, ModelView):
|
|
'Component'
|
|
__name__ = 'lims.component'
|
|
|
|
equipment = fields.Many2One('lims.equipment', 'Equipment',
|
|
required=True, ondelete='CASCADE', select=True)
|
|
kind = fields.Many2One('lims.component.kind', 'Kind', required=True)
|
|
location = fields.Many2One('lims.component.location', 'Location')
|
|
product_type = fields.Function(fields.Many2One('lims.product.type',
|
|
'Product type'), 'get_product_type')
|
|
comercial_product = fields.Many2One('lims.comercial.product',
|
|
'Comercial product')
|
|
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')
|
|
plant = fields.Function(fields.Many2One('lims.plant', 'Plant'),
|
|
'get_plant', searcher='search_plant')
|
|
party = fields.Function(fields.Many2One('party.party', 'Party'),
|
|
'get_party', searcher='search_party')
|
|
missing_data = fields.Boolean('Missing data')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls._order.insert(0, ('equipment', 'ASC'))
|
|
cls._order.insert(1, ('kind', 'ASC'))
|
|
t = cls.__table__()
|
|
cls._sql_constraints = [
|
|
('kind_location_description_unique', Unique(t, t.equipment,
|
|
t.kind, t.location, t.customer_description),
|
|
'lims_industry.msg_component_unique'),
|
|
]
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
table_h = cls.__table_handler__(module_name)
|
|
type_exist = table_h.column_exist('type')
|
|
super().__register__(module_name)
|
|
if type_exist:
|
|
cursor = Transaction().connection.cursor()
|
|
ComponentType = Pool().get('lims.component.type')
|
|
cursor.execute('UPDATE "' + cls._table + '" c '
|
|
'SET kind = ct.kind, location = ct.location '
|
|
'FROM "' + ComponentType._table + '" ct '
|
|
'WHERE ct.id = c.type')
|
|
table_h.drop_constraint('type_unique')
|
|
table_h.drop_constraint('type_description_unique')
|
|
table_h.drop_column('type')
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
TaskTemplate = Pool().get('lims.administrative.task.template')
|
|
components = super().create(vlist)
|
|
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
|
|
|
|
@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)))
|
|
|
|
@classmethod
|
|
def copy(cls, records, default=None):
|
|
if default is None:
|
|
default = {}
|
|
current_default = default.copy()
|
|
|
|
new_records = []
|
|
for record in records:
|
|
current_default['customer_description'] = '%s (copy)' % (
|
|
record.customer_description)
|
|
new_record, = super().copy([record], default=current_default)
|
|
new_records.append(new_record)
|
|
return new_records
|
|
|
|
def get_rec_name(self, name):
|
|
res = self.kind.rec_name
|
|
if self.location:
|
|
res += ' ' + self.location.name
|
|
if self.brand:
|
|
res += ' - ' + self.brand.rec_name
|
|
if self.model:
|
|
res += ' - ' + self.model
|
|
if self.customer_description:
|
|
res += ' [' + self.customer_description + ']'
|
|
return res
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
return ['OR',
|
|
('kind.name',) + tuple(clause[1:]),
|
|
('location.name',) + tuple(clause[1:]),
|
|
('brand.name',) + tuple(clause[1:]),
|
|
('model',) + tuple(clause[1:]),
|
|
('customer_description',) + tuple(clause[1:]),
|
|
]
|
|
|
|
@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
|
|
|
|
@classmethod
|
|
def search_plant(cls, name, clause):
|
|
return [('equipment.plant',) + tuple(clause[1:])]
|
|
|
|
@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
|
|
|
|
@classmethod
|
|
def search_party(cls, name, clause):
|
|
return [('equipment.plant.party',) + tuple(clause[1:])]
|
|
|
|
@fields.depends('kind', '_parent_kind.product_type')
|
|
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.kind and c.kind.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)
|
|
dangerous = fields.Boolean('Dangerous')
|
|
|
|
@staticmethod
|
|
def default_dangerous():
|
|
return False
|
|
|
|
def get_rec_name(self, name):
|
|
res = '%s %s' % (self.brand.name, self.name)
|
|
return res
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
return ['OR',
|
|
('name',) + tuple(clause[1:]),
|
|
('brand.name',) + tuple(clause[1:]),
|
|
]
|