changes finished

__init__.py

@@ -15,6 +15,7 @@ def register():
         equipment.OpticalEquipment,
         equipment.EquipmentMaintenance,
         configuration_equipment.Configuration,
+        maintenance.Calibration,
         maintenance.CreateContractInitial,
         maintenance.CalibrationSample,
         maintenance.Maintenance,

maintenance.py

@@ -10,6 +10,7 @@ from trytond.pool import Pool
 from trytond.modules.currency.fields import Monetary
 from trytond.modules.product import price_digits
 
+from scipy.stats import t
 import datetime
 from datetime import timedelta
 import math as mt
@@ -17,6 +18,7 @@ import numpy as np
 
 from trytond.exceptions import UserError
 
+_digits = (16, 2) 
 
 class MaintenanceService(Workflow, ModelSQL, ModelView):
     'Equipment Maintenance Service'
@@ -68,9 +70,9 @@ class MaintenanceService(Workflow, ModelSQL, ModelView):
             ('in_progress', 'finished'),
         })
         cls._buttons.update({
-                'in_progress': {'invisible': Eval('state').in_(['draft', 'in_progress', 'finished'])},
-                'finished': {'invisible': Eval('state').in_(['draft', 'agended', 'finished'])},
-                })
+            'in_progress': {'invisible': Eval('state').in_(['draft', 'in_progress', 'finished'])},
+            'finished': {'invisible': Eval('state').in_(['draft', 'agended', 'finished'])}
+        })
 
     @staticmethod
     def default_company():
@@ -148,6 +150,7 @@ class MaintenanceService(Workflow, ModelSQL, ModelView):
     def finished(cls, maintenances):
         pass
 
+    
 
 class Maintenance(Workflow, ModelSQL, ModelView):
     'Equipment Maintenance'
@@ -162,18 +165,15 @@ class Maintenance(Workflow, ModelSQL, ModelView):
     maintenance_type = fields.Selection([('preventive', 'Preventive'),
                                          ('corrective', 'Corrective')
                                          ], "Maintenance Type")
-    
     state = fields.Selection([('draft', "Draft"),
                               ('finished', "Finished")
                               ], "State",required=True, readonly=True, sort=False)
-
     company = fields.Many2One('company.company', "Company", readonly=True)
     propietary = fields.Many2One('party.party', "Propietary",
                                  depends=['service_maintenance'])
     propietary_address = fields.Many2One('party.address', "Propietary Address",
                                          domain=[('party', '=', Eval('propietary'))],
-                                         depends=['service_maintenance']
-                                         )
+                                         depends=['service_maintenance'])
     equipment = fields.Many2One('optical_equipment.equipment', "Equipment", required=True,
                                 domain=[('propietary', '=', Eval('propietary'))],
                                 depends=['service_maintenance'])
@@ -185,6 +185,7 @@ class Maintenance(Workflow, ModelSQL, ModelView):
     #                                  ('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")
@@ -198,8 +199,11 @@ class Maintenance(Workflow, ModelSQL, ModelView):
     #Calibration
     patterns_equipments = fields.Char("K Pattern", states={'readonly': True},
                                       depends=['equipment'])
-    lines_calibration = fields.One2Many('optical_equipment.maintenance.calibration_sample', 'maintenance', "Lines of Calibration")
+    lines_calibration = fields.One2Many('optical_equipment.maintenance.calibration_sample', 'maintenance', "Lines of Calibration",
+                                        states={'readonly': Eval('state') == 'finished'})
 
+    calibration_total = fields.One2Many('optical_equipment.maintenance.calibration', 'maintenance', "Calibration Total",
+                                        states={'readonly': Eval('state') == 'finished'})
     maintenance_lines = fields.One2Many('optical_equipment.maintenance.line', 'maintenance', 'Lines')
 
     """
@@ -224,79 +228,11 @@ class Maintenance(Workflow, ModelSQL, ModelView):
             ('draft',  'finished')
             })
         cls._buttons.update({
-                'in_progress': {'invisible': Eval('state').in_(['draft', 'in_progress', 'finished'])},
+            'in_progress': {'invisible': Eval('state').in_(['draft', 'in_progress', 'finished'])},
+            'finished': {'invisible': Eval('state').in_(['finished'])},
+            'calibrate': {'invisible': Eval('lines_calibration') == () | Eval('state') == 'finished'}
                 })
 
-    @staticmethod
-    def default_company():
-        return Transaction().context.get('company')
-
-    @fields.depends('service_maintenance')
-    def on_change_service_maintenance(self):
-        self.propietary = self.service_maintenance.propietary
-        self.propietary_address = self.service_maintenance.propietary_address
-
-    @fields.depends('equipment', 'patterns_equipments')
-    def on_change_equipment(self):
-        if self.equipment and self.equipment.product.calibration:
-            self.patterns_equipments = self.equipment.product.k_pattern
-        else:
-            self.patterns_equipments = None
-            
-    @classmethod
-    def default_initial_operation(cls):
-       return True
-
-    @classmethod
-    def default_check_equipment(cls):
-       return True
-
-    @classmethod
-    def default_check_electric_system(cls):
-       return True
-
-    @classmethod
-    def default_clean_int_ext(cls):
-       return True
-
-    @classmethod
-    def default_clean_eyes(cls):
-       return True
-
-    @classmethod
-    def default_optical(cls):
-       return True
-
-    @classmethod
-    def default_check_calibration(cls):
-       return True
-        
-    @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('in_progress')
-    def in_progress(cls, maintenances):
-        pass
-
-    @classmethod
-    @ModelView.button
-    @Workflow.transition('finished')
-    def finished(cls, maintenances):
-        raise UserError(str("Esto es una prueba"))
-        pass
-
     @classmethod
     def view_attributes(cls):
         return super(Maintenance, cls).view_attributes() + [
@@ -308,6 +244,361 @@ class Maintenance(Workflow, ModelSQL, ModelView):
             })
          ]
 
+    @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'
+
+    def get_standard_deviation(samples):
+        """
+        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 samples) / (n_samples -1)
+        dev_std = round(mt.sqrt(dev_std_square), 2)
+
+        return dev_std
+
+    def get_uncertain_type_A(samples, dev_std):
+        """
+        This function calculated the
+        uncertain type A
+        """
+        n_samples = len(samples)
+        uncertain_type_A = round(dev_std /mt.sqrt(n_samples),2)
+
+        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
+
+    @fields.depends('service_maintenance')
+    def on_change_service_maintenance(self):
+        self.propietary = self.service_maintenance.propietary
+        self.propietary_address = self.service_maintenance.propietary_address
+
+    @fields.depends('equipment', 'patterns_equipments')
+    def on_change_equipment(self):
+        if self.equipment and self.equipment.product.calibration:
+            self.patterns_equipments = self.equipment.product.k_pattern
+        else:
+            self.patterns_equipments = None
+
+    @classmethod
+    @ModelView.button
+    @Workflow.transition('in_progress')
+    def in_progress(cls, maintenances):
+        pass
+
+    @classmethod
+    @ModelView.button
+    @Workflow.transition('finished')
+    def finished(cls, maintenances):
+        #raise UserError(str("Esto es una prueba"))
+        for maintenance in maintenances:
+            if maintenance.calibration_total == ():
+                raise UserError("No puede finalizar este mantenimiento sin una calibración")
+            else:
+                maintenance.state = 'finished'
+                maintenance.code = maintenance.id
+                maintenance.save()
+
+    @classmethod
+    @ModelView.button
+    def calibrate(cls, maintenances):
+        pool = Pool()
+        CalibrationLineTotal = pool.get('optical_equipment.maintenance.calibration')
+        dates = {}
+        patterns = set()
+
+        for maintenance in maintenances:
+            maintenance.calibration_total = ()
+            if len(maintenance.lines_calibration) < 3:
+                raise UserError("Por favor Ingrese mas de (3) Muestras por patrón (Dioptría)")
+            else:
+                for line in maintenance.lines_calibration:
+                    if line.value_patterns.pattern not in patterns:
+                        patterns.add(line.value_patterns.pattern)
+                        dates[line.value_patterns.pattern] = [line.value_equipment]
+                    else:
+                        dates[line.value_patterns.pattern].append(line.value_equipment)
+                        
+            for pattern in patterns:
+                samples = dates[pattern]
+                U_subi = maintenance.equipment.product.Usubi
+                uncertain_pattern = maintenance.equipment.product.uncertainy_pattern
+                #d_resolution = maintenance.equipment.product.d_resolution
+                d_resolution = 0.25
+                a_resolution = maintenance.equipment.product.a_factor_resolution
+                MEP = maintenance.equipment.product.MEP
+                dev_std = cls.get_standard_deviation(samples)
+                uncertain_type_A = cls.get_uncertain_type_A(samples, dev_std)
+                uncertain_b1 = MEP / mt.sqrt(3)
+                k_certificated_calibration = 2
+                uncertain_b1a = round(uncertain_pattern / k_certificated_calibration, 2)
+                uncertain_b2_digital = round(d_resolution / 2*mt.sqrt(3),2)
+                uncertain_b2_analog = round(d_resolution / a_resolution*mt.sqrt(3),2)
+                sum_uncertain_c = uncertain_type_A**2 + uncertain_b1**2 + uncertain_b2_digital**2
+                uncertain_c = round(mt.sqrt(sum_uncertain_c),2)
+                uncertain_eff = round(uncertain_c**4/((uncertain_type_A**4)/(len(samples)-1)+(uncertain_b1**4/U_subi)+(uncertain_b2_digital**4/U_subi)),2)
+                t_student = round(t.ppf(1-0.025, uncertain_eff),2)
+                uncertain_expanded = round((t_student * uncertain_c),2)
+
+                calibrationLineTotal = CalibrationLineTotal(
+                    dev_std=dev_std,
+                    uncertain_type_A=uncertain_type_A,
+                    uncertain_pattern=uncertain_pattern,
+                    k_c_calibration=k_certificated_calibration,
+                    uncertain_U_b1=uncertain_b1a,
+                    d_resolution=d_resolution,
+                    uncertain_U_b2_dig=uncertain_b2_digital,
+                    uncertain_U_b2_ana=uncertain_b2_analog,
+                    uncertain_combinated=uncertain_c,
+                    uncertain_eff=uncertain_eff,
+                    t_student=t_student,
+                    uncertain_expanded=uncertain_expanded
+                )
+
+                maintenance.calibration_total += (calibrationLineTotal,)
+                maintenance.save()
+    
+
+class Calibration(ModelSQL, ModelView):
+    'Calibration of Maintenance'
+    __name__ = 'optical_equipment.maintenance.calibration'
+
+    _states={'readonly': True}
+    
+    maintenance = fields.Many2One('optical_equipment.maintenance', "Maintenance", ondelete="CASCADE",
+                                  select=True, required=True)
+    dev_std = fields.Float("Standart Desviation",  _digits, states=_states)
+    uncertain_type_A = fields.Float("Uncertain Type A",  _digits, states=_states)
+    uncertain_pattern = fields.Float("Uncertain Pattern",  _digits, states=_states)
+    k_c_calibration = fields.Float("K Crt Calibration",  _digits,states=_states)
+    uncertain_U_b1 = fields.Float("U_b1",  _digits, states=_states)
+    d_resolution = fields.Float("d_resolution",  _digits, states=_states)
+    uncertain_U_b2_dig = fields.Float("U_b2",  _digits, states=_states)
+    uncertain_U_b2_ana = fields.Float("U_b2",  _digits, states=_states)
+    uncertain_combinated = fields.Float("U_combinated",  _digits, states=_states)
+    uncertain_eff = fields.Float("U eff",  _digits, states=_states)
+    t_student = fields.Float("T Student",  _digits, states=_states)
+    uncertain_expanded = fields.Float("Uexpand",  _digits, states=_states)
+
+    
+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.Float("Sample #",  _digits)
+    value_patterns = fields.Many2One('optical_equipment.product_pattern', "Value Pattern", required=True,
+                                    ondelete='RESTRICT')
+    #value_pattern = fields.Float("Value in Pattern")
+    value_equipment = fields.Float("Value in Equipment",  _digits, required=True,
+                                   states={'readonly': Eval('value_patterns') == None})
+    mistake = fields.Float("Mistake",  _digits)
+    mistake_rate = fields.Float("% Mistake",  _digits,
+                                states={'readonly': True},
+                                depends=['mistake'])
+
+    
+    @fields.depends('value_patterns', 'value_equipment',
+                    'mistake', 'mistake_rate')
+    def on_change_value_equipment(self):
+        if float(self.value_patterns.pattern) < 0:
+            self.mistake = self.value_patterns.pattern - self.value_equipment
+        else:
+            if self.value_patterns.pattern > self.value_equipment:
+                self.mistake = self.value_patterns.pattern - self.value_equipment
+            else:
+                self.mistake = -self.value_patterns.pattern + self.value_equipment
+
+        self.mistake_rate = abs(self.mistake / self.value_patterns.pattern) * 100
+        
+
+class AgendedInitial(ModelView):
+    'Agended maintenance service'
+    __name__ = 'optical_equipment_maintenance.agended'
+
+    maintenance_service = fields.Many2One('optical_equipment_maintenance.service',"Maintenaince Service",
+                                          required=True, domain=[('state', '=', 'draft')])
+    estimated_agended = fields.DateTime("Date Maintenance", required=True)
+    technical = fields.Many2One('company.employee', "Technical", required=True)
+    
+class AssingAgended(Wizard):
+    'Assing Agended'
+    __name__ = 'optical_equipment_maintenance.assing_agended'
+
+    start = StateView('optical_equipment_maintenance.agended',
+                      'optical_equipment.assing_agended_view_form', [
+                          Button('Cancel', 'end', 'tryton-cancel'),
+                          Button('Assing', 'assing_agended', 'tryton-ok', default=True),
+                      ])
+
+    assing_agended = StateAction('optical_equipment.act_maintenance_service_form')
+
+    
+    def do_assing_agended(self, action):
+        pool = Pool()
+        Diary = pool.get('optical_equipment_maintenance.diary')
+        Config = pool.get('optical_equipment.configuration')
+        config = Config(3)
+        
+        MaintenanceService = pool.get('optical_equipment_maintenance.service')
+        diary = Diary(code=config.agended_sequence.get(),
+                      maintenance_service=self.start.maintenance_service,
+                      date_expected=self.start.estimated_agended,
+                      date_estimated=self.start.estimated_agended + timedelta(days=15),
+                      date_end=self.start.estimated_agended + timedelta(days=15),
+                      technical=self.start.technical.id,
+                      state='agended')
+        diary.save()
+
+        maintenanceService = self.start.maintenance_service
+        maintenanceService.estimated_agended = self.start.estimated_agended
+        maintenanceService.technical = self.start.technical
+        maintenanceService.state_agended = 'agended'
+        maintenanceService.state = 'agended'
+        maintenanceService.history_agended += (diary.id,)
+        maintenanceService.set_code(maintenanceService)
+        maintenanceService.save()
+        
+        
+class ReAgended(ModelView):
+    'Agended maintenance service'
+    __name__ = 'optical_equipment_maintenance.reagended'
+
+    maintenance_service = fields.Many2One('optical_equipment_maintenance.service',"Maintenaince Service",
+                                          required=True, domain=[('state', '=', 'failed')])
+    estimated_agended = fields.DateTime("Date Maintenance", required=True)
+    technical = fields.Many2One('company.employee', "Technical", required=True)
+
+    
+class ReAssingAgended(Wizard):
+    'Assing Agended'
+    __name__ = 'optical_equipment_maintenance.reassing_agended'
+
+    start = StateView('optical_equipment_maintenance.reagended',
+                      'optical_equipment.reassing_agended_view_form', [
+                          Button('Cancel', 'end', 'tryton-cancel'),
+                          Button('Assing', 'assing_agended', 'tryton-ok', default=True),
+                      ])
+
+    assing_agended = StateAction('optical_equipment.act_maintenance_service_form')
+
+    def do_assing_agended(self, action):
+        pool = Pool()
+        Diary = pool.get('optical_equipment_maintenance.diary')
+        
+        diary = Diary(maintenance_service=self.start.maintenance_service,
+                      date_expected=self.start.estimated_agended,
+                      date_estimated=self.start.estimated_agended + timedelta(days=15),
+                      date_end=self.start.estimated_agended + timedelta(days=15),
+                      technical=self.start.technical.id,
+                      state='agended')
+        diary.save()
+
+        maintenanceService = self.start.maintenance_service
+        maintenanceService.estimated_agended = self.start.estimated_agended
+        maintenanceService.technical = self.start.technical
+        maintenanceService.state_agended = 'agended'
+        maintenanceService.state = 'agended'
+        maintenanceService.history_agended += (diary.id,)
+        maintenanceService.save()
+
+
+class ServiceMaintenanceAgended(ModelSQL):
+    'Service Maintenance - Agended'
+    __name__ = 'optical_equipment_maintenance.service-maintenance.diary'
+
+
+    maintenance_service = fields.Many2One('optical_equipment_maintenance.service', "Maintenance Service")
+    agended = fields.Many2One('optical_equipment_maintenance.diary', "Agended")
+        
+
+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 MaintenanceActivity(ModelView, ModelSQL):
+    'Maintenance Activitys'
+    __name__ = 'optical_equipment_maintenance.activity'
+
+    maintenance = fields.Many2One('optical_equipment.maintenance')
+    product = fields.Many2One('product.product', 'Product',
+                              domain=[('maintenance_activity', '=', True)])
+
+    
 class CreateContractInitial(ModelView, ModelSQL):
     'Create Contract Inicial'
     __name__ = 'optical_equipment_create.contract'
@@ -417,269 +708,3 @@ class CreateContract(Wizard):
                             maintenance_services=prorogues
                             )
         contract.save()
-    
-
-class MaintenanceActivity(ModelView, ModelSQL):
-    'Maintenance Activitys'
-    __name__ = 'optical_equipment_maintenance.activity'
-
-    maintenance = fields.Many2One('optical_equipment.maintenance')
-    product = fields.Many2One('product.product', 'Product',
-                              domain=[('maintenance_activity', '=', True)])
-
-class AgendedInitial(ModelView):
-    'Agended maintenance service'
-    __name__ = 'optical_equipment_maintenance.agended'
-
-    maintenance_service = fields.Many2One('optical_equipment_maintenance.service',"Maintenaince Service",
-                                          required=True, domain=[('state', '=', 'draft')])
-    estimated_agended = fields.DateTime("Date Maintenance", required=True)
-    technical = fields.Many2One('company.employee', "Technical", required=True)
-    
-class AssingAgended(Wizard):
-    'Assing Agended'
-    __name__ = 'optical_equipment_maintenance.assing_agended'
-
-    start = StateView('optical_equipment_maintenance.agended',
-                      'optical_equipment.assing_agended_view_form', [
-                          Button('Cancel', 'end', 'tryton-cancel'),
-                          Button('Assing', 'assing_agended', 'tryton-ok', default=True),
-                      ])
-
-    assing_agended = StateAction('optical_equipment.act_maintenance_service_form')
-
-    
-    def do_assing_agended(self, action):
-        pool = Pool()
-        Diary = pool.get('optical_equipment_maintenance.diary')
-        Config = pool.get('optical_equipment.configuration')
-        config = Config(3)
-        
-        MaintenanceService = pool.get('optical_equipment_maintenance.service')
-        diary = Diary(code=config.agended_sequence.get(),
-                      maintenance_service=self.start.maintenance_service,
-                      date_expected=self.start.estimated_agended,
-                      date_estimated=self.start.estimated_agended + timedelta(days=15),
-                      date_end=self.start.estimated_agended + timedelta(days=15),
-                      technical=self.start.technical.id,
-                      state='agended')
-        diary.save()
-
-        maintenanceService = self.start.maintenance_service
-        maintenanceService.estimated_agended = self.start.estimated_agended
-        maintenanceService.technical = self.start.technical
-        maintenanceService.state_agended = 'agended'
-        maintenanceService.state = 'agended'
-        maintenanceService.history_agended += (diary.id,)
-        maintenanceService.set_code(maintenanceService)
-        maintenanceService.save()
-        
-        
-class ReAgended(ModelView):
-    'Agended maintenance service'
-    __name__ = 'optical_equipment_maintenance.reagended'
-
-    maintenance_service = fields.Many2One('optical_equipment_maintenance.service',"Maintenaince Service",
-                                          required=True, domain=[('state', '=', 'failed')])
-    estimated_agended = fields.DateTime("Date Maintenance", required=True)
-    technical = fields.Many2One('company.employee', "Technical", required=True)
-    
-class ReAssingAgended(Wizard):
-    'Assing Agended'
-    __name__ = 'optical_equipment_maintenance.reassing_agended'
-
-    start = StateView('optical_equipment_maintenance.reagended',
-                      'optical_equipment.reassing_agended_view_form', [
-                          Button('Cancel', 'end', 'tryton-cancel'),
-                          Button('Assing', 'assing_agended', 'tryton-ok', default=True),
-                      ])
-
-    assing_agended = StateAction('optical_equipment.act_maintenance_service_form')
-
-    def do_assing_agended(self, action):
-        pool = Pool()
-        Diary = pool.get('optical_equipment_maintenance.diary')
-        
-        diary = Diary(maintenance_service=self.start.maintenance_service,
-                      date_expected=self.start.estimated_agended,
-                      date_estimated=self.start.estimated_agended + timedelta(days=15),
-                      date_end=self.start.estimated_agended + timedelta(days=15),
-                      technical=self.start.technical.id,
-                      state='agended')
-        diary.save()
-
-        maintenanceService = self.start.maintenance_service
-        maintenanceService.estimated_agended = self.start.estimated_agended
-        maintenanceService.technical = self.start.technical
-        maintenanceService.state_agended = 'agended'
-        maintenanceService.state = 'agended'
-        maintenanceService.history_agended += (diary.id,)
-        maintenanceService.save()
-
-
-class ServiceMaintenanceAgended(ModelSQL):
-    'Service Maintenance - Agended'
-    __name__ = 'optical_equipment_maintenance.service-maintenance.diary'
-
-
-    maintenance_service = fields.Many2One('optical_equipment_maintenance.service', "Maintenance Service")
-    agended = fields.Many2One('optical_equipment_maintenance.diary', "Agended")
-        
-
-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'
-
-    maintenance = fields.Many2One('optical_equipment.maintenance', "Maintenance", ondelete="CASCADE",
-                                  select=True, required=True)
-    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'
-    )
-    
-    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.Float("Sample #")
-    value_patterns = fields.Many2One('optical_equipment.product_pattern', "Value Pattern", required=True,
-                                    ondelete='RESTRICT')
-    #value_pattern = fields.Float("Value in Pattern")
-    value_equipment = fields.Float("Value in Equipment", required=True,
-                                   states={'readonly': Eval('value_patterns') == None})
-    mistake = fields.Float("Mistake")
-    mistake_rate = fields.Float("% Mistake", states={'readonly': True},
-                                depends=['mistake'])
-
-    @fields.depends('value_patterns', 'value_equipment', 'mistake', 'mistake_rate')
-    def on_change_value_equipment(self):
-        if float(self.value_patterns.pattern) < 0:
-            self.mistake = self.value_patterns.pattern - self.value_equipment
-        else:
-            if self.value_patterns.pattern > self.value_equipment:
-                self.mistake = self.value_patterns.pattern - self.value_equipment
-            else:
-                self.mistake = -self.value_patterns.pattern + self.value_equipment
-
-        self.mistake_rate = abs(self.mistake / self.value_patterns.pattern) * 100

maintenance.xml

@@ -103,6 +103,12 @@
 	    <field name="string">Finished</field>
 	    <field name="model" search="[('model', '=', 'optical_equipment.maintenance')]"/>
 	</record>
+	<record model="ir.model.button" id="maintenance_calibrate_button">
+	    <field name="name">calibrate</field>
+	    <field name="string">Calibrate</field>
+	    <field name="model" search="[('model', '=', 'optical_equipment.maintenance')]"/>
+	</record>
+
 	<record model="ir.action.act_window.domain" id="act_maintenance_service_form_domain_draft">
             <field name="name">Draft</field>
             <field name="sequence" eval="10"/>
@@ -170,6 +176,17 @@
             <field name="priority" eval="10"/>
             <field name="name">maintenance_calibration_tree</field>
         </record>
+	<record model="ir.ui.view" id="calibration_total_view_tree">
+            <field name="model">optical_equipment.maintenance.calibration</field>
+            <field name="type">tree</field>
+            <field name="name">calibration_total_tree</field>
+        </record>
+	<record model="ir.ui.view" id="calibration_total_view_form">
+            <field name="model">optical_equipment.maintenance.calibration</field>
+            <field name="type">form</field>
+            <field name="name">calibration_total_form</field>
+        </record>
+
 	<record model="ir.ui.view" id="maintenance_service_view_calendar">
             <field name="model">optical_equipment_maintenance.service</field>
             <field name="type">calendar</field>

product.py

@@ -156,7 +156,7 @@ class Template(metaclass=PoolMeta):
     warranty = fields.Integer("Warranty")
 
     #### calibration parameters
-
+    MEP = fields.Float("MEP")
     uncertainy_pattern = fields.Float("Uncertainy Pattern",
                                      help="Agregar valores separados por ',' Ej:-5,+5,-10,+10")
     k_pattern = fields.Char("K Pattern",
@@ -178,6 +178,7 @@ class Template(metaclass=PoolMeta):
                                 depends=['resolution_type'])
     Usubi = fields.Integer("Usub i")
 
+
     @classmethod
     def view_attributes(cls):
         return super(Template, cls).view_attributes() + [

view/maintenance_form.xml

@@ -59,6 +59,8 @@
 	    <newline/>
 	    <group colspan="6" yexpand="1" id="lines_calibration">
 		<field name="lines_calibration"/>
+		<newline/>		
+		<field name="calibration_total"/>
 	    </group>
 	</page>
     </notebook>
@@ -68,5 +70,6 @@
     <group id="button">
       <button name="in_progress"/>
       <button name="finished"/>
+      <button name="calibrate"/>
     </group>
 </form>

view/template_form.xml

@@ -61,6 +61,9 @@ this repository contains the full copyright notices and license terms. -->
 	    <label name="k_pattern_list"/>
 	    <field name="k_pattern_list"/>
 	    <newline/>
+	    <label name="MEP"/>
+	    <field name="MEP"/>
+	    <newline/>
 	    <label name="resolution_type"/>
 	    <field name="resolution_type"/>
 	    <newline/>