trytondo-optical_equipment/maintenance.py

378 lines
14 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.model import (
Workflow, ModelSQL, ModelView, Unique, fields, sequence_ordered)
from trytond.transaction import Transaction
from trytond.pyson import Eval, If, Id
from trytond.pool import Pool
import math as mt
import numpy as np
class Maintenance(Workflow, ModelSQL, ModelView):
'Equipment Maintenance'
__name__ = 'optical_equipment.maintenance'
service_maintenance = fields.Many2One('optical_equipment.maintenance.service', "Maintenance Service",
ondelete='CASCADE', select=True)
code = fields.Char(
"Code", select=True,states={'readonly': True })
maintenance_type = fields.Selection([('preventive', 'Preventive'),
('corrective', 'Corrective')
], "Maintenance Type")
state = fields.Selection([('draft', "Draft"),
('agended', "Agended"),
('in_progress', "In Progress"),
('failed', "Failed"),
('finished', "Finished")
], "State",required=True, readonly=True, sort=False)
company = fields.Many2One('company.company', "Company", readonly=True)
propietary = fields.Many2One('party.party', "Propietary", required=True)
propietary_address = fields.Many2One('party.address', "Propietary Address", required=True,
domain=[('party', '=', Eval('propietary'))]
)
equipment = fields.Many2One('optical_equipment.equipment', "Equipment",
domain=[('state', '!=', 'draft'),
('propietary', '=', Eval('propietary'))]
)
#when the maintenance is in agended status
diary = fields.One2Many('optical_equipment.maintenance.diary', 'diary')
estimated_agended = fields.DateTime("Date Maintenance")
state_agended = fields.Selection([('no_agenda', "No agenda"),
('agended', "Agended"),
('in_progress', "In progress"),
('finish', "Finish"),
('failed', "Failed")], "State Agenda")
technical = fields.Many2One('company.employee', "Technical")
#Preventive maintenance
initial_operation = fields.Boolean("Verificiación inicial de funcionamiento")
check_equipment = fields.Boolean("Revisión del Equipo")
check_eletric_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_activity = fields.Many2Many('optical_equipment.maintenance-product.product', 'activity', 'maintenance', "Maintenance Activitys")
maintenance_lines = fields.One2Many('optical_equipment.maintenance.line', 'maintenance', 'Lines')
@classmethod
def __setup__(cls):
super(Maintenance, cls).__setup__()
cls._transitions.update({
('draft', 'agended'),
('agended', 'in_progress'),
('in_progress', 'finished')
})
cls._buttons.update({
'agended': {'invisible': Eval('state').in_(['agended', 'in_progress', 'finished'])},
'in_progress': {'invisible': Eval('state').in_(['draft', 'in_progress', 'finished'])},
'finished': {'invisible': Eval('state').in_(['draft', 'agended', 'finished'])},
})
@staticmethod
def default_company():
return Transaction().context.get('company')
@classmethod
def default_state(cls):
return 'draft'
@classmethod
def default_maintenance_type(cls):
return 'preventive'
@classmethod
def default_state_agended(cls):
return 'no_agenda'
@classmethod
@ModelView.button
@Workflow.transition('agended')
def agended(cls, maintenances):
pass
@classmethod
@ModelView.button
@Workflow.transition('in_progress')
def in_progress(cls, maintenances):
pass
@classmethod
@ModelView.button
@Workflow.transition('finished')
def finished(cls, maintenances):
pass
@classmethod
def view_attributes(cls):
return super(Maintenance, cls).view_attributes() + [
('//page[@id="preventive"]', 'states', {
'invisible': If(Eval('maintenance_type') != 'preventive', True),
}),
('//page[@id="corrective"]', 'states',{
'invisible': If(Eval('maintenance_type') != 'corrective', True),
})
]
class MaintenanceService(ModelSQL, ModelView):
'Equipment Maintenance Service'
__name__ = 'optical_equipment.maintenance.service'
code = fields.Char(
"Code", select=True,states={'readonly': True })
reference = fields.Char(
"Reference", select=True,
help="The identification of an external origin.")
description = fields.Char("Description",
states={
'readonly': Eval('state') != 'draft',
})
#sale_date = fields.Function(fields.Char("Sale Date"), 'get_sale_date')
sale_origin = fields.Reference("Sale Origin", selection='get_origin', select=True,
states={'readonly': True})
company = fields.Many2One('company.company', "Company", readonly=True)
maintenance_type = fields.Selection([('preventive', 'Preventive'),
('corrective', 'Corrective')
], "Maintenance Type")
propietary = fields.Many2One('party.party', "Propietary", required=True)
propietary_address = fields.Many2One('party.address', "Propietary Address", required=True,
domain=[('party', '=', Eval('propietary'))]
)
lines = fields.One2Many('optical_equipment.maintenance', 'service_maintenance', "Lines")
estimated_agended = fields.DateTime("Date Maintenance")
state_agended = fields.Selection([('no_agenda', "No agenda"),
('agended', "Agended"),
('in_progress', "In progress"),
('finish', "Finish"),
('failed', "Failed")], "State Agenda")
technical = fields.Many2One('company.employee', "Technical")
state = fields.Selection([('draft', "Draft"),
('agended', "Agended"),
('in_progress', "In Progress"),
('failed', "Failed"),
('finished', "Finished")
], "State",required=True, readonly=True, sort=False)
@staticmethod
def default_company():
return Transaction().context.get('company')
@classmethod
def default_state(self):
return 'draft'
@classmethod
def get_sale_date(self):
pass
@classmethod
def _get_origin(cls):
'Return list of Model names for origin Reference'
pool = Pool()
Sale = pool.get('sale.line')
return [Sale.__name__]
@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
@ModelView.button
@Workflow.transition('agended')
def agended(cls, maintenances):
pass
@classmethod
@ModelView.button
@Workflow.transition('in_progress')
def in_progress(cls, maintenances):
pass
@classmethod
@ModelView.button
@Workflow.transition('finished')
def finished(cls, maintenances):
pass
class MaintenanceActivity(ModelSQL):
'Maintenance - Products'
__name__ = 'optical_equipment.maintenance-product.product'
activity = fields.Many2One('product.product', "Activity", select=True)
maintenance = fields.Many2One('optical_equipment.maintenance', "Maintenance", select=True)
class MaintenanceLine(ModelSQL, ModelView):
'Maintenance Line'
__name__ = 'optical_equipment.maintenance.line'
product = fields.Many2One('product.product', 'Product',
ondelete='RESTRICT',domain=[
If(Eval('sale_state').in_(['draft']),
('maintenance_activity', '=', True),
()),
],)
maintenance = fields.Many2One('optical_equipment.maintenance', 'Maintenance', ondelete='CASCADE', select=True)
maintenance_activity = fields.Many2One('product.product', 'Maintenance activity')
class Calibration(ModelSQL, ModelView):
'Calibration of Maintenance'
__name__ = 'optical_equipment.maintenance.calibration'
samples = fields.One2Many('optical_equipment.maintenance.calibration_sample', 'maintenance',
'Samples')
dev_std = fields.Function(
fields.Float("Standart Desviation"),'get_standard_deviation'
)
uncertain_type_A = fields.Function(
fields.Float("Uncertain Type A"), 'get_uncertain_A'
)
uncertain_pattern = fields.Function(
fields.Float("Uncertain Pattern"), 'get_uncertain_pattern'
)
k_c_calibration = fields.Function(
fields.Float("K Crt Calibration"), 'get_k_certificated_calibration'
)
uncertain_U_b1 = fields.Function(
fields.Float("U_b1"), 'get_uncertain_U_b1'
)
d_resolution = fields.Float("d_resolution")
uncertain_U_b2_dig = fields.Function(
fields.Float("U_b2"), 'get_uncertain_b2_digital'
)
uncertain_U_b2_ana = fields.Function(
fields.Float("U_b2"), 'get_uncertain_b2_analoga'
)
uncertain_combinated = fields.Function(
fields.Float("U_combinated"), 'get_uncertain_combinated'
)
uncertain_eff = fields.Function(
fields.Float("U eff"), 'get_uncertain_eff'
)
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'])
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'])
average = fields.Float("Average")
#total_samples total de muestras
#average_pattern_equipment #Promedio de las muestras tomadas en el equipo suma(value_equipment)/total_samples
#Desviacion estandar muestral != desviación estandar poblacional
def get_standard_deviation(self):
"""
This function calculated the
standartd deviation
"""
sum_samples = sum(samples)
n_samples = len(samples)
mean = sum_samples / n_samples
dev_std_square = sum((l-mean)**2 for l in sample) / (n_samples -1)
dev_std = mt.sqrt(dev_std_square)
return dev_std
def get_uncertain_type_A(self):
"""
This function calculated the
uncertain type A
"""
n_samples = len(samples)
uncertain_type_A = dev_std /mt.sqrt(n_samples)
return uncertain_type_A
def get_uncertain_pattern(self):
"""
uncertain_pattern = 0,25 constante viene del equipo
"""
uncertain_pattern = 0.25
return uncertain_pattern
def get_k_certificated_calibration(self):
k_certificated_calibration = 2
return k_certicated_calibration
def get_uncertain_U_b1(self):
uncertain_b1 = MEP / mt.sqrt(3)
uncertain_b1a = uncertain_pattern / k_certificated_calibration
return uncertain_b1
def default_d_resolution(self):
return d
def get_uncertain_b2_digital(self):
uncertain_b2 = d/2*mt.sqrt(3)
return uncertain_b2
def get_uncertain_b2_analog(self):
#Incertidumbre por resolución Análoga
# a contante que viene del equipo
uncertain_b2_analog = d/a * math.sqrt(3)
return uncertain_b2_analog
def get_uncertain_combinated(self):
#Incertidumbre Combinada
sum_uncertain_c = uncertain_type_A**2 + uncertain_b1**2 + uncertain_b2**2
uncertain_c = math.sqrt(sum_uncertain_c)
return uncertain_c
def get_uncertain_eff(self):
#Grados Efectivos de libertad
uncertain_eff = uncertain_c**4/((uncertain_type_A**4)/(len(sample)-1)+(uncertain_b1**4/U_subi)+(uncertain_b2**4/U_subi))
return uncertain_eff
class CalibrationSample(sequence_ordered(), ModelView, ModelSQL):
'Samples of Calibration'
__name__ = 'optical_equipment.maintenance.calibration_sample'
maintenance = fields.Many2One('optical_equipment.maintenance', 'Maintenance',
ondelete='CASCADE')
number_sample = fields.Integer("Sample #")
value_pattern = fields.Integer("Value in Pattern")
value_equipment = fields.Float("Value in Equipment")
mistake = fields.Float("Mistake")
mistake_rate = fields.Float("% Mistake")
expanded_uncertainty = fields.Float("Uncertainy Expanded")