← Back to branch summary

~openerp-commiter/openobject-addons/trunk-extra-addons

« back to all changes in this revision

Viewing changes to hr_skill/hr_skill.py

merging new development from indian accounting

Show diffs side-by-side

added added

removed removed

Lines of Context:
hr_skill/hr_skill.py
 
1
# -*- encoding: utf-8 -*-
1
2
##############################################################################
2
3
#
3
4
# Copyright (c) 2004 TINY SPRL. (http://tiny.be) All Rights Reserved.
37
38
# Wheight Category
38
39
# eg: years, in english, ..
39
40
class hr_skill_weight_category(osv.osv):
40
 
        _name ='hr_skill.weight.category'
41
 
        _columns = {
42
 
                'name': fields.char('Name', size=64, required=True),
43
 
                }
 
41
    _name ='hr_skill.weight.category'
 
42
    _columns = {
 
43
        'name': fields.char('Name', size=64, required=True),
 
44
        }
44
45
 
45
46
hr_skill_weight_category()
46
47
 
48
49
# weight
49
50
# eg: 0 to 1, more than 5, good, bad
50
51
class hr_skill_weight(osv.osv):
51
 
        _name ='hr_skill.weight'
52
 
        _columns = {
53
 
                'name': fields.char('Name', size=64,required=True),
54
 
                'value': fields.float('Numerical value', required=True), 
55
 
                'category_id': fields.many2one('hr_skill.weight.category', 'Category', required=True, ondelete='cascade'),
56
 
                }# hr_skill.category ne passe pas (cad creation des tables) la premiere fois (hr_skill_category bien)
 
52
    _name ='hr_skill.weight'
 
53
    _columns = {
 
54
        'name': fields.char('Name', size=64,required=True),
 
55
        'value': fields.float('Numerical value', required=True), 
 
56
        'category_id': fields.many2one('hr_skill.weight.category', 'Category', required=True, ondelete='cascade'),
 
57
        }# hr_skill.category ne passe pas (cad creation des tables) la premiere fois (hr_skill_category bien)
57
58
 
58
59
hr_skill_weight()
59
60
 
63
64
#      Langage, IT (->view)       
64
65
# Categories of weight
65
66
class hr_skill_skill(osv.osv):
66
 
        _name = 'hr_skill.skill'
67
 
        _columns = {
68
 
                'name': fields.char('Name', size=64,required=True), 
69
 
                'active': fields.boolean('Active'), 
70
 
                'weight': fields.float('Weight', required=True),
71
 
                'weight_category_id': fields.many2one('hr_skill.weight.category','Weight Category'),
72
 
                'parent_id': fields.many2one('hr_skill.skill', 'Parent', ondelete='cascade'),
73
 
                'child_ids': fields.one2many('hr_skill.skill', 'parent_id', 'Childs'),
74
 
                'view': fields.selection([('view','View'), ('skill','Skill')], 'Skill', required=True),
75
 
        }
76
 
        _defaults = {
77
 
                'view': lambda self,cr,uid,context: 'view',
78
 
                'weight': lambda self,cr,uid,context: 0,
79
 
                'active': lambda self,cr,uid,context: 1
80
 
        }
 
67
    _name = 'hr_skill.skill'
 
68
    _columns = {
 
69
        'name': fields.char('Name', size=64,required=True), 
 
70
        'active': fields.boolean('Active'), 
 
71
        'weight': fields.float('Weight', required=True),
 
72
        'weight_category_id': fields.many2one('hr_skill.weight.category','Weight Category'),
 
73
        'parent_id': fields.many2one('hr_skill.skill', 'Parent', ondelete='cascade'),
 
74
        'child_ids': fields.one2many('hr_skill.skill', 'parent_id', 'Childs'),
 
75
        'view': fields.selection([('view','View'), ('skill','Skill')], 'Skill', required=True),
 
76
    }
 
77
    _defaults = {
 
78
        'view': lambda self,cr,uid,context: 'view',
 
79
        'weight': lambda self,cr,uid,context: 0,
 
80
        'active': lambda self,cr,uid,context: 1
 
81
    }
81
82
hr_skill_skill()
82
83
 
83
84
 
85
86
# Experience category
86
87
# eg : a degree or a professional experience
87
88
class hr_skill_experience_category(osv.osv):
88
 
        _name ='hr_skill.experience.category'
89
 
        _columns = {
90
 
                'name': fields.char('Name', size=64,required=True),
91
 
        }
 
89
    _name ='hr_skill.experience.category'
 
90
    _columns = {
 
91
        'name': fields.char('Name', size=64,required=True),
 
92
    }
92
93
hr_skill_experience_category()
93
94
 
94
95
 
96
97
# eg : a specific former job position or studies  
97
98
# each experience is associated with several couple skill - weight 
98
99
class hr_skill_experience(osv.osv):
99
 
        _name ='hr_skill.experience'
100
 
        _columns = {
101
 
                'name': fields.char('Name', size=64,required=True),
102
 
                'skill_ids': fields.one2many('hr_skill.experience.skill','experience_id','Skills'),
103
 
                'sequence': fields.integer('Sequence'),
104
 
                'category_id' : fields.many2one('hr_skill.experience.category', 'Category'),
105
 
        }
 
100
    _name ='hr_skill.experience'
 
101
    _columns = {
 
102
        'name': fields.char('Name', size=64,required=True),
 
103
        'skill_ids': fields.one2many('hr_skill.experience.skill','experience_id','Skills'),
 
104
        'sequence': fields.integer('Sequence'),
 
105
        'category_id' : fields.many2one('hr_skill.experience.category', 'Category'),
 
106
    }
106
107
hr_skill_experience()
107
108
 
108
109
 
109
110
# Evaluation Category
110
111
class hr_skill_evaluation_category(osv.osv):
111
 
        _name ='hr_skill.evaluation.category'
112
 
        _columns = {
113
 
                'name': fields.char('Name', size=64,required=True),
114
 
        }
 
112
    _name ='hr_skill.evaluation.category'
 
113
    _columns = {
 
114
        'name': fields.char('Name', size=64,required=True),
 
115
    }
115
116
hr_skill_evaluation_category()
116
117
 
117
118
# Evaluation
118
119
class hr_skill_evaluation(osv.osv):
119
 
        _name ='hr_skill.evaluation'
120
 
        _columns = {
121
 
                'name': fields.char('Evaluation name', size=64,required=True),
122
 
                'date': fields.date('Date',required=True),
123
 
                'interviewer_name': fields.char('Evaluator', size=64,required=True),
124
 
                'interviewee_name': fields.char('Evaluated People', size=64,required=True),
125
 
                'employee_id': fields.many2one('hr.employee', 'Evaluated Employee'),
126
 
                'note': fields.text('Notes'),
127
 
                'reference': fields.char('Reference', size=64),
128
 
                'category_id': fields.many2one('hr_skill.evaluation.category', 'Category', change_default=True),
129
 
                'experience_ids': fields.one2many('hr_skill.evaluation.experience','evaluation_id','Experience'),
130
 
                'skill_ids': fields.one2many('hr_skill.evaluation.skill','evaluation_id','Skill'),
 
120
    _name ='hr_skill.evaluation'
 
121
    _columns = {
 
122
        'name': fields.char('Evaluation name', size=64,required=True),
 
123
        'date': fields.date('Date',required=True),
 
124
        'interviewer_name': fields.char('Evaluator', size=64,required=True),
 
125
        'interviewee_name': fields.char('Evaluated People', size=64,required=True),
 
126
        'employee_id': fields.many2one('hr.employee', 'Evaluated Employee'),
 
127
        'note': fields.text('Notes'),
 
128
        'reference': fields.char('Reference', size=64),
 
129
        'category_id': fields.many2one('hr_skill.evaluation.category', 'Category', change_default=True),
 
130
        'experience_ids': fields.one2many('hr_skill.evaluation.experience','evaluation_id','Experience'),
 
131
        'skill_ids': fields.one2many('hr_skill.evaluation.skill','evaluation_id','Skill'),
131
132
 
132
 
        }
133
 
        def onchange_employee_id(self, cr, uid, ids, employee_id):
134
 
                if not employee_id:
135
 
                        return {}
136
 
                empl = self.pool.get('hr.employee').browse(cr, uid, employee_id)
137
 
                return {'value': {'interviewee_name':empl.name} }
138
 
        
 
133
    }
 
134
    def onchange_employee_id(self, cr, uid, ids, employee_id):
 
135
        if not employee_id:
 
136
            return {}
 
137
        empl = self.pool.get('hr.employee').browse(cr, uid, employee_id)
 
138
        return {'value': {'interviewee_name':empl.name} }
 
139
    
139
140
hr_skill_evaluation()
140
141
 
141
142
# Profile
142
143
# eg : management, web-dev.
143
144
# each profile is associated with several couple skill - weight
144
145
class hr_skill_profile(osv.osv):
145
 
        _name ='hr_skill.profile'
146
 
        _columns = {
147
 
                'name': fields.char('Name', size=64, required=True),
148
 
                'skill_ids': fields.one2many('hr_skill.profile.skill','profile_id','Skills'),
149
 
        }
 
146
    _name ='hr_skill.profile'
 
147
    _columns = {
 
148
        'name': fields.char('Name', size=64, required=True),
 
149
        'skill_ids': fields.one2many('hr_skill.profile.skill','profile_id','Skills'),
 
150
    }
150
151
hr_skill_profile()
151
152
 
152
153
 
154
155
# eg : Senior web-dev, junior logistician
155
156
# a position is associated to one (or several) profile
156
157
class hr_skill_position(osv.osv):
157
 
        _name ='hr_skill.position'
158
 
        _columns = {
159
 
                'name': fields.char('Name', size=64, required=True), 
160
 
                'employee_id': fields.many2one('hr.employee', 'Assigned Employee'),# ?? pq un many2one ?
161
 
                'profile_ids': fields.one2many('hr_skill.position.profile', 'position_id', 'Profiles'),
162
 
                'status': fields.selection([('open','Open'), ('assigned','Assigned'), ('unused','Unused')], 'Status'),
163
 
        }
 
158
    _name ='hr_skill.position'
 
159
    _columns = {
 
160
        'name': fields.char('Name', size=64, required=True), 
 
161
        'employee_id': fields.many2one('hr.employee', 'Assigned Employee'),# ?? pq un many2one ?
 
162
        'profile_ids': fields.one2many('hr_skill.position.profile', 'position_id', 'Profiles'),
 
163
        'status': fields.selection([('open','Open'), ('assigned','Assigned'), ('unused','Unused')], 'Status'),
 
164
    }
164
165
hr_skill_position()
165
166
 
166
167
 
167
168
 
168
169
# definitition des relations :
169
170
class hr_skill_position_profile(osv.osv):
170
 
        _name ='hr_skill.position.profile'
171
 
        _columns = {
172
 
                'name': fields.char('Name', size=64),
173
 
                'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
174
 
                'position_id': fields.many2one('hr_skill.position','Position', ondelete='cascade',required=True),
175
 
                'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True) ,
176
 
        }
177
 
        def onchange_profile_id(self, cr, uid, ids, profile_id):
178
 
                if not profile_id:
179
 
                        return {}
180
 
                prof = self.pool.get('hr_skill.profile').browse(cr, uid, profile_id)
181
 
                return {'value': {'name':prof.name} }
 
171
    _name ='hr_skill.position.profile'
 
172
    _columns = {
 
173
        'name': fields.char('Name', size=64),
 
174
        'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
 
175
        'position_id': fields.many2one('hr_skill.position','Position', ondelete='cascade',required=True),
 
176
        'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True) ,
 
177
    }
 
178
    def onchange_profile_id(self, cr, uid, ids, profile_id):
 
179
        if not profile_id:
 
180
            return {}
 
181
        prof = self.pool.get('hr_skill.profile').browse(cr, uid, profile_id)
 
182
        return {'value': {'name':prof.name} }
182
183
hr_skill_position_profile()
183
184
 
184
185
 
185
186
class hr_skill_experience_skill(osv.osv):
186
 
        _name ='hr_skill.experience.skill'
187
 
        _columns = {
188
 
                'name': fields.char('Name', size=64, required=True),
189
 
                'weight_id': fields.many2one('hr_skill.weight','Weight', required=True),
190
 
                'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade',required=True),
191
 
                'experience_id': fields.many2one('hr_skill.experience','Experience', ondelete='cascade',required=True) ,
192
 
        }
193
 
        def onchange_skill_id(self, cr, uid, ids, skill_id):
194
 
                if not skill_id:
195
 
                        return {}
196
 
                sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
197
 
                return {'value': {'name':sk.name} }
198
 
        
 
187
    _name ='hr_skill.experience.skill'
 
188
    _columns = {
 
189
        'name': fields.char('Name', size=64, required=True),
 
190
        'weight_id': fields.many2one('hr_skill.weight','Weight', required=True),
 
191
        'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade',required=True),
 
192
        'experience_id': fields.many2one('hr_skill.experience','Experience', ondelete='cascade',required=True) ,
 
193
    }
 
194
    def onchange_skill_id(self, cr, uid, ids, skill_id):
 
195
        if not skill_id:
 
196
            return {}
 
197
        sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
 
198
        return {'value': {'name':sk.name} }
 
199
    
199
200
hr_skill_experience_skill()
200
201
 
201
202
 
202
203
 
203
204
class hr_skill_profile_skill(osv.osv):
204
 
        _name ='hr_skill.profile.skill'
205
 
        _columns = {
206
 
                'name': fields.char('Name', size=64),
207
 
                'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
208
 
                'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True),
209
 
                'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade',required=True, domain=[('view','<>','view')]),
210
 
        }
211
 
        
212
 
        def onchange_skill_id(self, cr, uid, ids, skill_id):
213
 
                if not skill_id:
214
 
                        return {}
215
 
                sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
216
 
                return {'value': {'name':sk.name} }
217
 
        
 
205
    _name ='hr_skill.profile.skill'
 
206
    _columns = {
 
207
        'name': fields.char('Name', size=64),
 
208
        'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
 
209
        'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True),
 
210
        'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade',required=True, domain=[('view','<>','view')]),
 
211
    }
 
212
    
 
213
    def onchange_skill_id(self, cr, uid, ids, skill_id):
 
214
        if not skill_id:
 
215
            return {}
 
216
        sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
 
217
        return {'value': {'name':sk.name} }
 
218
    
218
219
hr_skill_profile_skill()
219
220
 
220
221
 
221
222
 
222
223
class hr_skill_position_profile(osv.osv):
223
 
        _name ='hr_skill.position.profile'
224
 
        _columns = {
225
 
                'name': fields.char('Name', size=64),
226
 
                'weight_id': fields.many2one('hr_skill.weight','Weight',required=True, ondelete='cascade'),
227
 
                'position_id': fields.many2one('hr_skill.position','Position', ondelete='cascade',required=True),
228
 
                'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True),
229
 
        }
 
224
    _name ='hr_skill.position.profile'
 
225
    _columns = {
 
226
        'name': fields.char('Name', size=64),
 
227
        'weight_id': fields.many2one('hr_skill.weight','Weight',required=True, ondelete='cascade'),
 
228
        'position_id': fields.many2one('hr_skill.position','Position', ondelete='cascade',required=True),
 
229
        'profile_id': fields.many2one('hr_skill.profile','Profile', ondelete='cascade',required=True),
 
230
    }
230
231
hr_skill_profile_skill()
231
232
 
232
233
 
233
234
 
234
235
class hr_skill_evaluation_experience(osv.osv):
235
 
        _name ='hr_skill.evaluation.experience'
236
 
        _columns = {
237
 
                'name': fields.char('Name', size=64,required=True),
238
 
                'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
239
 
                'evaluation_id': fields.many2one('hr_skill.evaluation','Evaluation', ondelete='cascade', required=True),
240
 
                'experience_id': fields.many2one('hr_skill.experience','Experience', ondelete='cascade', required=True),
241
 
        }
242
 
        
243
 
        def onchange_experience_id(self, cr, uid, ids, experience_id): 
244
 
                if not experience_id:
245
 
                        return {}
246
 
                exp = self.pool.get('hr_skill.experience').browse(cr, uid, experience_id)
247
 
                return {'value': {'name':exp.name} }
 
236
    _name ='hr_skill.evaluation.experience'
 
237
    _columns = {
 
238
        'name': fields.char('Name', size=64,required=True),
 
239
        'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
 
240
        'evaluation_id': fields.many2one('hr_skill.evaluation','Evaluation', ondelete='cascade', required=True),
 
241
        'experience_id': fields.many2one('hr_skill.experience','Experience', ondelete='cascade', required=True),
 
242
    }
 
243
    
 
244
    def onchange_experience_id(self, cr, uid, ids, experience_id): 
 
245
        if not experience_id:
 
246
            return {}
 
247
        exp = self.pool.get('hr_skill.experience').browse(cr, uid, experience_id)
 
248
        return {'value': {'name':exp.name} }
248
249
 
249
250
hr_skill_evaluation_experience()
250
251
 
251
252
 
252
253
 
253
254
class hr_skill_evaluation_skill(osv.osv):
254
 
        _name ='hr_skill.evaluation.skill'
255
 
        _columns = {
256
 
                'name': fields.char('Name', size=64),
257
 
                'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
258
 
                'evaluation_id': fields.many2one('hr_skill.evaluation','Evaluation', ondelete='cascade', required=True),
259
 
                'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade', required=True),
260
 
        }
261
 
        def onchange_skill_id(self, cr, uid, ids, skill_id): 
262
 
                if not skill_id:
263
 
                        return {}
264
 
                sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
265
 
                return {'value': {'name':sk.name} }
 
255
    _name ='hr_skill.evaluation.skill'
 
256
    _columns = {
 
257
        'name': fields.char('Name', size=64),
 
258
        'weight_id': fields.many2one('hr_skill.weight','Weight',required=True),
 
259
        'evaluation_id': fields.many2one('hr_skill.evaluation','Evaluation', ondelete='cascade', required=True),
 
260
        'skill_id': fields.many2one('hr_skill.skill','Skill', ondelete='cascade', required=True),
 
261
    }
 
262
    def onchange_skill_id(self, cr, uid, ids, skill_id): 
 
263
        if not skill_id:
 
264
            return {}
 
265
        sk = self.pool.get('hr_skill.skill').browse(cr, uid, skill_id)
 
266
        return {'value': {'name':sk.name} }
266
267
 
267
268
hr_skill_evaluation_skill()
268
269
 
 
270
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 
271