272 lines
11 KiB
Python
272 lines
11 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 collections import defaultdict
|
|
from trytond.pool import Pool
|
|
from trytond.model import (
|
|
DeactivableMixin, Workflow, ModelSQL, ModelView, Unique, fields)
|
|
from trytond.pyson import Eval, If
|
|
from trytond.transaction import Transaction
|
|
from trytond.i18n import gettext
|
|
from trytond.exceptions import UserError
|
|
from trytond.model.exceptions import AccessError
|
|
|
|
|
|
_MAINTENANCE_FREQUENCY = [("none", ''),
|
|
("6", 'Seis Meses'),
|
|
("12", 'Doce Meses')]
|
|
class OpticalEquipment(DeactivableMixin, Workflow, ModelSQL, ModelView):
|
|
'Optical Equipment'
|
|
__name__ = 'optical_equipment.equipment'
|
|
|
|
_states={
|
|
'readonly': Eval('state') != 'draft',
|
|
}
|
|
|
|
_states_serial={
|
|
'readonly': Eval('state') != 'draft',
|
|
}
|
|
|
|
code = fields.Char(
|
|
"Code", select=True,states={'readonly': True })
|
|
|
|
state = fields.Selection([('draft', "Draft"),
|
|
('registred', "Registred"),
|
|
('uncontrated', "UnContrated"),
|
|
('contrated', "Contrated")
|
|
], "State",
|
|
required=True, readonly=True, sort=False)
|
|
|
|
company = fields.Many2One('company.company', "Company", readonly=True)
|
|
location = fields.Many2One('stock.location', "Location",
|
|
states=_states,)
|
|
propietary = fields.Many2One('party.party',"Propietary", required=True,
|
|
states=_states,)
|
|
propietary_address = fields.Many2One('party.address', "Propietary Address", required=True,
|
|
domain=[('party', '=', Eval('propietary'))],
|
|
states=_states
|
|
)
|
|
product = fields.Many2One('product.product', "Product",
|
|
domain=[('equipment', '=', True)],
|
|
states=_states,
|
|
depends=['equipment']
|
|
)
|
|
refurbish = fields.Boolean("Refurbish",
|
|
states=_states,)
|
|
equipment_type = fields.Char('type', states={'readonly': If('product', True)})
|
|
risk = fields.Char('Type risk',states={'readonly': If('product', True)})
|
|
use = fields.Char('Use', states={'readonly': If('product', True)})
|
|
biomedical_class = fields.Char('Biomedical Class', states={'readonly': If('product', True)})
|
|
main_tecnology = fields.Char('Main tecnology', states={'readonly': If('product', True)})
|
|
calibration = fields.Boolean("Apply calibration", states={'readonly': If('product', True)})
|
|
mark_category = fields.Many2One('product.category', 'Mark', required=True,
|
|
domain=[('parent', '=', None),
|
|
('accounting', '=', False)],
|
|
states=_states
|
|
)
|
|
model_category = fields.Many2One('product.category', "Model", required=True,
|
|
domain=[('parent', '=', Eval('mark_category')),
|
|
('accounting', '=', False)],
|
|
states=_states,)
|
|
reference_category = fields.Many2One('product.category', "Reference",
|
|
domain=[('parent', '=', Eval('model_category'))],
|
|
states=_states,
|
|
depends=['model_category']
|
|
)
|
|
origin_country = fields.Many2One('country.country',"Origin Country",
|
|
states=_states,)
|
|
software_version = fields.Char("Software version", size=None,
|
|
states=_states,)
|
|
useful_life = fields.Integer("Useful life",
|
|
states=_states,)
|
|
warranty = fields.Integer("Warranty",
|
|
states=_states,)
|
|
serial = fields.Char("Serial", size=None,
|
|
states=_states_serial,)
|
|
health_register = fields.Char("Health Register", size=None,
|
|
states=_states,)
|
|
|
|
subscription_history = fields.Many2Many('sale.subscription-optical_equipment.equipment',
|
|
'equipment','subscription', "Subscriptions",
|
|
states={'readonly': True}
|
|
)
|
|
maintenance_history = fields.Function(
|
|
fields.Many2Many('optical_equipment.maintenance-optical_equipment.equipment',
|
|
'equipment', 'maintenance',"Maintenances"), 'get_maintenances_of_equipment')
|
|
software_version = fields.Char("Software version", size=None,
|
|
states=_states,)
|
|
|
|
maintenance_frequency = fields.Selection(_MAINTENANCE_FREQUENCY, "Maintenance Frequency",
|
|
depends=['propietary'])
|
|
|
|
purchase_origin = fields.Reference("Purchase Origin", selection='get_origin',select=True,
|
|
states=_states)
|
|
|
|
del _states
|
|
|
|
@classmethod
|
|
def _get_origin(cls):
|
|
'Return list of Model names for origin Reference'
|
|
pool = Pool()
|
|
Purchase = pool.get('purchase.line')
|
|
|
|
return [Purchase.__name__]
|
|
|
|
|
|
@property
|
|
def origin_name(self):
|
|
if isinstance(self.origin, self.__class__):
|
|
return self.origin.invoice.rec_name
|
|
return self.origin.rec_name if self.origin else None
|
|
|
|
@classmethod
|
|
def get_origin(cls):
|
|
Model = Pool().get('ir.model')
|
|
get_name = Model.get_name
|
|
models = cls._get_origin()
|
|
|
|
return [(None, '')] + [(m, get_name(m)) for m in models]
|
|
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(OpticalEquipment, cls).__setup__()
|
|
cls._transitions = ({
|
|
('draft', 'registred'),
|
|
('registred', 'uncontrated'),
|
|
('uncontrated', 'contrated'),
|
|
})
|
|
cls._buttons.update({
|
|
# 'draft': {
|
|
# 'invisible': Eval('state') == 'draft'},
|
|
'registred': {
|
|
'invisible': Eval('state').in_(['registred', 'contrated'])}}
|
|
)
|
|
|
|
@classmethod
|
|
def set_code(cls, equipments):
|
|
pool = Pool()
|
|
Config = pool.get('optical_equipment.configuration')
|
|
config = Config(1)
|
|
|
|
for equipment in equipments:
|
|
if config.equipment_sequence != None:
|
|
if equipment.code == None: #if not equipment.code:
|
|
try:
|
|
equipment.code = config.equipment_sequence.get()
|
|
equipment.state = 'registred'
|
|
cls.save(equipments) #Revisar
|
|
except UserError:
|
|
raise UserError(str('Validation Error'))
|
|
else:
|
|
raise UserError(gettext('optical_equipment.msg_not_sequence_equipment'))
|
|
|
|
|
|
|
|
def get_maintenances_of_equipment(self, records):
|
|
pool = Pool()
|
|
MaintenancesEquipment = pool.get('optical_equipment.maintenance')
|
|
maintenancesEquipment = set()
|
|
|
|
maintenancesEquipment = MaintenancesEquipment.search(['equipment', '=', self.id])
|
|
maintenances = []
|
|
|
|
for key in maintenancesEquipment:
|
|
maintenances.append(key.id)
|
|
|
|
return maintenances
|
|
|
|
@classmethod
|
|
def default_state(cls):
|
|
return 'draft'
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
@fields.depends('propietary', 'maintenance_frequency')
|
|
def on_change_propietary(self):
|
|
if self.propietary:
|
|
if self.propietary.client_type == 'ips':
|
|
self.maintenance_frequency = "6"
|
|
else:
|
|
self.maintenance_frequency = "12"
|
|
else:
|
|
self.maintenance_frequency = "none"
|
|
|
|
@fields.depends('product', 'equipment_type','use',
|
|
'biomedical_class', 'calibration',
|
|
'mark_category', 'model_category')
|
|
def on_change_product(self):
|
|
if self.product:
|
|
self.equipment_type=self.product.equipment_type
|
|
self.use=self.product.use
|
|
self.biomedical_class=self.product.biomedical_class
|
|
self.calibration=self.product.calibration
|
|
self.mark_category=self.product.mark_category
|
|
self.model_category=self.product.model_category
|
|
self.reference_category=self.product.reference_category
|
|
self.useful_life=self.product.useful_life if self.product.useful_life else int(0)
|
|
self.calibration=True if self.product.calibration else False
|
|
self.warranty=self.product.warranty if self.product.warranty else int(0)
|
|
self.risk=self.product.risk
|
|
self.origin_country=self.product.origin_country
|
|
self.use=self.product.use
|
|
self.biomedical_class=self.product.biomedical_class
|
|
else:
|
|
self.equipment_type=None
|
|
self.use=None
|
|
self.biomedical_class=None
|
|
self.calibration=None
|
|
self.mark_category=None
|
|
self.model_category=None
|
|
self.reference_category=None
|
|
self.useful_life=None
|
|
self.calibration=False
|
|
self.warranty=None
|
|
self.risk=None
|
|
self.origin_country=None
|
|
self.use=None
|
|
self.biomedical_class=None
|
|
self.refurbish=None
|
|
self.serial=None
|
|
self.health_register=None
|
|
self.software_version=None
|
|
|
|
# @classmethod
|
|
# @ModelView.button
|
|
# @Workflow.transition('draft')
|
|
# def draft(cls, equipments):
|
|
# pass
|
|
|
|
|
|
|
|
@classmethod
|
|
def delete(cls, equipments):
|
|
for equipment in equipments:
|
|
if equipment.purchase_origin:
|
|
raise AccessError(
|
|
gettext('estos equipos no se pueden borrar'))
|
|
elif equipment.state != 'draft' and equipment.serial != None:
|
|
raise AccessError(
|
|
gettext('estos equipos no se pueden borrar'))
|
|
super(OpticalEquipment, cls).delete(equipments)
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
@Workflow.transition('registred')
|
|
def registred(cls, equipments):
|
|
for i in equipments:
|
|
if i.serial == None:
|
|
raise UserError(str("El Equipo no cuenta con un Serial"))
|
|
else:
|
|
cls.set_code(equipments)
|
|
|
|
|
|
|
|
class EquipmentMaintenance(ModelSQL, ModelView):
|
|
'Optical Equipment - Equipment - Maintenance'
|
|
__name__='optical_equipment.maintenance-optical_equipment.equipment'
|
|
|
|
equipment = fields.Many2One('optical_equipment.equipment', 'Equipment', select=True)
|
|
maintenance = fields.Many2One('optical_equipment.maintenance', 'Maintenances', select=True)
|