328 lines
13 KiB
Python
328 lines
13 KiB
Python
#This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
#this repository contains the full copyright notices and license terms
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.model import (
|
|
ModelView, ModelSQL, fields, Exclude)
|
|
from trytond.pyson import Bool, If, Eval, Id
|
|
from trytond.exceptions import UserError
|
|
|
|
|
|
_RISK = [('n/a', "No aplíca"),
|
|
('uno', 'I'),
|
|
('dosA', 'IIA'),
|
|
('dosB', 'IIB')]
|
|
|
|
_USE = [('', ""),
|
|
('medico', 'Médico'),
|
|
('basico', 'Basico'),
|
|
('apoyo', 'Apoyo')]
|
|
|
|
_BIOMEDICAL_CLASS = [
|
|
('n/a', "No aplíca"),
|
|
('diagnostico', 'Diagnóstico'),
|
|
('rehabilitación', 'Rehabilitación')]
|
|
|
|
_MAIN_TECNOLOGY = [
|
|
('', ""),
|
|
('mecanico', 'Mecánico'),
|
|
('electrico', 'Electrico'),
|
|
('electronico', 'Electrónico'),
|
|
('hidraulico', 'Hidraulico'),
|
|
('neumatico', 'Neumatico')]
|
|
|
|
_EQUIPMENT_TYPE = [
|
|
('', ""),
|
|
('mobiliario_optico', 'Mobiliario óptico'),
|
|
('refraccion', 'Refracción'),
|
|
('medico', 'Medicion'),
|
|
('accesorios', 'Accesorios')]
|
|
|
|
NON_MEASURABLE = ['service']
|
|
|
|
|
|
class Template(metaclass=PoolMeta):
|
|
'Template'
|
|
__name__ = 'product.template'
|
|
|
|
equipment = fields.Boolean('It is equipment',
|
|
states={'invisible': Eval('type', 'goods') != 'goods',
|
|
},depends=['type']
|
|
)
|
|
maintenance_activity = fields.Boolean('Maintenance Activity',
|
|
states={'invisible': Eval('type', 'service') != 'service',
|
|
'readonly': If(Eval('equipment',True), True)
|
|
| If(Eval('replacement',True), True)
|
|
},depends=['type']
|
|
)
|
|
replacement = fields.Boolean('Replacement',
|
|
states={'invisible': Eval('type', 'goods') != 'goods',
|
|
'readonly': If(Eval('equipment',True), True)
|
|
| If(Eval('maintenance_activity',True), True)
|
|
},depends=['type']
|
|
)
|
|
equipment_type = fields.Selection(_EQUIPMENT_TYPE, 'Equipment type',
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
risk = fields.Selection(_RISK, 'Type risk')
|
|
use = fields.Selection(_USE, 'Use',
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
biomedical_class = fields.Selection(_BIOMEDICAL_CLASS,'Biomedical Class',
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
main_tecnology = fields.Selection(_MAIN_TECNOLOGY,'Main tecnology',
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
calibration = fields.Boolean("Apply calibration")
|
|
observation = fields.Text('Observation')
|
|
mark_category = fields.Many2One('product.category', 'Mark',
|
|
domain=[('parent', '=', None),
|
|
('accounting', '=', False)],
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
model_category = fields.Many2One('product.category', "Model",
|
|
domain=[('parent', '=', Eval('mark_category')),
|
|
('accounting', '=', False)],
|
|
states={'required': Eval('equipment', False)},
|
|
depends=['equipment']
|
|
)
|
|
reference_category = fields.Many2One('product.category', "Reference",
|
|
domain=[('parent', '=', Eval('model_category'))],
|
|
)
|
|
origin_country = fields.Many2One('country.country',"Origin Country")
|
|
refurbish = fields.Boolean('Refurbish')
|
|
software_required = fields.Boolean("Software Required")
|
|
software_version = fields.Char("Software version",
|
|
states={'invisible': If(~Eval('software_required'), True)},
|
|
depends=['software_required'])
|
|
|
|
#These are measurements required for the equipments, are in this place
|
|
# for manage of class 'product.template'
|
|
|
|
|
|
temperature_min = fields.Float("Temp Min")
|
|
temperature_max = fields.Float("Temp Max")
|
|
temperature_uom = fields.Many2One('product.uom', 'Temperature UOM',
|
|
domain=[('category', '=', Id('optical_equipment', "uom_cat_temperature"))],
|
|
states={'invisible' : If(Eval('temperature_min') == None, True)},
|
|
depends=['itemperature_min']
|
|
)
|
|
frequency = fields.Float("Frequency")
|
|
frequency_uom = fields.Many2One('product.uom', "Frequency UOM",
|
|
domain=[('category', '=', Id('optical_equipment', 'uom_cat_frequency'))],
|
|
states={'invisible' : If(Eval('frequency') == None, True)},
|
|
depends=['frequency']
|
|
)
|
|
moisture_min = fields.Float("Moisture Min")
|
|
moisture_max = fields.Float("Moisture Max")
|
|
moisture_uom = fields.Many2One('product.uom', "Moisture UOM",
|
|
domain=[('category', '=', Id('optical_equipment', 'uom_cat_relative_humedity'))],
|
|
states={'invisible' : If(Eval('moisture_min') == None, True)},
|
|
depends=['moisture_min']
|
|
)
|
|
electrical_equipment = fields.Boolean("Electrical Equipment")
|
|
frequency = fields.Float("Frequency",
|
|
states={'invisible': ~Bool(Eval('electrical_equipment'))})
|
|
frequency_uom = fields.Many2One('product.uom', "Frequency UOM",
|
|
domain=[('category', '=', Id('optical_equipment', 'uom_cat_frequency'))],
|
|
states={'invisible' : If(Eval('frequency') == None, True) |
|
|
~Eval('electrical_equipment', True)},
|
|
depends=['frequency']
|
|
)
|
|
voltageAC = fields.Float("Voltage AC",
|
|
states={'invisible': ~Bool(Eval('electrical_equipment'))})
|
|
voltageAC_uom = fields.Many2One('product.uom', "Voltage AC UOM",
|
|
domain=[('category', '=', Id('optical_equipment', 'uom_cat_electrical_tension'))],
|
|
states={'invisible' : If(Eval('voltageAC') == None, True) |
|
|
~Eval('electrical_equipment', True)},
|
|
depends=['voltageAC']
|
|
)
|
|
voltageDC = fields.Float("Voltage DC",
|
|
states={'invisible': ~Bool(Eval('electrical_equipment'))})
|
|
voltageDC_uom = fields.Many2One('product.uom', "Voltage DC UOM",
|
|
domain=[('category', '=', Id('optical_equipment', 'uom_cat_electrical_tension'))],
|
|
states={'invisible' : If(Eval('voltageDC') == None, True) |
|
|
~Eval('electrical_equipment', True)},
|
|
depends=['voltageDC'])
|
|
|
|
useful_life = fields.Integer("Useful life")
|
|
warranty = fields.Integer("Warranty")
|
|
|
|
#### calibration parameters
|
|
|
|
uncertainy_pattern = fields.Float("Uncertainy Pattern",
|
|
help="Agregar valores separados por ',' Ej:-5,+5,-10,+10")
|
|
k_pattern = fields.Char("K Pattern",
|
|
help="Agregar valores separados por ',' Ej:-5,+5,-10,+10")
|
|
|
|
resolution_type = fields.Selection([('',""),
|
|
('analoga', "Analoga"),
|
|
('digital', "Digital")], "Resolution Type",
|
|
states={'required': Eval('calibration', False)},
|
|
depends=['calibration'])
|
|
d_resolution = fields.Float("Resolution d",
|
|
states={'invisible': If(Eval('resolution_type') != 'digital', True)},
|
|
depends=['resolution_type'])
|
|
analog_resolution = fields.Float("Analog resolution",
|
|
states={'invisible': If(Eval('resolution_type') != 'analoga', True)},
|
|
depends=['resolution_type'])
|
|
a_factor_resolution = fields.Float("(a) Resolution",
|
|
states={'invisible': If(Eval('resolution_type') != 'analoga', True)},
|
|
depends=['resolution_type'])
|
|
Usubi = fields.Integer("Usub i")
|
|
|
|
@classmethod
|
|
def view_attributes(cls):
|
|
return super(Template, cls).view_attributes() + [
|
|
('//page[@id="features"]', 'states', {
|
|
'invisible': ~Eval('equipment'),
|
|
}),
|
|
('//page[@id="calibration"]', 'states', {
|
|
'invisible': ~Eval('calibration')},)
|
|
]
|
|
|
|
@classmethod
|
|
@fields.depends('temperature_min')
|
|
def default_temperature_min(self):
|
|
return 0
|
|
|
|
@classmethod
|
|
@fields.depends('temperature_max')
|
|
def default_temperature_max(self):
|
|
return 0
|
|
|
|
@classmethod
|
|
@fields.depends('temperature')
|
|
def default_temperature_uom(self):
|
|
pool = Pool()
|
|
Measurements = pool.get('product.uom')
|
|
measurement = Measurements.search(['name', '=', 'Celsius'])[0].id
|
|
|
|
return measurement
|
|
|
|
@staticmethod
|
|
def default_frequency():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_frequency_uom():
|
|
pool = Pool()
|
|
Measurements = pool.get('product.uom')
|
|
measurement = Measurements.search(['name', '=', 'Hertz'])[0].id
|
|
|
|
return measurement
|
|
|
|
@staticmethod
|
|
def default_moisture_min():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_moisture_max():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_moisture_uom():
|
|
pool = Pool()
|
|
Measurements = pool.get('product.uom')
|
|
measurement = Measurements.search(['name', '=', 'Relative Humedity'])[0].id
|
|
|
|
return measurement
|
|
|
|
@staticmethod
|
|
def default_voltageAC():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_voltageAC_uom():
|
|
pool = Pool()
|
|
Measurements = pool.get('product.uom')
|
|
measurement = Measurements.search(['name', '=', 'Volt'])[0].id
|
|
|
|
return measurement
|
|
|
|
@staticmethod
|
|
def default_voltageDC():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_voltageDC_uom():
|
|
pool = Pool()
|
|
Measurements = pool.get('product.uom')
|
|
measurement = Measurements.search(['name', '=', 'Volt'])[0].id
|
|
|
|
return measurement
|
|
|
|
|
|
@staticmethod
|
|
def default_risk():
|
|
return 'n/a'
|
|
|
|
@staticmethod
|
|
def default_use():
|
|
return None
|
|
|
|
@staticmethod
|
|
def default_biomedical_class():
|
|
return 'n/a'
|
|
|
|
@staticmethod
|
|
def default_main_tecnology():
|
|
return None
|
|
|
|
@staticmethod
|
|
def default_calibration():
|
|
return False
|
|
|
|
@staticmethod
|
|
def default_refurbish():
|
|
return False
|
|
|
|
@staticmethod
|
|
def default_refurbish():
|
|
return False
|
|
|
|
|
|
@fields.depends('software_required', 'software_version')
|
|
def on_change_with_sotfware_required(self):
|
|
self.software_version = None
|
|
|
|
@fields.depends('d_resolution', 'analog_resolution', 'a_factor_resolution')
|
|
def on_change_resolution_type(self):
|
|
self.d_resolution = None
|
|
self.analog_resolution = None
|
|
self.a_factor_resolution = None
|
|
|
|
|
|
@fields.depends('equipment', 'replacement')
|
|
def on_change_equipment(self):
|
|
if self.equipment:
|
|
self.replacement=False
|
|
self.maintenance_activity=False
|
|
self.calibration=False
|
|
|
|
@fields.depends('mark_category', 'model_category', 'reference_category')
|
|
def on_change_mark_category(self):
|
|
if not self.mark_category:
|
|
self.model_category = None
|
|
self.reference_category = None
|
|
|
|
@fields.depends('model_category', 'reference_category')
|
|
def on_change_model_category(self):
|
|
if not self.model_category:
|
|
self.reference_category = None
|
|
|
|
@fields.depends('electrical_equipment')
|
|
def on_change_electrical_equipment(self):
|
|
if self.electrical_equipment:
|
|
self.voltageAC = 0
|
|
self.voltageDC = 0
|
|
self.frequency = 0
|
|
|
|
class Product(metaclass=PoolMeta):
|
|
__name__ = 'product.product'
|