← Back to branch summary

~daviddiz/+junk/sistema_de_gestion_6.0

« back to all changes in this revision

Viewing changes to sg_formacion/sg_formacion.py

  • Committer: David Diz
  • Date: 2012-09-12 07:27:52 UTC
  • Revision ID: ddiz@8wlz3n1-20120912072752-sz6iy9zs3o6uo41y
Commit inicial

Show diffs side-by-side

added added

removed removed

Lines of Context:
sg_formacion/sg_formacion.py
 
1
# -*- encoding: utf-8 -*-
 
2
##############################################################################
 
3
#
 
4
#    OpenERP, Open Source Management Solution   
 
5
#    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>). All Rights Reserved
 
6
#    $Id$
 
7
#
 
8
#    This program is free software: you can redistribute it and/or modify
 
9
#    it under the terms of the GNU General Public License as published by
 
10
#    the Free Software Foundation, either version 3 of the License, or
 
11
#    (at your option) any later version.
 
12
#
 
13
#    This program is distributed in the hope that it will be useful,
 
14
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
#    GNU General Public License for more details.
 
17
#
 
18
#    You should have received a copy of the GNU General Public License
 
19
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
#
 
21
##############################################################################
 
22
 
 
23
from osv import osv, fields
 
24
import netsvc
 
25
import time
 
26
import pooler
 
27
import wizard
 
28
 
 
29
class hr_employee_estudios(osv.osv):
 
30
    _name = 'hr.employee.estudios'
 
31
    _description = 'Estudios que posee el empleado'
 
32
    _columns = {
 
33
        'descripcion': fields.text("Descripción"),
 
34
        'empleado': fields.many2one('hr.employee', 'Empleado', ondelete='cascade'),        
 
35
    }    
 
36
    
 
37
hr_employee_estudios()
 
38
 
 
39
class hr_employee_experiencia(osv.osv):
 
40
    _name = 'hr.employee.experiencia'
 
41
    _description = 'Experiencia que posee el empleado'
 
42
    _columns = {
 
43
        'descripcion': fields.text("Descripción"),
 
44
        'empleado': fields.many2one('hr.employee', 'Empleado', ondelete='cascade'),        
 
45
    }    
 
46
    
 
47
hr_employee_experiencia()
 
48
 
 
49
class hr_department(osv.osv):
 
50
    _inherit = "hr.department"
 
51
    _columns = {
 
52
#        'miembros_ids': fields.many2many('hr.employee', 'sg_formacion_department_employee_rel', 'department_id', 'employee_id', 'Miembros'),
 
53
#        'director_id': fields.many2one('hr.employee', 'Director'),
 
54
        'empleado_ids': fields.one2many('sg.formacion.department.employee','departamento_id', 'Empleados del departamento'),
 
55
    }
 
56
    
 
57
hr_department()
 
58
 
 
59
class sg_formacion_plan_anual(osv.osv):
 
60
    _name = 'sg.formacion.plan.anual'
 
61
    _description = 'Plan Anual de Formación'
 
62
    _columns = {
 
63
        'name' : fields.char("Nombre", size=145),
 
64
        'ano': fields.char("Año", size=5, required=True),
 
65
        'aprobado': fields.boolean('¿Aprobado?', help="¿Ha sido aprobado el plan anual?"),
 
66
        'fecha_aprobacion': fields.date('Fecha de Aprobación'),
 
67
        'responsable_aprobacion': fields.char("Responsable de la Aprobación", size=445),
 
68
        'observaciones': fields.text('Notas'), 
 
69
        'registros_ids': fields.one2many('sg.formacion.plan.anual.registro', 'plan_anual_id', 'Cursos de Formación del Plan'),
 
70
        'user_id': fields.many2one('res.users','Usuario', readonly=True),      
 
71
    }
 
72
    
 
73
    _defaults = {
 
74
        'ano': lambda *a: time.strftime('%Y'),
 
75
        'aprobado': lambda *a: False,
 
76
        'user_id': lambda self, cr, uid, context: uid,
 
77
    }
 
78
 
 
79
sg_formacion_plan_anual()
 
80
 
 
81
class sg_formacion_plan_anual_registro(osv.osv):
 
82
    _name = 'sg.formacion.plan.anual.registro'
 
83
    _description = 'Registros del Plan Anual de Formación'
 
84
    _columns = {
 
85
        'curso': fields.char("Curso", size=445, required=True, help="Nombre del curso de formación planeado."),
 
86
        'duracion': fields.integer('Duración', help="Duración del curso (en horas)."),
 
87
        'impartido': fields.char("Impartido por", size=445, help="Persona o personas que impartirán el curso."),
 
88
        'destinatario': fields.char("Destinatario", size=445, help="Persona o colectivo a los que va dirigido el curso"),
 
89
        #el destinatario puede ser un empleado o un departamento ¿enlazar?
 
90
        'fecha_inicio': fields.date("Fecha de Inicio Prevista"),
 
91
        'tipo': fields.selection([("I","Planificación inicial"),("A","Ampliación de la planificación")],"Momento de la Planificación"),
 
92
        'tematica': fields.char("Temática del curso", size=445, required=True, help="Temática sobre la que versará el curso."),
 
93
        'plan_anual_id': fields.many2one('sg.formacion.plan.anual', 'Plan Anual de Formación', required=True, ondelete='cascade'),
 
94
        'state': fields.selection([('planeada','Planeada'),('realizada','Realizada')],'Estado', select=True, readonly=True),
 
95
        'registro_ids': fields.one2many('sg.formacion.registro', 'registro_id', 'Registros de formación creados a partir del curso planeado'),
 
96
    }
 
97
    
 
98
    _defaults = {
 
99
        'tipo': lambda *a: 'I',
 
100
        'state': lambda *a: 'planeada',
 
101
    }
 
102
 
 
103
sg_formacion_plan_anual_registro()
 
104
 
 
105
class sg_formacion_perfil_puesto(osv.osv):
 
106
    _name = 'sg.formacion.perfil.puesto'
 
107
    _description = 'Perfil de puestos de trabajo'
 
108
    _columns = {
 
109
        'name': fields.char("Nombre del puesto", size=145, required=True),
 
110
        'dependencia': fields.many2one('sg.formacion.perfil.puesto', 'Dependencia', help="Puesto del cual depende el actual."),
 
111
#        'departamento': fields.char("Departamento", size=45),
 
112
        'aprobado': fields.boolean('¿Aprobado?', help="¿Ha sido aprobado?"),
 
113
        'fecha_aprobacion': fields.date('Fecha de Aprobación'),
 
114
        'responsable_aprobacion': fields.char("Responsable de la Aprobación", size=445),
 
115
        'notas': fields.text('Notas'),
 
116
        'departamento': fields.many2one('hr.department', 'Departamento', help="Departamento al que pertenece el perfil de puesto"),
 
117
        #'empleados_ids': fields.many2many('hr.employee', 'sg_formacion_perfil_employee_rel', 'perfil_puesto_id', 'employee_id', 'Empleados que están o estuvieron en el puesto'),
 
118
        'fun_ids': fields.one2many('sg.formacion.perfil.puesto.fun', 'perfil_puesto_id', 'Funciones del Puesto'),
 
119
        'formacion_necesaria_ids': fields.one2many('sg.formacion.perfil.puesto.formacion.necesaria', 'perfil_puesto_id', 'Requisitos de Formación Necesarios'),
 
120
        'formacion_adicional_ids': fields.one2many('sg.formacion.perfil.puesto.formacion.adicional', 'perfil_puesto_id', 'Requisitos de Formación Adicionales'),
 
121
        'experiencia_ids': fields.one2many('sg.formacion.perfil.puesto.experiencia', 'perfil_puesto_id', 'Requisitos de Experiencia'),
 
122
        'empleado_ids': fields.one2many('sg.formacion.perfil.employee','perfil_id', 'Empleados que desempeñan el puesto o lo hicieron.'),
 
123
    }
 
124
 
 
125
sg_formacion_perfil_puesto()
 
126
 
 
127
class sg_formacion_perfil_puesto_fun(osv.osv):
 
128
    _name = 'sg.formacion.perfil.puesto.fun'
 
129
    _description = 'Funciones del puesto de trabajo'
 
130
    _columns = {
 
131
        'descripcion': fields.char("Descripción de la función", size=445, help="Descripción de la función a realizar en el puesto de trabajo"),
 
132
        'perfil_puesto_id': fields.many2one('sg.formacion.perfil.puesto', 'Perfil del Puesto', ondelete='cascade'),
 
133
    }
 
134
 
 
135
sg_formacion_perfil_puesto_fun()
 
136
 
 
137
class sg_formacion_perfil_puesto_formacion_necesaria(osv.osv):
 
138
    _name = 'sg.formacion.perfil.puesto.formacion.necesaria'
 
139
    _description = 'Formación necesaria en el puesto de trabajo'
 
140
    _columns = {
 
141
        'descripcion': fields.char("Descripción de la formación necesaria", size=445, help="Descripción de la formación necesaria en el puesto de trabajo"),
 
142
        'perfil_puesto_id': fields.many2one('sg.formacion.perfil.puesto', 'Perfil del Puesto', ondelete='cascade'),
 
143
    }
 
144
 
 
145
sg_formacion_perfil_puesto_formacion_necesaria()
 
146
 
 
147
class sg_formacion_perfil_puesto_formacion_adicional(osv.osv):
 
148
    _name = 'sg.formacion.perfil.puesto.formacion.adicional'
 
149
    _description = 'Formación adicional en el puesto de trabajo'
 
150
    _columns = {
 
151
        'descripcion': fields.char("Descripción de la formación adicional", size=445, help="Descripción de la formación adicional conveniente para el puesto de trabajo"),
 
152
        'perfil_puesto_id': fields.many2one('sg.formacion.perfil.puesto', 'Perfil del Puesto', ondelete='cascade'),
 
153
    }
 
154
 
 
155
sg_formacion_perfil_puesto_formacion_adicional()
 
156
 
 
157
class sg_formacion_perfil_puesto_experiencia(osv.osv):
 
158
    _name = 'sg.formacion.perfil.puesto.experiencia'
 
159
    _description = 'Experiencia necesaria para el puesto de trabajo'
 
160
    _columns = {
 
161
        'descripcion': fields.char("Descripción de la experiencia", size=445, help="Descripción de la experiencia necesaria en el puesto de trabajo"),
 
162
        'perfil_puesto_id': fields.many2one('sg.formacion.perfil.puesto', 'Perfil del Puesto', ondelete='cascade'),
 
163
    }
 
164
 
 
165
sg_formacion_perfil_puesto_experiencia()
 
166
 
 
167
class sg_formacion_registro(osv.osv):
 
168
    
 
169
    def _valoracion_media(self, cr, uid, ids, field_name, arg, context={}):
 
170
        res={}
 
171
        for sg_formacion_registro in self.browse(cr,uid,ids):
 
172
            media = 0.0
 
173
            val=0.0
 
174
            numemp = 0
 
175
            for sg_formacion_registro_employee in sg_formacion_registro.empleado_ids:
 
176
                val1 = sg_formacion_registro_employee.valoracion_objetivos
 
177
                val2 = sg_formacion_registro_employee.valoracion_conocimientos
 
178
                if val1 and val2:
 
179
                    val = (float(val1)+float(val2))/2
 
180
                    media += val
 
181
                    numemp += 1
 
182
        if not numemp:
 
183
            res[sg_formacion_registro.id] = 0
 
184
        else:
 
185
            res[sg_formacion_registro.id] = media / numemp        
 
186
        return res
 
187
    
 
188
    def _valoracion_media_responsable(self, cr, uid, ids, field_name, arg, context={}):
 
189
        res={}
 
190
        for sg_formacion_registro in self.browse(cr,uid,ids):
 
191
            media = 0.0
 
192
            val=0.0
 
193
            numemp = 0
 
194
            for sg_formacion_registro_employee in sg_formacion_registro.empleado_ids:
 
195
                val = sg_formacion_registro_employee.valoracion_res_alum
 
196
                if val:
 
197
                    val = float(val)
 
198
                    media += val
 
199
                    numemp += 1
 
200
        if not numemp:
 
201
            res[sg_formacion_registro.id] = 0
 
202
        else:
 
203
            res[sg_formacion_registro.id] = media / numemp        
 
204
        return res
 
205
    
 
206
    _name = 'sg.formacion.registro'
 
207
    _description = 'Curso'
 
208
    _columns = {
 
209
        'name': fields.char("Denominación del curso", size=145, required=True),
 
210
        'descripcion': fields.char("Descripción de la formación", size=445, help="Descripción de la formación"),
 
211
        'duracion': fields.integer('Duración (Horas)', help="Duración del curso (en horas)."),
 
212
        'fecha_inicio': fields.date("Fecha de Inicio"),
 
213
        'fecha_fin': fields.date("Fecha de Fin"),
 
214
        'tipo': fields.selection([("I","Interna (impartida por personal de la empresa)"),("E","Externa (impartida por personal ajeno a la empresa)")], "Tipo", required=True, help="INTERNA:impartida por personal de la empresa  o  EXTERNA:impartida por personal ajeno a la empresa."),
 
215
        'impartido': fields.char("Docente (será personal ajeno a la empresa al ser el curso de tipo Externo)", size=445, help="Persona o personas que impartirán el curso."),
 
216
        'empleado_profesor_id': fields.many2one('hr.employee', 'Docente (será un empleado al ser el curso de tipo Interno)', help="Persona o personas que impartirán el curso."),
 
217
        'lugar': fields.char("Lugar", size=445, help="Lugar donde se realizará la formación."),
 
218
        #'empleado_ids': fields.many2many('hr.employee', 'sg_formacion_registro_employee_rel', 'registro_id', 'employee_id',  'Alumnos'),
 
219
        'observaciones': fields.text('Observaciones'),
 
220
        'valoracion_total': fields.function(_valoracion_media, method=True, string='Valoración media del curso por los alumnos (0-10)', digits=(4,2), type='float', readonly=True),
 
221
        'valoracion_observaciones': fields.text('Notas sobre la Valoración', help="Comentario sobre satisfacción y valoración general del curso."),
 
222
        'responsable_valoracion': fields.char("Responsable de la Valoración del Curso", size=445),
 
223
#        'valoracion_responsable': fields.integer("Valoración global del curso por el responsable (0-10)"),
 
224
        'valoracion_responsable': fields.function(_valoracion_media_responsable, method=True, string='Valoración global del curso por el responsable (0-10)', digits=(4,2), type='float', readonly=True),
 
225
        'empleado_ids': fields.one2many('sg.formacion.registro.employee', 'registro_id', 'Valoración de los cursos por los alumnos'),
 
226
        'registro_id': fields.many2one('sg.formacion.plan.anual.registro', 'Registro del plan anual del que procede'),
 
227
    }
 
228
    
 
229
    _defaults = {
 
230
        'tipo': lambda *a: 'I',
 
231
    }
 
232
 
 
233
sg_formacion_registro()
 
234
 
 
235
class hr_employee(osv.osv):
 
236
    _inherit = "hr.employee"
 
237
    _columns = {
 
238
        #'formacion_ids': fields.many2many('sg.formacion.registro', 'sg_formacion_registro_employee_rel', 'employee_id', 'registro_id', 'Alumnos'),
 
239
        #'departamentos_ids': fields.many2many('hr.department', 'sg_formacion_department_employee_rel', 'employee_id', 'department_id', 'Pertenece o ha pertenecido a los departamentos'),
 
240
        #'perfiles_ids': fields.many2many('sg.formacion.perfil.puesto', 'sg_formacion_perfil_employee_rel', 'employee_id', 'perfil_puesto_id', 'Perfiles de Puestos Desempeñados'),
 
241
        'dni': fields.char("DNI", size=32),
 
242
        'contratacion_ids': fields.one2many('sg.formacion.contratacion','empleado_id', 'Periodos de alta en la empresa'),
 
243
        'estudios': fields.one2many('hr.employee.estudios', 'empleado', 'Estudios'),
 
244
        'experiencia': fields.one2many('hr.employee.experiencia', 'empleado', 'Experiencia'),
 
245
        'registro_ids': fields.one2many('sg.formacion.registro.employee','empleado_id', 'Valoración de los cursos por los alumnos'),
 
246
#        'departamento_ids': fields.one2many('sg.formacion.department.employee','empleado_id', 'Departamentos a los que pertenece'),
 
247
        'perfil_ids': fields.one2many('sg.formacion.perfil.employee','empleado_id', 'Perfiles de puesto a los que pertenece o ha pertenecido.'),
 
248
    }
 
249
    
 
250
hr_employee()
 
251
 
 
252
class sg_formacion_contratacion(osv.osv):
 
253
    _name = 'sg.formacion.contratacion'
 
254
    _columns = {
 
255
        'empleado_id': fields.many2one('hr.employee', 'Empleado'),
 
256
        'alta': fields.date("Fecha de Alta"),
 
257
        'baja': fields.date("Fecha de Baja"),
 
258
    }  
 
259
    
 
260
    _defaults = {
 
261
        'alta': lambda *a: time.strftime('%Y-%m-%d'),
 
262
    }
 
263
    
 
264
sg_formacion_contratacion()
 
265
 
 
266
 
 
267
class sg_formacion_registro_employee(osv.osv):
 
268
    _name = 'sg.formacion.registro.employee'
 
269
    _columns = {
 
270
        'empleado_id': fields.many2one('hr.employee', 'Empleado', required=True, ondelete='cascade'),
 
271
        'registro_id': fields.many2one('sg.formacion.registro', 'Curso', required=True, ondelete='cascade'),
 
272
        #'valoracion_res_alum': fields.integer("Valoración numérica del alumno por parte del responsable (0-10)"),
 
273
        'valoracion_res_alum': fields.selection([("0","0"),("1","1"),("2","2"),("3","3"),("4","4"),("5","5"),("6","6"),("7","7"),("8","8"),("9","9"),("10","10")],"Valoración numérica del alumno por parte del responsable (0-10)"),
 
274
        'fecha': fields.date('Fecha'),
 
275
        'valoracion_objetivos': fields.selection([("0","0"),("1","1"),("2","2"),("3","3"),("4","4"),("5","5"),("6","6"),("7","7"),("8","8"),("9","9"),("10","10")],"¿Se han conseguido los objetivos del curso? Respuesta del Alumno (0-10)"),
 
276
        'valoracion_conocimientos': fields.selection([("0","0"),("1","1"),("2","2"),("3","3"),("4","4"),("5","5"),("6","6"),("7","7"),("8","8"),("9","9"),("10","10")],"¿Nivel de conocimientos adquiridos? Respuesta del Alumno (0-10)"),
 
277
    }  
 
278
    
 
279
    _defaults = {
 
280
        'fecha': lambda *a: time.strftime('%Y-%m-%d'),
 
281
    }
 
282
    
 
283
    def create(self, cr, uid, vals, context={}):
 
284
        a= 0
 
285
        return super(sg_formacion_registro_employee, self).create(cr, uid, vals, context)
 
286
    
 
287
sg_formacion_registro_employee()
 
288
 
 
289
class sg_formacion_department_employee(osv.osv):
 
290
    #_inherit = "sg.formacion.department.employee.rel"
 
291
    _name = 'sg.formacion.department.employee'
 
292
    _columns = {
 
293
        'empleado_id': fields.many2one('hr.employee', 'Empleado'),
 
294
        'departamento_id': fields.many2one('hr.department', 'Departamento'),
 
295
        'fecha_inicio': fields.date("Fecha de Inicio"),
 
296
        'fecha_fin': fields.date("Fecha de Fin"),
 
297
    }
 
298
    
 
299
sg_formacion_department_employee()
 
300
 
 
301
class sg_formacion_perfil_employee(osv.osv):
 
302
    #_inherit = "sg.formacion.perfil.employee.rel"
 
303
    _name = 'sg.formacion.perfil.employee'
 
304
    _columns = {
 
305
        'empleado_id': fields.many2one('hr.employee', 'Empleado'),
 
306
        'perfil_id': fields.many2one('sg.formacion.perfil.puesto', 'Perfil de Puesto'),
 
307
        'fecha_inicio': fields.date("Fecha de Inicio"),
 
308
        'fecha_fin': fields.date("Fecha de Fin"),
 
309
    }
 
310
    
 
311
sg_formacion_perfil_employee()
 
312
 
 
313
 
 
314
class ejecutar_formacion_planeada(osv.osv_memory):
 
315
    _name = 'ejecutar.formacion.planeada'
 
316
    _description = 'Ejecutar formación planeada'
 
317
    
 
318
    _columns = {
 
319
        'type': fields.selection([('I','Interna (impartida por personal de la empresa)'), 
 
320
                                  ('E','Externa (impartida por personal ajeno a la empresa)')], 'Tipo de Formación'),
 
321
    }
 
322
    
 
323
    _defaults = {
 
324
        'type': lambda *a:'I',
 
325
    }
 
326
    
 
327
    def crear_y_abrir_registro_formacion(self, cr, uid, ids, context):
 
328
        idregistro = 0
 
329
        pool_obj = pooler.get_pool(cr.dbname)
 
330
        obj_plan_registro = pool_obj.get('sg.formacion.plan.anual.registro')
 
331
#       lanzo una excepción si se intenta crear un curso de formación sin haber guardado antes el registro del plan anual del cual procede 
 
332
        if not context['record_id']:
 
333
#            raise wizard.except_wizard(('Warning'), ('Debe guardarse el registro del plan anual de formación\nantes de crear un curso a partir de él.'))
 
334
            return {'type':'ir.actions.act_window_close'}
 
335
        data_plan_registro = obj_plan_registro.browse(cr, uid, context['record_id'], context=context)
 
336
        registro = pool_obj.get('sg.formacion.registro')
 
337
        tipo = self.browse(cr, uid, ids[0]).type
 
338
        clave = registro.create(cr, uid, {
 
339
                                  'name': data_plan_registro.curso,
 
340
                                  'descripcion': data_plan_registro.tematica,
 
341
                                  'duracion': data_plan_registro.duracion,
 
342
                                  'tipo': tipo,
 
343
                                  'registro_id': data_plan_registro.id,
 
344
                                  'fecha_inicio': time.strftime('%Y-%m-%d'),
 
345
                                  }) 
 
346
        idregistro = registro.search(cr, uid, [('id','=',clave)])
 
347
#        netsvc.Logger().notifyChannel('sg.formacion.registro', netsvc.LOG_INFO, '%s/n'%idregistro)
 
348
        pool_obj = pooler.get_pool(cr.dbname)
 
349
#        ahora tengo que poner como realizado el registro del plan anual que acabo de convertir en curso real
 
350
        obj_plan_registro.write(cr, uid, data_plan_registro.id, {'state':'realizada'})
 
351
        model_data_ids = pool_obj.get('ir.model.data').search(cr,uid,[('model','=','ir.ui.view'),('name','=','view_registro_form')])
 
352
        resource_id = pool_obj.get('ir.model.data').read(cr,uid,model_data_ids,fields=['res_id'])[0]['res_id']
 
353
        result = {
 
354
                'domain': "[('id','=', %d)]"%idregistro[0],
 
355
                'name': 'Curso Creado',
 
356
                'view_type': 'form',
 
357
                'view_mode': 'tree,form',
 
358
                'res_model': 'sg.formacion.registro',
 
359
                'views': [(False,'tree'),(resource_id,'form')],
 
360
                'type': 'ir.actions.act_window',
 
361
                'target': 'new',
 
362
        }
 
363
        return result
 
364
    
 
365
ejecutar_formacion_planeada()
 
366
 
 
367
#vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: