504 lines
15 KiB
Python
504 lines
15 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
|
|
from trytond.pyson import Bool, If, Eval, Id
|
|
|
|
|
|
_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"
|
|
|
|
product = fields.Many2One(
|
|
"optical_equipment.maintenance",
|
|
"Maintenance Activity",
|
|
ondelete="CASCADE",
|
|
)
|
|
equipment = fields.Boolean(
|
|
"It is equipment",
|
|
states={
|
|
"invisible": Eval("type", "goods") != "goods",
|
|
},
|
|
)
|
|
maintenance_activity = fields.Boolean(
|
|
"Maintenance Activity",
|
|
states={
|
|
"invisible": Eval("type", "service") != "service",
|
|
"readonly": If(Eval("equipment", True), True)
|
|
| If(Eval("replacement", True), True),
|
|
},
|
|
)
|
|
replacement = fields.Boolean(
|
|
"Replacement",
|
|
states={
|
|
"invisible": Eval("type", "goods") != "goods",
|
|
"readonly": If(Eval("equipment", True), True)
|
|
| If(Eval("maintenance_activity", True), True),
|
|
},
|
|
)
|
|
|
|
maintenance_required = fields.Boolean(
|
|
"Miantenance Required",
|
|
states={
|
|
"invisible": (Eval("type", "goods") != "goods")}
|
|
)
|
|
equipment_type = fields.Selection(
|
|
_EQUIPMENT_TYPE, "Equipment type",
|
|
states={"required": Eval("equipment", False)}
|
|
)
|
|
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)},
|
|
)
|
|
main_tecnology = fields.Selection(
|
|
_MAIN_TECNOLOGY, "Main tecnology",
|
|
states={"required": Eval("equipment", False)})
|
|
calibration = fields.Boolean("Apply calibration")
|
|
observation = fields.Text("Observation")
|
|
|
|
# Mark, Category, Reference
|
|
mark_category = fields.Many2One(
|
|
"product.category",
|
|
"Mark",
|
|
domain=[("parent", "=", None), ("accounting", "=", False)],
|
|
states={"required": Eval("equipment", False)},
|
|
)
|
|
model_category = fields.Many2One(
|
|
"product.category",
|
|
"Model",
|
|
domain=[
|
|
("parent", "=", Eval("mark_category")),
|
|
("accounting", "=", False)],
|
|
states={"required": Eval("equipment", False)})
|
|
reference_category = fields.Many2One(
|
|
"product.category",
|
|
"Reference",
|
|
states={
|
|
"required": (Eval("equipment", True))
|
|
},
|
|
domain=[("parent", "=", Eval("model_category"))])
|
|
|
|
# Information Equipment
|
|
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": ~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': (~Eval('temperature_min', True))}
|
|
)
|
|
frequency = fields.Float("Frequency")
|
|
frequency_uom = fields.Many2One(
|
|
"product.uom",
|
|
"Frequency UOM",
|
|
domain=[
|
|
("category", "=", Id("optical_equipment", "uom_cat_frequency"))],
|
|
states={'invisible': (Eval('frequency', True))})
|
|
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': (~Eval('moisture_min', True))})
|
|
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': (~Eval('frequency', True))
|
|
| ~Eval('electrical_equipment', True)},)
|
|
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': (~Eval('voltageAC', True))
|
|
| ~Eval('electrical_equipment', True)},
|
|
)
|
|
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': (
|
|
~Eval('voltageDC', True) | ~Eval(
|
|
'electrical_equipment', True))},)
|
|
useful_life = fields.Integer("Useful life")
|
|
warranty = fields.Integer("Warranty")
|
|
|
|
# calibration parameters
|
|
use_pattern = fields.Many2One(
|
|
"optical_equipment.use_pattern",
|
|
"Use Pattern",
|
|
ondelete="RESTRICT",
|
|
states={"required": Eval("calibration", True)},)
|
|
measuring_range = fields.Selection(
|
|
[("dioptria", "Dioptria"),
|
|
("mmhg", "mmHg")], "Rango de Medición")
|
|
MEP = fields.Float(
|
|
"MEP",
|
|
states={"required": Eval("calibration", False)},)
|
|
uncertainy_pattern = fields.Float(
|
|
"Uncertainy Pattern",
|
|
states={"required": Eval("calibration", True)},
|
|
help="Agregar valores separados por ',' Ej:-5,+5,-10,+10",)
|
|
k_pattern = fields.Char(
|
|
"K Pattern",
|
|
states={"required": Eval("calibration", False)},
|
|
help="Agregar valores separados por ',' Ej:-5,+5,-10,+10",
|
|
)
|
|
k_pattern_list = fields.One2Many(
|
|
"optical_equipment.product_pattern",
|
|
"product",
|
|
"List of patterns K",
|
|
states={"required": Eval("calibration", False)},
|
|
)
|
|
resolution_type = fields.Selection(
|
|
[("", ""), ("analoga", "Analoga"), ("digital", "Digital")],
|
|
"Resolution Type",
|
|
states={"required": Eval("calibration", False)},
|
|
)
|
|
|
|
d_resolution = fields.Float(
|
|
"Resolution d",
|
|
states={
|
|
'invisible': (Eval('resolution_type') != 'digital'),
|
|
'required': (Eval('resolution_type') == 'digital')
|
|
})
|
|
analog_resolution = fields.Float(
|
|
"Analog resolution",
|
|
states={'invisible': (Eval('resolution_type') != 'analoga'), },
|
|
)
|
|
a_factor_resolution = fields.Float(
|
|
"(a) Resolution",
|
|
states={'invisible': (Eval('resolution_type') != 'analoga')},
|
|
)
|
|
Usubi = fields.Integer("Usub i", states={
|
|
"required": Eval("calibration", False)})
|
|
|
|
# maintenance activities
|
|
initial_operation = fields.Boolean(
|
|
"Verificación inicial de funcionamiento")
|
|
check_equipment = fields.Boolean("Revisión del Equipo")
|
|
check_electric_system = fields.Boolean("Revisión del sistema electríco")
|
|
clean_int_ext = fields.Boolean("Limpieza interior y exterior")
|
|
clean_eyes = fields.Boolean("Limpieza de lentes y espejos")
|
|
optical = fields.Boolean("Optical")
|
|
check_calibration = fields.Boolean("Verificar Calibración")
|
|
|
|
# Maintenance activites Preventives
|
|
preventive_activities = fields.Text("Preventive Activities")
|
|
|
|
@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")},
|
|
),
|
|
(
|
|
"//page[@id='maintenance_activities']",
|
|
"states",
|
|
{"invisible": ~Eval("maintenance_required")},
|
|
),
|
|
]
|
|
|
|
@classmethod
|
|
@fields.depends("measuring_range")
|
|
def default_measuring_range(self):
|
|
return "dioptria"
|
|
|
|
@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
|
|
def default_frequency(cls):
|
|
return 0
|
|
|
|
@classmethod
|
|
def default_moisture_min(cls):
|
|
return 0
|
|
|
|
@classmethod
|
|
def default_moisture_max(cls):
|
|
return 0
|
|
|
|
@classmethod
|
|
def default_voltageDC(cls):
|
|
return 0
|
|
|
|
@classmethod
|
|
def default_voltageAC(cls):
|
|
return 0
|
|
|
|
def default_risk():
|
|
return "n/a"
|
|
|
|
def default_use():
|
|
return None
|
|
|
|
def default_biomedical_class():
|
|
return "n/a"
|
|
|
|
def default_main_tecnology():
|
|
return None
|
|
|
|
def default_calibration():
|
|
return False
|
|
|
|
def default_refurbish():
|
|
return False
|
|
|
|
@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
|
|
|
|
@classmethod
|
|
def default_frequency_uom(cls):
|
|
pool = Pool()
|
|
Measurements = pool.get("product.uom")
|
|
measurement = Measurements.search(["name", "=", "Hertz"])[0].id
|
|
|
|
return measurement
|
|
|
|
@classmethod
|
|
def default_moisture_uom(cls):
|
|
pool = Pool()
|
|
Measurements = pool.get("product.uom")
|
|
measurement = Measurements.search(
|
|
["name", "=", "Relative Humedity"])[0].id
|
|
|
|
return measurement
|
|
|
|
@classmethod
|
|
def default_voltageAC_uom(cls):
|
|
pool = Pool()
|
|
Measurements = pool.get("product.uom")
|
|
measurement = Measurements.search(["name", "=", "Volt"])[0].id
|
|
|
|
return measurement
|
|
|
|
@classmethod
|
|
def default_voltageDC_uom(cls):
|
|
pool = Pool()
|
|
Measurements = pool.get("product.uom")
|
|
measurement = Measurements.search(["name", "=", "Volt"])[0].id
|
|
|
|
return measurement
|
|
|
|
@fields.depends("voltageDC", "voltageDC_uom")
|
|
def on_change_voltageDC_uom(self):
|
|
pool = Pool()
|
|
Measurements = pool.get("product.uom")
|
|
measurement = Measurements.search(["name", "=", "Volt"])[0].id
|
|
self.voltageDC_uom = measurement
|
|
|
|
# @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
|
|
self.mark_category = None
|
|
self.model_category = None
|
|
self.reference_category = None
|
|
self.equipment_type = None
|
|
self.risk = "n/a"
|
|
self.biomedical_class = "n/a"
|
|
self.use = ""
|
|
self.useful_life = 0
|
|
self.warranty = 0
|
|
|
|
@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
|
|
|
|
@classmethod
|
|
def copy(cls, templates, default=None):
|
|
if default is None:
|
|
default = {}
|
|
else:
|
|
default = default.copy()
|
|
default.setdefault("code", None)
|
|
default.setdefault("images", None)
|
|
return super().copy(templates, default=default)
|
|
|
|
|
|
class Product(metaclass=PoolMeta):
|
|
__name__ = "product.product"
|
|
|
|
@classmethod
|
|
def copy(cls, products, default=None):
|
|
if default is None:
|
|
default = {}
|
|
else:
|
|
default = default.copy()
|
|
|
|
default.setdefault("suffix_code", None)
|
|
default.setdefault("code", None)
|
|
default.setdefault("poduct", None)
|
|
default.setdefault("images", None)
|
|
return super().copy(products, default=default)
|
|
|
|
|
|
class Image(metaclass=PoolMeta):
|
|
__name__ = "product.image"
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
|
|
@classmethod
|
|
def copy(cls, images, default=None):
|
|
if default is None:
|
|
default = {}
|
|
else:
|
|
default = default.copy()
|
|
default.setdefault("template", None)
|
|
default.setdefault("product", None)
|
|
return super().copy(images, default=default)
|
|
|
|
|
|
class UsePattern(ModelSQL, ModelView):
|
|
"Use Pattern"
|
|
__name__ = "optical_equipment.use_pattern"
|
|
_rec_name = "name_pattern"
|
|
|
|
name_pattern = fields.Char("Name Pattern", required=True)
|
|
|
|
|
|
class Pattern(ModelSQL, ModelView):
|
|
"Pattern K of equipment"
|
|
__name__ = "optical_equipment.product_pattern"
|
|
_rec_name = "rec_name"
|
|
|
|
product = fields.Many2One(
|
|
"product.template", "Template", ondelete="CASCADE")
|
|
pattern = fields.Float("Value Pattern")
|
|
rec_name = fields.Function(fields.Char("rec_name"), "get_rec_name")
|
|
|
|
@fields.depends("pattern")
|
|
def get_rec_name(self, name):
|
|
if self.pattern:
|
|
return str(self.pattern)
|