1 # -*- coding: utf-8 -*-
2 ##############################################################################
4 # OpenERP, Open Source Management Solution
5 # Copyright (C) 2004-today OpenERP SA (<http://www.openerp.com>)
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Affero General Public License as
9 # published by the Free Software Foundation, either version 3 of the
10 # License, or (at your option) any later version.
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Affero General Public License for more details.
17 # You should have received a copy of the GNU Affero General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
20 ##############################################################################
22 from datetime import datetime, date
23 from lxml import etree
26 from openerp import SUPERUSER_ID
27 from openerp import tools
28 from openerp.osv import fields, osv
29 from openerp.tools.translate import _
31 from openerp.addons.base_status.base_stage import base_stage
32 from openerp.addons.resource.faces import task as Task
34 _TASK_STATE = [('draft', 'New'),('open', 'In Progress'),('pending', 'Pending'), ('done', 'Done'), ('cancelled', 'Cancelled')]
36 class project_task_type(osv.osv):
37 _name = 'project.task.type'
38 _description = 'Task Stage'
41 'name': fields.char('Stage Name', required=True, size=64, translate=True),
42 'description': fields.text('Description'),
43 'sequence': fields.integer('Sequence'),
44 'case_default': fields.boolean('Default for New Projects',
45 help="If you check this field, this stage will be proposed by default on each new project. It will not assign this stage to existing projects."),
46 'project_ids': fields.many2many('project.project', 'project_task_type_rel', 'type_id', 'project_id', 'Projects'),
47 'state': fields.selection(_TASK_STATE, 'Related Status', required=True,
48 help="The status of your document is automatically changed regarding the selected stage. " \
49 "For example, if a stage is related to the status 'Close', when your document reaches this stage, it is automatically closed."),
50 'fold': fields.boolean('Folded by Default',
51 help="This stage is not visible, for example in status bar or kanban view, when there are no records in that stage to display."),
53 def _get_default_project_id(self, cr, uid, ctx={}):
54 proj = ctx.get('default_project_id', False)
62 'case_default': False,
63 'project_ids': _get_default_project_id
68 """Keep first word(s) of name to make it small enough
70 if not name: return name
71 # keep 7 chars + end of the last word
72 keep_words = name[:7].strip().split()
73 return ' '.join(name.split()[:len(keep_words)])
75 class project(osv.osv):
76 _name = "project.project"
77 _description = "Project"
78 _inherits = {'account.analytic.account': "analytic_account_id",
79 "mail.alias": "alias_id"}
80 _inherit = ['mail.thread', 'ir.needaction_mixin']
82 def search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False):
84 return super(project, self).search(cr, user, args, offset=offset, limit=limit, order=order, context=context, count=count)
85 if context and context.get('user_preference'):
86 cr.execute("""SELECT project.id FROM project_project project
87 LEFT JOIN account_analytic_account account ON account.id = project.analytic_account_id
88 LEFT JOIN project_user_rel rel ON rel.project_id = project.analytic_account_id
89 WHERE (account.user_id = %s or rel.uid = %s)"""%(user, user))
90 return [(r[0]) for r in cr.fetchall()]
91 return super(project, self).search(cr, user, args, offset=offset, limit=limit, order=order,
92 context=context, count=count)
94 def _complete_name(self, cr, uid, ids, name, args, context=None):
96 for m in self.browse(cr, uid, ids, context=context):
97 res[m.id] = (m.parent_id and (m.parent_id.name + '/') or '') + m.name
100 def onchange_partner_id(self, cr, uid, ids, part=False, context=None):
101 partner_obj = self.pool.get('res.partner')
105 if 'pricelist_id' in self.fields_get(cr, uid, context=context):
106 pricelist = partner_obj.read(cr, uid, part, ['property_product_pricelist'], context=context)
107 pricelist_id = pricelist.get('property_product_pricelist', False) and pricelist.get('property_product_pricelist')[0] or False
108 val['pricelist_id'] = pricelist_id
109 return {'value': val}
111 def _get_projects_from_tasks(self, cr, uid, task_ids, context=None):
112 tasks = self.pool.get('project.task').browse(cr, uid, task_ids, context=context)
113 project_ids = [task.project_id.id for task in tasks if task.project_id]
114 return self.pool.get('project.project')._get_project_and_parents(cr, uid, project_ids, context)
116 def _get_project_and_parents(self, cr, uid, ids, context=None):
117 """ return the project ids and all their parent projects """
121 SELECT DISTINCT parent.id
122 FROM project_project project, project_project parent, account_analytic_account account
123 WHERE project.analytic_account_id = account.id
124 AND parent.analytic_account_id = account.parent_id
127 ids = [t[0] for t in cr.fetchall()]
131 def _get_project_and_children(self, cr, uid, ids, context=None):
132 """ retrieve all children projects of project ids;
133 return a dictionary mapping each project to its parent project (or None)
135 res = dict.fromkeys(ids, None)
138 SELECT project.id, parent.id
139 FROM project_project project, project_project parent, account_analytic_account account
140 WHERE project.analytic_account_id = account.id
141 AND parent.analytic_account_id = account.parent_id
144 dic = dict(cr.fetchall())
149 def _progress_rate(self, cr, uid, ids, names, arg, context=None):
150 child_parent = self._get_project_and_children(cr, uid, ids, context)
151 # compute planned_hours, total_hours, effective_hours specific to each project
153 SELECT project_id, COALESCE(SUM(planned_hours), 0.0),
154 COALESCE(SUM(total_hours), 0.0), COALESCE(SUM(effective_hours), 0.0)
155 FROM project_task WHERE project_id IN %s AND state <> 'cancelled'
157 """, (tuple(child_parent.keys()),))
158 # aggregate results into res
159 res = dict([(id, {'planned_hours':0.0,'total_hours':0.0,'effective_hours':0.0}) for id in ids])
160 for id, planned, total, effective in cr.fetchall():
161 # add the values specific to id to all parent projects of id in the result
164 res[id]['planned_hours'] += planned
165 res[id]['total_hours'] += total
166 res[id]['effective_hours'] += effective
167 id = child_parent[id]
168 # compute progress rates
170 if res[id]['total_hours']:
171 res[id]['progress_rate'] = round(100.0 * res[id]['effective_hours'] / res[id]['total_hours'], 2)
173 res[id]['progress_rate'] = 0.0
176 def unlink(self, cr, uid, ids, context=None):
178 mail_alias = self.pool.get('mail.alias')
179 for proj in self.browse(cr, uid, ids, context=context):
181 raise osv.except_osv(_('Invalid Action!'),
182 _('You cannot delete a project containing tasks. You can either delete all the project\'s tasks and then delete the project or simply deactivate the project.'))
184 alias_ids.append(proj.alias_id.id)
185 res = super(project, self).unlink(cr, uid, ids, context=context)
186 mail_alias.unlink(cr, uid, alias_ids, context=context)
189 def _get_attached_docs(self, cr, uid, ids, field_name, arg, context):
191 attachment = self.pool.get('ir.attachment')
192 task = self.pool.get('project.task')
194 project_attachments = attachment.search(cr, uid, [('res_model', '=', 'project.project'), ('res_id', '=', id)], context=context, count=True)
195 task_ids = task.search(cr, uid, [('project_id', '=', id)], context=context)
196 task_attachments = attachment.search(cr, uid, [('res_model', '=', 'project.task'), ('res_id', 'in', task_ids)], context=context, count=True)
197 res[id] = (project_attachments or 0) + (task_attachments or 0)
200 def _task_count(self, cr, uid, ids, field_name, arg, context=None):
201 res = dict.fromkeys(ids, 0)
202 task_ids = self.pool.get('project.task').search(cr, uid, [('project_id', 'in', ids)])
203 for task in self.pool.get('project.task').browse(cr, uid, task_ids, context):
204 res[task.project_id.id] += 1
207 def _get_alias_models(self, cr, uid, context=None):
208 """Overriden in project_issue to offer more options"""
209 return [('project.task', "Tasks")]
211 def attachment_tree_view(self, cr, uid, ids, context):
212 task_ids = self.pool.get('project.task').search(cr, uid, [('project_id', 'in', ids)])
215 '&', ('res_model', '=', 'project.project'), ('res_id', 'in', ids),
216 '&', ('res_model', '=', 'project.task'), ('res_id', 'in', task_ids)
218 res_id = ids and ids[0] or False
220 'name': _('Attachments'),
222 'res_model': 'ir.attachment',
223 'type': 'ir.actions.act_window',
225 'view_mode': 'tree,form',
228 'context': "{'default_res_model': '%s','default_res_id': %d}" % (self._name, res_id)
230 # Lambda indirection method to avoid passing a copy of the overridable method when declaring the field
231 _alias_models = lambda self, *args, **kwargs: self._get_alias_models(*args, **kwargs)
233 'complete_name': fields.function(_complete_name, string="Project Name", type='char', size=250),
234 'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the project without removing it."),
235 'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of Projects."),
236 'analytic_account_id': fields.many2one('account.analytic.account', 'Contract/Analytic', help="Link this project to an analytic account if you need financial management on projects. It enables you to connect projects with budgets, planning, cost and revenue analysis, timesheets on projects, etc.", ondelete="cascade", required=True),
237 'priority': fields.integer('Sequence', help="Gives the sequence order when displaying the list of projects"),
238 'members': fields.many2many('res.users', 'project_user_rel', 'project_id', 'uid', 'Project Members',
239 help="Project's members are users who can have an access to the tasks related to this project.", states={'close':[('readonly',True)], 'cancelled':[('readonly',True)]}),
240 'tasks': fields.one2many('project.task', 'project_id', "Task Activities"),
241 'planned_hours': fields.function(_progress_rate, multi="progress", string='Planned Time', help="Sum of planned hours of all tasks related to this project and its child projects.",
243 'project.project': (_get_project_and_parents, ['tasks', 'parent_id', 'child_ids'], 10),
244 'project.task': (_get_projects_from_tasks, ['planned_hours', 'remaining_hours', 'work_ids', 'state'], 20),
246 'effective_hours': fields.function(_progress_rate, multi="progress", string='Time Spent', help="Sum of spent hours of all tasks related to this project and its child projects.",
248 'project.project': (_get_project_and_parents, ['tasks', 'parent_id', 'child_ids'], 10),
249 'project.task': (_get_projects_from_tasks, ['planned_hours', 'remaining_hours', 'work_ids', 'state'], 20),
251 'total_hours': fields.function(_progress_rate, multi="progress", string='Total Time', help="Sum of total hours of all tasks related to this project and its child projects.",
253 'project.project': (_get_project_and_parents, ['tasks', 'parent_id', 'child_ids'], 10),
254 'project.task': (_get_projects_from_tasks, ['planned_hours', 'remaining_hours', 'work_ids', 'state'], 20),
256 'progress_rate': fields.function(_progress_rate, multi="progress", string='Progress', type='float', group_operator="avg", help="Percent of tasks closed according to the total of tasks todo.",
258 'project.project': (_get_project_and_parents, ['tasks', 'parent_id', 'child_ids'], 10),
259 'project.task': (_get_projects_from_tasks, ['planned_hours', 'remaining_hours', 'work_ids', 'state'], 20),
261 'resource_calendar_id': fields.many2one('resource.calendar', 'Working Time', help="Timetable working hours to adjust the gantt diagram report", states={'close':[('readonly',True)]} ),
262 'type_ids': fields.many2many('project.task.type', 'project_task_type_rel', 'project_id', 'type_id', 'Tasks Stages', states={'close':[('readonly',True)], 'cancelled':[('readonly',True)]}),
263 'task_count': fields.function(_task_count, type='integer', string="Open Tasks"),
264 'color': fields.integer('Color Index'),
265 'alias_id': fields.many2one('mail.alias', 'Alias', ondelete="cascade", required=True,
266 help="Internal email associated with this project. Incoming emails are automatically synchronized"
267 "with Tasks (or optionally Issues if the Issue Tracker module is installed)."),
268 'alias_model': fields.selection(_alias_models, "Alias Model", select=True, required=True,
269 help="The kind of document created when an email is received on this project's email alias"),
270 'privacy_visibility': fields.selection([('public','Public'), ('followers','Followers Only')], 'Privacy / Visibility', required=True),
271 'state': fields.selection([('template', 'Template'),('draft','New'),('open','In Progress'), ('cancelled', 'Cancelled'),('pending','Pending'),('close','Closed')], 'Status', required=True,),
272 'doc_count':fields.function(_get_attached_docs, string="Number of documents attached", type='int')
275 def _get_type_common(self, cr, uid, context):
276 ids = self.pool.get('project.task.type').search(cr, uid, [('case_default','=',1)], context=context)
279 _order = "sequence, id"
286 'type_ids': _get_type_common,
287 'alias_model': 'project.task',
288 'privacy_visibility': 'public',
289 'alias_domain': False, # always hide alias during creation
292 # TODO: Why not using a SQL contraints ?
293 def _check_dates(self, cr, uid, ids, context=None):
294 for leave in self.read(cr, uid, ids, ['date_start', 'date'], context=context):
295 if leave['date_start'] and leave['date']:
296 if leave['date_start'] > leave['date']:
301 (_check_dates, 'Error! project start-date must be lower then project end-date.', ['date_start', 'date'])
304 def set_template(self, cr, uid, ids, context=None):
305 res = self.setActive(cr, uid, ids, value=False, context=context)
308 def set_done(self, cr, uid, ids, context=None):
309 task_obj = self.pool.get('project.task')
310 task_ids = task_obj.search(cr, uid, [('project_id', 'in', ids), ('state', 'not in', ('cancelled', 'done'))])
311 task_obj.case_close(cr, uid, task_ids, context=context)
312 return self.write(cr, uid, ids, {'state':'close'}, context=context)
314 def set_cancel(self, cr, uid, ids, context=None):
315 task_obj = self.pool.get('project.task')
316 task_ids = task_obj.search(cr, uid, [('project_id', 'in', ids), ('state', '!=', 'done')])
317 task_obj.case_cancel(cr, uid, task_ids, context=context)
318 return self.write(cr, uid, ids, {'state':'cancelled'}, context=context)
320 def set_pending(self, cr, uid, ids, context=None):
321 return self.write(cr, uid, ids, {'state':'pending'}, context=context)
323 def set_open(self, cr, uid, ids, context=None):
324 return self.write(cr, uid, ids, {'state':'open'}, context=context)
326 def reset_project(self, cr, uid, ids, context=None):
327 return self.setActive(cr, uid, ids, value=True, context=context)
329 def map_tasks(self, cr, uid, old_project_id, new_project_id, context=None):
330 """ copy and map tasks from old to new project """
334 task_obj = self.pool.get('project.task')
335 proj = self.browse(cr, uid, old_project_id, context=context)
336 for task in proj.tasks:
337 map_task_id[task.id] = task_obj.copy(cr, uid, task.id, {}, context=context)
338 self.write(cr, uid, [new_project_id], {'tasks':[(6,0, map_task_id.values())]})
339 task_obj.duplicate_task(cr, uid, map_task_id, context=context)
342 def copy(self, cr, uid, id, default=None, context=None):
348 context['active_test'] = False
349 default['state'] = 'open'
350 default['line_ids'] = []
351 default['tasks'] = []
352 default.pop('alias_name', None)
353 default.pop('alias_id', None)
354 proj = self.browse(cr, uid, id, context=context)
355 if not default.get('name', False):
356 default.update(name=_("%s (copy)") % (proj.name))
357 res = super(project, self).copy(cr, uid, id, default, context)
358 self.map_tasks(cr,uid,id,res,context)
361 def duplicate_template(self, cr, uid, ids, context=None):
364 data_obj = self.pool.get('ir.model.data')
366 for proj in self.browse(cr, uid, ids, context=context):
367 parent_id = context.get('parent_id', False)
368 context.update({'analytic_project_copy': True})
369 new_date_start = time.strftime('%Y-%m-%d')
371 if proj.date_start and proj.date:
372 start_date = date(*time.strptime(proj.date_start,'%Y-%m-%d')[:3])
373 end_date = date(*time.strptime(proj.date,'%Y-%m-%d')[:3])
374 new_date_end = (datetime(*time.strptime(new_date_start,'%Y-%m-%d')[:3])+(end_date-start_date)).strftime('%Y-%m-%d')
375 context.update({'copy':True})
376 new_id = self.copy(cr, uid, proj.id, default = {
377 'name':_("%s (copy)") % (proj.name),
379 'date_start':new_date_start,
381 'parent_id':parent_id}, context=context)
382 result.append(new_id)
384 child_ids = self.search(cr, uid, [('parent_id','=', proj.analytic_account_id.id)], context=context)
385 parent_id = self.read(cr, uid, new_id, ['analytic_account_id'])['analytic_account_id'][0]
387 self.duplicate_template(cr, uid, child_ids, context={'parent_id': parent_id})
389 if result and len(result):
391 form_view_id = data_obj._get_id(cr, uid, 'project', 'edit_project')
392 form_view = data_obj.read(cr, uid, form_view_id, ['res_id'])
393 tree_view_id = data_obj._get_id(cr, uid, 'project', 'view_project')
394 tree_view = data_obj.read(cr, uid, tree_view_id, ['res_id'])
395 search_view_id = data_obj._get_id(cr, uid, 'project', 'view_project_project_filter')
396 search_view = data_obj.read(cr, uid, search_view_id, ['res_id'])
398 'name': _('Projects'),
400 'view_mode': 'form,tree',
401 'res_model': 'project.project',
404 'views': [(form_view['res_id'],'form'),(tree_view['res_id'],'tree')],
405 'type': 'ir.actions.act_window',
406 'search_view_id': search_view['res_id'],
410 # set active value for a project, its sub projects and its tasks
411 def setActive(self, cr, uid, ids, value=True, context=None):
412 task_obj = self.pool.get('project.task')
413 for proj in self.browse(cr, uid, ids, context=None):
414 self.write(cr, uid, [proj.id], {'state': value and 'open' or 'template'}, context)
415 cr.execute('select id from project_task where project_id=%s', (proj.id,))
416 tasks_id = [x[0] for x in cr.fetchall()]
418 task_obj.write(cr, uid, tasks_id, {'active': value}, context=context)
419 child_ids = self.search(cr, uid, [('parent_id','=', proj.analytic_account_id.id)])
421 self.setActive(cr, uid, child_ids, value, context=None)
424 def _schedule_header(self, cr, uid, ids, force_members=True, context=None):
425 context = context or {}
426 if type(ids) in (long, int,):
428 projects = self.browse(cr, uid, ids, context=context)
430 for project in projects:
431 if (not project.members) and force_members:
432 raise osv.except_osv(_('Warning!'),_("You must assign members on the project '%s' !") % (project.name,))
434 resource_pool = self.pool.get('resource.resource')
436 result = "from openerp.addons.resource.faces import *\n"
437 result += "import datetime\n"
438 for project in self.browse(cr, uid, ids, context=context):
439 u_ids = [i.id for i in project.members]
440 if project.user_id and (project.user_id.id not in u_ids):
441 u_ids.append(project.user_id.id)
442 for task in project.tasks:
443 if task.state in ('done','cancelled'):
445 if task.user_id and (task.user_id.id not in u_ids):
446 u_ids.append(task.user_id.id)
447 calendar_id = project.resource_calendar_id and project.resource_calendar_id.id or False
448 resource_objs = resource_pool.generate_resources(cr, uid, u_ids, calendar_id, context=context)
449 for key, vals in resource_objs.items():
451 class User_%s(Resource):
453 ''' % (key, vals.get('efficiency', False))
460 def _schedule_project(self, cr, uid, project, context=None):
461 resource_pool = self.pool.get('resource.resource')
462 calendar_id = project.resource_calendar_id and project.resource_calendar_id.id or False
463 working_days = resource_pool.compute_working_calendar(cr, uid, calendar_id, context=context)
464 # TODO: check if we need working_..., default values are ok.
465 puids = [x.id for x in project.members]
467 puids.append(project.user_id.id)
475 project.date_start or time.strftime('%Y-%m-%d'), working_days,
476 '|'.join(['User_'+str(x) for x in puids])
478 vacation = calendar_id and tuple(resource_pool.compute_vacation(cr, uid, calendar_id, context=context)) or False
485 #TODO: DO Resource allocation and compute availability
486 def compute_allocation(self, rc, uid, ids, start_date, end_date, context=None):
492 def schedule_tasks(self, cr, uid, ids, context=None):
493 context = context or {}
494 if type(ids) in (long, int,):
496 projects = self.browse(cr, uid, ids, context=context)
497 result = self._schedule_header(cr, uid, ids, False, context=context)
498 for project in projects:
499 result += self._schedule_project(cr, uid, project, context=context)
500 result += self.pool.get('project.task')._generate_task(cr, uid, project.tasks, ident=4, context=context)
503 exec result in local_dict
504 projects_gantt = Task.BalancedProject(local_dict['Project'])
506 for project in projects:
507 project_gantt = getattr(projects_gantt, 'Project_%d' % (project.id,))
508 for task in project.tasks:
509 if task.state in ('done','cancelled'):
512 p = getattr(project_gantt, 'Task_%d' % (task.id,))
514 self.pool.get('project.task').write(cr, uid, [task.id], {
515 'date_start': p.start.strftime('%Y-%m-%d %H:%M:%S'),
516 'date_end': p.end.strftime('%Y-%m-%d %H:%M:%S')
518 if (not task.user_id) and (p.booked_resource):
519 self.pool.get('project.task').write(cr, uid, [task.id], {
520 'user_id': int(p.booked_resource[0].name[5:]),
524 # ------------------------------------------------
525 # OpenChatter methods and notifications
526 # ------------------------------------------------
528 def create(self, cr, uid, vals, context=None):
529 if context is None: context = {}
530 # Prevent double project creation when 'use_tasks' is checked!
531 context = dict(context, project_creation_in_progress=True)
532 mail_alias = self.pool.get('mail.alias')
533 if not vals.get('alias_id') and vals.get('name', False):
534 vals.pop('alias_name', None) # prevent errors during copy()
535 alias_id = mail_alias.create_unique_alias(cr, uid,
536 # Using '+' allows using subaddressing for those who don't
537 # have a catchall domain setup.
538 {'alias_name': "project+"+short_name(vals['name'])},
539 model_name=vals.get('alias_model', 'project.task'),
541 vals['alias_id'] = alias_id
542 if vals.get('type', False) not in ('template','contract'):
543 vals['type'] = 'contract'
544 project_id = super(project, self).create(cr, uid, vals, context)
545 mail_alias.write(cr, uid, [vals['alias_id']], {'alias_defaults': {'project_id': project_id} }, context)
548 def write(self, cr, uid, ids, vals, context=None):
549 # if alias_model has been changed, update alias_model_id accordingly
550 if vals.get('alias_model'):
551 model_ids = self.pool.get('ir.model').search(cr, uid, [('model', '=', vals.get('alias_model', 'project.task'))])
552 vals.update(alias_model_id=model_ids[0])
553 return super(project, self).write(cr, uid, ids, vals, context=context)
555 class task(base_stage, osv.osv):
556 _name = "project.task"
557 _description = "Task"
558 _date_name = "date_start"
559 _inherit = ['mail.thread', 'ir.needaction_mixin']
563 'project.mt_task_new': lambda self, cr, uid, obj, ctx=None: obj['state'] == 'new',
564 'project.mt_task_started': lambda self, cr, uid, obj, ctx=None: obj['state'] == 'open',
565 'project.mt_task_closed': lambda self, cr, uid, obj, ctx=None: obj['state'] == 'done',
568 'project.mt_task_stage': lambda self, cr, uid, obj, ctx=None: obj['state'] not in ['new', 'done', 'open'],
570 'kanban_state': { # kanban state: tracked, but only block subtype
571 'project.mt_task_blocked': lambda self, cr, uid, obj, ctx=None: obj['kanban_state'] == 'blocked',
575 def _get_default_project_id(self, cr, uid, context=None):
576 """ Gives default section by checking if present in the context """
577 return (self._resolve_project_id_from_context(cr, uid, context=context) or False)
579 def _get_default_stage_id(self, cr, uid, context=None):
580 """ Gives default stage_id """
581 project_id = self._get_default_project_id(cr, uid, context=context)
582 return self.stage_find(cr, uid, [], project_id, [('state', '=', 'draft')], context=context)
584 def _resolve_project_id_from_context(self, cr, uid, context=None):
585 """ Returns ID of project based on the value of 'default_project_id'
586 context key, or None if it cannot be resolved to a single
589 if context is None: context = {}
590 if type(context.get('default_project_id')) in (int, long):
591 return context['default_project_id']
592 if isinstance(context.get('default_project_id'), basestring):
593 project_name = context['default_project_id']
594 project_ids = self.pool.get('project.project').name_search(cr, uid, name=project_name, context=context)
595 if len(project_ids) == 1:
596 return project_ids[0][0]
599 def _read_group_stage_ids(self, cr, uid, ids, domain, read_group_order=None, access_rights_uid=None, context=None):
600 stage_obj = self.pool.get('project.task.type')
601 order = stage_obj._order
602 access_rights_uid = access_rights_uid or uid
603 if read_group_order == 'stage_id desc':
604 order = '%s desc' % order
606 project_id = self._resolve_project_id_from_context(cr, uid, context=context)
608 search_domain += ['|', ('project_ids', '=', project_id)]
609 search_domain += [('id', 'in', ids)]
610 stage_ids = stage_obj._search(cr, uid, search_domain, order=order, access_rights_uid=access_rights_uid, context=context)
611 result = stage_obj.name_get(cr, access_rights_uid, stage_ids, context=context)
612 # restore order of the search
613 result.sort(lambda x,y: cmp(stage_ids.index(x[0]), stage_ids.index(y[0])))
616 for stage in stage_obj.browse(cr, access_rights_uid, stage_ids, context=context):
617 fold[stage.id] = stage.fold or False
620 def _read_group_user_id(self, cr, uid, ids, domain, read_group_order=None, access_rights_uid=None, context=None):
621 res_users = self.pool.get('res.users')
622 project_id = self._resolve_project_id_from_context(cr, uid, context=context)
623 access_rights_uid = access_rights_uid or uid
625 ids += self.pool.get('project.project').read(cr, access_rights_uid, project_id, ['members'], context=context)['members']
626 order = res_users._order
627 # lame way to allow reverting search, should just work in the trivial case
628 if read_group_order == 'user_id desc':
629 order = '%s desc' % order
630 # de-duplicate and apply search order
631 ids = res_users._search(cr, uid, [('id','in',ids)], order=order, access_rights_uid=access_rights_uid, context=context)
632 result = res_users.name_get(cr, access_rights_uid, ids, context=context)
633 # restore order of the search
634 result.sort(lambda x,y: cmp(ids.index(x[0]), ids.index(y[0])))
638 'stage_id': _read_group_stage_ids,
639 'user_id': _read_group_user_id,
642 def _str_get(self, task, level=0, border='***', context=None):
643 return border+' '+(task.user_id and task.user_id.name.upper() or '')+(level and (': L'+str(level)) or '')+(' - %.1fh / %.1fh'%(task.effective_hours or 0.0,task.planned_hours))+' '+border+'\n'+ \
644 border[0]+' '+(task.name or '')+'\n'+ \
645 (task.description or '')+'\n\n'
647 # Compute: effective_hours, total_hours, progress
648 def _hours_get(self, cr, uid, ids, field_names, args, context=None):
650 cr.execute("SELECT task_id, COALESCE(SUM(hours),0) FROM project_task_work WHERE task_id IN %s GROUP BY task_id",(tuple(ids),))
651 hours = dict(cr.fetchall())
652 for task in self.browse(cr, uid, ids, context=context):
653 res[task.id] = {'effective_hours': hours.get(task.id, 0.0), 'total_hours': (task.remaining_hours or 0.0) + hours.get(task.id, 0.0)}
654 res[task.id]['delay_hours'] = res[task.id]['total_hours'] - task.planned_hours
655 res[task.id]['progress'] = 0.0
656 if (task.remaining_hours + hours.get(task.id, 0.0)):
657 res[task.id]['progress'] = round(min(100.0 * hours.get(task.id, 0.0) / res[task.id]['total_hours'], 99.99),2)
658 if task.state in ('done','cancelled'):
659 res[task.id]['progress'] = 100.0
662 def onchange_remaining(self, cr, uid, ids, remaining=0.0, planned=0.0):
663 if remaining and not planned:
664 return {'value':{'planned_hours': remaining}}
667 def onchange_planned(self, cr, uid, ids, planned=0.0, effective=0.0):
668 return {'value':{'remaining_hours': planned - effective}}
670 def onchange_project(self, cr, uid, id, project_id):
673 data = self.pool.get('project.project').browse(cr, uid, [project_id])
674 partner_id=data and data[0].partner_id
676 return {'value':{'partner_id':partner_id.id}}
679 def duplicate_task(self, cr, uid, map_ids, context=None):
680 for new in map_ids.values():
681 task = self.browse(cr, uid, new, context)
682 child_ids = [ ch.id for ch in task.child_ids]
684 for child in task.child_ids:
685 if child.id in map_ids.keys():
686 child_ids.remove(child.id)
687 child_ids.append(map_ids[child.id])
689 parent_ids = [ ch.id for ch in task.parent_ids]
691 for parent in task.parent_ids:
692 if parent.id in map_ids.keys():
693 parent_ids.remove(parent.id)
694 parent_ids.append(map_ids[parent.id])
695 #FIXME why there is already the copy and the old one
696 self.write(cr, uid, new, {'parent_ids':[(6,0,set(parent_ids))], 'child_ids':[(6,0, set(child_ids))]})
698 def copy_data(self, cr, uid, id, default=None, context=None):
701 default = default or {}
702 default.update({'work_ids':[], 'date_start': False, 'date_end': False, 'date_deadline': False})
703 if not default.get('remaining_hours', False):
704 default['remaining_hours'] = float(self.read(cr, uid, id, ['planned_hours'])['planned_hours'])
705 default['active'] = True
706 if not default.get('name', False):
707 default['name'] = self.browse(cr, uid, id, context=context).name or ''
708 if not context.get('copy',False):
709 new_name = _("%s (copy)") % (default.get('name', ''))
710 default.update({'name':new_name})
711 return super(task, self).copy_data(cr, uid, id, default, context)
713 def _is_template(self, cr, uid, ids, field_name, arg, context=None):
715 for task in self.browse(cr, uid, ids, context=context):
718 if task.project_id.active == False or task.project_id.state == 'template':
722 def _get_task(self, cr, uid, ids, context=None):
724 for work in self.pool.get('project.task.work').browse(cr, uid, ids, context=context):
725 if work.task_id: result[work.task_id.id] = True
729 'active': fields.function(_is_template, store=True, string='Not a Template Task', type='boolean', help="This field is computed automatically and have the same behavior than the boolean 'active' field: if the task is linked to a template or unactivated project, it will be hidden unless specifically asked."),
730 'name': fields.char('Task Summary', size=128, required=True, select=True),
731 'description': fields.text('Description'),
732 'priority': fields.selection([('4','Very Low'), ('3','Low'), ('2','Medium'), ('1','Important'), ('0','Very important')], 'Priority', select=True),
733 'sequence': fields.integer('Sequence', select=True, help="Gives the sequence order when displaying a list of tasks."),
734 'stage_id': fields.many2one('project.task.type', 'Stage', track_visibility='onchange',
735 domain="['&', ('fold', '=', False), ('project_ids', '=', project_id)]"),
736 'state': fields.related('stage_id', 'state', type="selection", store=True,
737 selection=_TASK_STATE, string="Status", readonly=True,
738 help='The status is set to \'Draft\', when a case is created.\
739 If the case is in progress the status is set to \'Open\'.\
740 When the case is over, the status is set to \'Done\'.\
741 If the case needs to be reviewed then the status is \
742 set to \'Pending\'.'),
743 'categ_ids': fields.many2many('project.category', string='Tags'),
744 'kanban_state': fields.selection([('normal', 'Normal'),('blocked', 'Blocked'),('done', 'Ready for next stage')], 'Kanban State',
745 track_visibility='onchange',
746 help="A task's kanban state indicates special situations affecting it:\n"
747 " * Normal is the default situation\n"
748 " * Blocked indicates something is preventing the progress of this task\n"
749 " * Ready for next stage indicates the task is ready to be pulled to the next stage",
750 readonly=True, required=False),
751 'create_date': fields.datetime('Create Date', readonly=True,select=True),
752 'date_start': fields.datetime('Starting Date',select=True),
753 'date_end': fields.datetime('Ending Date',select=True),
754 'date_deadline': fields.date('Deadline',select=True),
755 'project_id': fields.many2one('project.project', 'Project', ondelete='set null', select="1", track_visibility='onchange'),
756 'parent_ids': fields.many2many('project.task', 'project_task_parent_rel', 'task_id', 'parent_id', 'Parent Tasks'),
757 'child_ids': fields.many2many('project.task', 'project_task_parent_rel', 'parent_id', 'task_id', 'Delegated Tasks'),
758 'notes': fields.text('Notes'),
759 'planned_hours': fields.float('Initially Planned Hours', help='Estimated time to do the task, usually set by the project manager when the task is in draft state.'),
760 'effective_hours': fields.function(_hours_get, string='Hours Spent', multi='hours', help="Computed using the sum of the task work done.",
762 'project.task': (lambda self, cr, uid, ids, c={}: ids, ['work_ids', 'remaining_hours', 'planned_hours'], 10),
763 'project.task.work': (_get_task, ['hours'], 10),
765 'remaining_hours': fields.float('Remaining Hours', digits=(16,2), help="Total remaining time, can be re-estimated periodically by the assignee of the task."),
766 'total_hours': fields.function(_hours_get, string='Total', multi='hours', help="Computed as: Time Spent + Remaining Time.",
768 'project.task': (lambda self, cr, uid, ids, c={}: ids, ['work_ids', 'remaining_hours', 'planned_hours'], 10),
769 'project.task.work': (_get_task, ['hours'], 10),
771 'progress': fields.function(_hours_get, string='Progress (%)', multi='hours', group_operator="avg", help="If the task has a progress of 99.99% you should close the task if it's finished or reevaluate the time",
773 'project.task': (lambda self, cr, uid, ids, c={}: ids, ['work_ids', 'remaining_hours', 'planned_hours','state'], 10),
774 'project.task.work': (_get_task, ['hours'], 10),
776 'delay_hours': fields.function(_hours_get, string='Delay Hours', multi='hours', help="Computed as difference between planned hours by the project manager and the total hours of the task.",
778 'project.task': (lambda self, cr, uid, ids, c={}: ids, ['work_ids', 'remaining_hours', 'planned_hours'], 10),
779 'project.task.work': (_get_task, ['hours'], 10),
781 'user_id': fields.many2one('res.users', 'Assigned to', track_visibility='onchange'),
782 'delegated_user_id': fields.related('child_ids', 'user_id', type='many2one', relation='res.users', string='Delegated To'),
783 'partner_id': fields.many2one('res.partner', 'Customer'),
784 'work_ids': fields.one2many('project.task.work', 'task_id', 'Work done'),
785 'manager_id': fields.related('project_id', 'analytic_account_id', 'user_id', type='many2one', relation='res.users', string='Project Manager'),
786 'company_id': fields.many2one('res.company', 'Company'),
787 'id': fields.integer('ID', readonly=True),
788 'color': fields.integer('Color Index'),
789 'user_email': fields.related('user_id', 'email', type='char', string='User Email', readonly=True),
792 'stage_id': _get_default_stage_id,
793 'project_id': _get_default_project_id,
794 'kanban_state': 'normal',
799 'user_id': lambda obj, cr, uid, context: uid,
800 'company_id': lambda self, cr, uid, c: self.pool.get('res.company')._company_default_get(cr, uid, 'project.task', context=c),
802 _order = "priority, sequence, date_start, name, id"
804 def set_high_priority(self, cr, uid, ids, *args):
805 """Set task priority to high
807 return self.write(cr, uid, ids, {'priority' : '0'})
809 def set_normal_priority(self, cr, uid, ids, *args):
810 """Set task priority to normal
812 return self.write(cr, uid, ids, {'priority' : '2'})
814 def _check_recursion(self, cr, uid, ids, context=None):
816 visited_branch = set()
818 res = self._check_cycle(cr, uid, id, visited_branch, visited_node, context=context)
824 def _check_cycle(self, cr, uid, id, visited_branch, visited_node, context=None):
825 if id in visited_branch: #Cycle
828 if id in visited_node: #Already tested don't work one more time for nothing
831 visited_branch.add(id)
834 #visit child using DFS
835 task = self.browse(cr, uid, id, context=context)
836 for child in task.child_ids:
837 res = self._check_cycle(cr, uid, child.id, visited_branch, visited_node, context=context)
841 visited_branch.remove(id)
844 def _check_dates(self, cr, uid, ids, context=None):
847 obj_task = self.browse(cr, uid, ids[0], context=context)
848 start = obj_task.date_start or False
849 end = obj_task.date_end or False
856 (_check_recursion, 'Error ! You cannot create recursive tasks.', ['parent_ids']),
857 (_check_dates, 'Error ! Task end-date must be greater then task start-date', ['date_start','date_end'])
860 # Override view according to the company definition
861 def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
862 users_obj = self.pool.get('res.users')
863 if context is None: context = {}
864 # read uom as admin to avoid access rights issues, e.g. for portal/share users,
865 # this should be safe (no context passed to avoid side-effects)
866 obj_tm = users_obj.browse(cr, SUPERUSER_ID, uid, context=context).company_id.project_time_mode_id
867 tm = obj_tm and obj_tm.name or 'Hours'
869 res = super(task, self).fields_view_get(cr, uid, view_id, view_type, context, toolbar, submenu=submenu)
871 if tm in ['Hours','Hour']:
874 eview = etree.fromstring(res['arch'])
876 def _check_rec(eview):
877 if eview.attrib.get('widget','') == 'float_time':
878 eview.set('widget','float')
885 res['arch'] = etree.tostring(eview)
887 for f in res['fields']:
888 if 'Hours' in res['fields'][f]['string']:
889 res['fields'][f]['string'] = res['fields'][f]['string'].replace('Hours',tm)
892 # ----------------------------------------
894 # ----------------------------------------
896 def stage_find(self, cr, uid, cases, section_id, domain=[], order='sequence', context=None):
897 """ Override of the base.stage method
898 Parameter of the stage search taken from the lead:
899 - section_id: if set, stages must belong to this section or
900 be a default stage; if not set, stages must be default
903 if isinstance(cases, (int, long)):
904 cases = self.browse(cr, uid, cases, context=context)
905 # collect all section_ids
908 section_ids.append(section_id)
911 section_ids.append(task.project_id.id)
914 search_domain = [('|')] * (len(section_ids)-1)
915 for section_id in section_ids:
916 search_domain.append(('project_ids', '=', section_id))
917 search_domain += list(domain)
918 # perform search, return the first found
919 stage_ids = self.pool.get('project.task.type').search(cr, uid, search_domain, order=order, context=context)
924 def _check_child_task(self, cr, uid, ids, context=None):
927 tasks = self.browse(cr, uid, ids, context=context)
930 for child in task.child_ids:
931 if child.state in ['draft', 'open', 'pending']:
932 raise osv.except_osv(_("Warning !"), _("Child task still open.\nPlease cancel or complete child task first."))
935 def action_close(self, cr, uid, ids, context=None):
936 """ This action closes the task
938 task_id = len(ids) and ids[0] or False
939 self._check_child_task(cr, uid, ids, context=context)
940 if not task_id: return False
941 return self.do_close(cr, uid, [task_id], context=context)
943 def do_close(self, cr, uid, ids, context=None):
944 """ Compatibility when changing to case_close. """
945 return self.case_close(cr, uid, ids, context=context)
947 def case_close(self, cr, uid, ids, context=None):
949 if not isinstance(ids, list): ids = [ids]
950 for task in self.browse(cr, uid, ids, context=context):
952 project = task.project_id
953 for parent_id in task.parent_ids:
954 if parent_id.state in ('pending','draft'):
956 for child in parent_id.child_ids:
957 if child.id != task.id and child.state not in ('done','cancelled'):
960 self.do_reopen(cr, uid, [parent_id.id], context=context)
962 vals['remaining_hours'] = 0.0
963 if not task.date_end:
964 vals['date_end'] = fields.datetime.now()
965 self.case_set(cr, uid, [task.id], 'done', vals, context=context)
968 def do_reopen(self, cr, uid, ids, context=None):
969 for task in self.browse(cr, uid, ids, context=context):
970 project = task.project_id
971 self.case_set(cr, uid, [task.id], 'open', {}, context=context)
974 def do_cancel(self, cr, uid, ids, context=None):
975 """ Compatibility when changing to case_cancel. """
976 return self.case_cancel(cr, uid, ids, context=context)
978 def case_cancel(self, cr, uid, ids, context=None):
979 tasks = self.browse(cr, uid, ids, context=context)
980 self._check_child_task(cr, uid, ids, context=context)
982 self.case_set(cr, uid, [task.id], 'cancelled', {'remaining_hours': 0.0}, context=context)
985 def do_open(self, cr, uid, ids, context=None):
986 """ Compatibility when changing to case_open. """
987 return self.case_open(cr, uid, ids, context=context)
989 def case_open(self, cr, uid, ids, context=None):
990 if not isinstance(ids,list): ids = [ids]
991 return self.case_set(cr, uid, ids, 'open', {'date_start': fields.datetime.now()}, context=context)
993 def do_draft(self, cr, uid, ids, context=None):
994 """ Compatibility when changing to case_draft. """
995 return self.case_draft(cr, uid, ids, context=context)
997 def case_draft(self, cr, uid, ids, context=None):
998 return self.case_set(cr, uid, ids, 'draft', {}, context=context)
1000 def do_pending(self, cr, uid, ids, context=None):
1001 """ Compatibility when changing to case_pending. """
1002 return self.case_pending(cr, uid, ids, context=context)
1004 def case_pending(self, cr, uid, ids, context=None):
1005 return self.case_set(cr, uid, ids, 'pending', {}, context=context)
1007 def _delegate_task_attachments(self, cr, uid, task_id, delegated_task_id, context=None):
1008 attachment = self.pool.get('ir.attachment')
1009 attachment_ids = attachment.search(cr, uid, [('res_model', '=', self._name), ('res_id', '=', task_id)], context=context)
1010 new_attachment_ids = []
1011 for attachment_id in attachment_ids:
1012 new_attachment_ids.append(attachment.copy(cr, uid, attachment_id, default={'res_id': delegated_task_id}, context=context))
1013 return new_attachment_ids
1015 def do_delegate(self, cr, uid, ids, delegate_data=None, context=None):
1017 Delegate Task to another users.
1019 if delegate_data is None:
1021 assert delegate_data['user_id'], _("Delegated User should be specified")
1022 delegated_tasks = {}
1023 for task in self.browse(cr, uid, ids, context=context):
1024 delegated_task_id = self.copy(cr, uid, task.id, {
1025 'name': delegate_data['name'],
1026 'project_id': delegate_data['project_id'] and delegate_data['project_id'][0] or False,
1027 'user_id': delegate_data['user_id'] and delegate_data['user_id'][0] or False,
1028 'planned_hours': delegate_data['planned_hours'] or 0.0,
1029 'parent_ids': [(6, 0, [task.id])],
1030 'description': delegate_data['new_task_description'] or '',
1034 self._delegate_task_attachments(cr, uid, task.id, delegated_task_id, context=context)
1035 newname = delegate_data['prefix'] or ''
1037 'remaining_hours': delegate_data['planned_hours_me'],
1038 'planned_hours': delegate_data['planned_hours_me'] + (task.effective_hours or 0.0),
1041 if delegate_data['state'] == 'pending':
1042 self.do_pending(cr, uid, [task.id], context=context)
1043 elif delegate_data['state'] == 'done':
1044 self.do_close(cr, uid, [task.id], context=context)
1045 delegated_tasks[task.id] = delegated_task_id
1046 return delegated_tasks
1048 def set_remaining_time(self, cr, uid, ids, remaining_time=1.0, context=None):
1049 for task in self.browse(cr, uid, ids, context=context):
1050 if (task.state=='draft') or (task.planned_hours==0.0):
1051 self.write(cr, uid, [task.id], {'planned_hours': remaining_time}, context=context)
1052 self.write(cr, uid, ids, {'remaining_hours': remaining_time}, context=context)
1055 def set_remaining_time_1(self, cr, uid, ids, context=None):
1056 return self.set_remaining_time(cr, uid, ids, 1.0, context)
1058 def set_remaining_time_2(self, cr, uid, ids, context=None):
1059 return self.set_remaining_time(cr, uid, ids, 2.0, context)
1061 def set_remaining_time_5(self, cr, uid, ids, context=None):
1062 return self.set_remaining_time(cr, uid, ids, 5.0, context)
1064 def set_remaining_time_10(self, cr, uid, ids, context=None):
1065 return self.set_remaining_time(cr, uid, ids, 10.0, context)
1067 def set_kanban_state_blocked(self, cr, uid, ids, context=None):
1068 return self.write(cr, uid, ids, {'kanban_state': 'blocked'}, context=context)
1070 def set_kanban_state_normal(self, cr, uid, ids, context=None):
1071 return self.write(cr, uid, ids, {'kanban_state': 'normal'}, context=context)
1073 def set_kanban_state_done(self, cr, uid, ids, context=None):
1074 self.write(cr, uid, ids, {'kanban_state': 'done'}, context=context)
1077 def _store_history(self, cr, uid, ids, context=None):
1078 for task in self.browse(cr, uid, ids, context=context):
1079 self.pool.get('project.task.history').create(cr, uid, {
1081 'remaining_hours': task.remaining_hours,
1082 'planned_hours': task.planned_hours,
1083 'kanban_state': task.kanban_state,
1084 'type_id': task.stage_id.id,
1085 'state': task.state,
1086 'user_id': task.user_id.id
1091 def create(self, cr, uid, vals, context=None):
1094 if not vals.get('stage_id'):
1095 ctx = context.copy()
1096 if vals.get('project_id'):
1097 ctx['default_project_id'] = vals['project_id']
1098 vals['stage_id'] = self._get_default_stage_id(cr, uid, context=ctx)
1099 task_id = super(task, self).create(cr, uid, vals, context=context)
1100 self._store_history(cr, uid, [task_id], context=context)
1103 # Overridden to reset the kanban_state to normal whenever
1104 # the stage (stage_id) of the task changes.
1105 def write(self, cr, uid, ids, vals, context=None):
1106 if isinstance(ids, (int, long)):
1108 if vals.get('project_id'):
1109 project_id = self.pool.get('project.project').browse(cr, uid, vals.get('project_id'), context=context)
1111 vals.setdefault('message_follower_ids', [])
1112 vals['message_follower_ids'] += [(6, 0,[follower.id]) for follower in project_id.message_follower_ids]
1113 if vals and not 'kanban_state' in vals and 'stage_id' in vals:
1114 new_stage = vals.get('stage_id')
1115 vals_reset_kstate = dict(vals, kanban_state='normal')
1116 for t in self.browse(cr, uid, ids, context=context):
1117 #TO FIX:Kanban view doesn't raise warning
1118 #stages = [stage.id for stage in t.project_id.type_ids]
1119 #if new_stage not in stages:
1120 #raise osv.except_osv(_('Warning!'), _('Stage is not defined in the project.'))
1121 write_vals = vals_reset_kstate if t.stage_id != new_stage else vals
1122 super(task, self).write(cr, uid, [t.id], write_vals, context=context)
1125 result = super(task, self).write(cr, uid, ids, vals, context=context)
1126 if ('stage_id' in vals) or ('remaining_hours' in vals) or ('user_id' in vals) or ('state' in vals) or ('kanban_state' in vals):
1127 self._store_history(cr, uid, ids, context=context)
1130 def unlink(self, cr, uid, ids, context=None):
1133 self._check_child_task(cr, uid, ids, context=context)
1134 res = super(task, self).unlink(cr, uid, ids, context)
1137 def _generate_task(self, cr, uid, tasks, ident=4, context=None):
1138 context = context or {}
1142 if task.state in ('done','cancelled'):
1147 %s effort = \"%.2fH\"''' % (ident,task.id, ident,task.remaining_hours, ident,task.total_hours)
1149 for t2 in task.parent_ids:
1150 start.append("up.Task_%s.end" % (t2.id,))
1154 ''' % (ident,','.join(start))
1159 ''' % (ident, 'User_'+str(task.user_id.id))
1164 # ---------------------------------------------------
1166 # ---------------------------------------------------
1168 def message_get_reply_to(self, cr, uid, ids, context=None):
1169 """ Override to get the reply_to of the parent project. """
1170 return [task.project_id.message_get_reply_to()[0] if task.project_id else False
1171 for task in self.browse(cr, uid, ids, context=context)]
1173 def message_new(self, cr, uid, msg, custom_values=None, context=None):
1174 """ Override to updates the document according to the email. """
1175 if custom_values is None: custom_values = {}
1177 'name': msg.get('subject'),
1178 'planned_hours': 0.0,
1180 defaults.update(custom_values)
1181 return super(task,self).message_new(cr, uid, msg, custom_values=defaults, context=context)
1183 def message_update(self, cr, uid, ids, msg, update_vals=None, context=None):
1184 """ Override to update the task according to the email. """
1185 if update_vals is None: update_vals = {}
1188 'cost':'planned_hours',
1190 for line in msg['body'].split('\n'):
1192 res = tools.command_re.match(line)
1194 match = res.group(1).lower()
1195 field = maps.get(match)
1198 update_vals[field] = float(res.group(2).lower())
1199 except (ValueError, TypeError):
1201 elif match.lower() == 'state' \
1202 and res.group(2).lower() in ['cancel','close','draft','open','pending']:
1203 act = 'do_%s' % res.group(2).lower()
1205 getattr(self,act)(cr, uid, ids, context=context)
1206 return super(task,self).message_update(cr, uid, ids, msg, update_vals=update_vals, context=context)
1208 def project_task_reevaluate(self, cr, uid, ids, context=None):
1209 if self.pool.get('res.users').has_group(cr, uid, 'project.group_time_work_estimation_tasks'):
1211 'view_type': 'form',
1212 "view_mode": 'form',
1213 'res_model': 'project.task.reevaluate',
1214 'type': 'ir.actions.act_window',
1217 return self.do_reopen(cr, uid, ids, context=context)
1219 class project_work(osv.osv):
1220 _name = "project.task.work"
1221 _description = "Project Task Work"
1223 'name': fields.char('Work summary', size=128),
1224 'date': fields.datetime('Date', select="1"),
1225 'task_id': fields.many2one('project.task', 'Task', ondelete='cascade', required=True, select="1"),
1226 'hours': fields.float('Time Spent'),
1227 'user_id': fields.many2one('res.users', 'Done by', required=True, select="1"),
1228 'company_id': fields.related('task_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True)
1232 'user_id': lambda obj, cr, uid, context: uid,
1233 'date': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S')
1236 _order = "date desc"
1237 def create(self, cr, uid, vals, *args, **kwargs):
1238 if 'hours' in vals and (not vals['hours']):
1239 vals['hours'] = 0.00
1240 if 'task_id' in vals:
1241 cr.execute('update project_task set remaining_hours=remaining_hours - %s where id=%s', (vals.get('hours',0.0), vals['task_id']))
1242 return super(project_work,self).create(cr, uid, vals, *args, **kwargs)
1244 def write(self, cr, uid, ids, vals, context=None):
1245 if 'hours' in vals and (not vals['hours']):
1246 vals['hours'] = 0.00
1248 for work in self.browse(cr, uid, ids, context=context):
1249 cr.execute('update project_task set remaining_hours=remaining_hours - %s + (%s) where id=%s', (vals.get('hours',0.0), work.hours, work.task_id.id))
1250 return super(project_work,self).write(cr, uid, ids, vals, context)
1252 def unlink(self, cr, uid, ids, *args, **kwargs):
1253 for work in self.browse(cr, uid, ids):
1254 cr.execute('update project_task set remaining_hours=remaining_hours + %s where id=%s', (work.hours, work.task_id.id))
1255 return super(project_work,self).unlink(cr, uid, ids,*args, **kwargs)
1258 class account_analytic_account(osv.osv):
1259 _inherit = 'account.analytic.account'
1260 _description = 'Analytic Account'
1262 'use_tasks': fields.boolean('Tasks',help="If checked, this contract will be available in the project menu and you will be able to manage tasks or track issues"),
1263 'company_uom_id': fields.related('company_id', 'project_time_mode_id', type='many2one', relation='product.uom'),
1266 def on_change_template(self, cr, uid, ids, template_id, context=None):
1267 res = super(account_analytic_account, self).on_change_template(cr, uid, ids, template_id, context=context)
1268 if template_id and 'value' in res:
1269 template = self.browse(cr, uid, template_id, context=context)
1270 res['value']['use_tasks'] = template.use_tasks
1273 def _trigger_project_creation(self, cr, uid, vals, context=None):
1275 This function is used to decide if a project needs to be automatically created or not when an analytic account is created. It returns True if it needs to be so, False otherwise.
1277 if context is None: context = {}
1278 return vals.get('use_tasks') and not 'project_creation_in_progress' in context
1280 def project_create(self, cr, uid, analytic_account_id, vals, context=None):
1282 This function is called at the time of analytic account creation and is used to create a project automatically linked to it if the conditions are meet.
1284 project_pool = self.pool.get('project.project')
1285 project_id = project_pool.search(cr, uid, [('analytic_account_id','=', analytic_account_id)])
1286 if not project_id and self._trigger_project_creation(cr, uid, vals, context=context):
1288 'name': vals.get('name'),
1289 'analytic_account_id': analytic_account_id,
1290 'type': vals.get('type','contract'),
1292 return project_pool.create(cr, uid, project_values, context=context)
1295 def create(self, cr, uid, vals, context=None):
1298 if vals.get('child_ids', False) and context.get('analytic_project_copy', False):
1299 vals['child_ids'] = []
1300 analytic_account_id = super(account_analytic_account, self).create(cr, uid, vals, context=context)
1301 self.project_create(cr, uid, analytic_account_id, vals, context=context)
1302 return analytic_account_id
1304 def write(self, cr, uid, ids, vals, context=None):
1305 vals_for_project = vals.copy()
1306 for account in self.browse(cr, uid, ids, context=context):
1307 if not vals.get('name'):
1308 vals_for_project['name'] = account.name
1309 if not vals.get('type'):
1310 vals_for_project['type'] = account.type
1311 self.project_create(cr, uid, account.id, vals_for_project, context=context)
1312 return super(account_analytic_account, self).write(cr, uid, ids, vals, context=context)
1314 def unlink(self, cr, uid, ids, *args, **kwargs):
1315 project_obj = self.pool.get('project.project')
1316 analytic_ids = project_obj.search(cr, uid, [('analytic_account_id','in',ids)])
1318 raise osv.except_osv(_('Warning!'), _('Please delete the project linked with this account first.'))
1319 return super(account_analytic_account, self).unlink(cr, uid, ids, *args, **kwargs)
1321 class project_project(osv.osv):
1322 _inherit = 'project.project'
1327 class project_task_history(osv.osv):
1329 Tasks History, used for cumulative flow charts (Lean/Agile)
1331 _name = 'project.task.history'
1332 _description = 'History of Tasks'
1333 _rec_name = 'task_id'
1336 def _get_date(self, cr, uid, ids, name, arg, context=None):
1338 for history in self.browse(cr, uid, ids, context=context):
1339 if history.state in ('done','cancelled'):
1340 result[history.id] = history.date
1342 cr.execute('''select
1345 project_task_history
1349 order by id limit 1''', (history.task_id.id, history.id))
1351 result[history.id] = res and res[0] or False
1354 def _get_related_date(self, cr, uid, ids, context=None):
1356 for history in self.browse(cr, uid, ids, context=context):
1357 cr.execute('''select
1360 project_task_history
1364 order by id desc limit 1''', (history.task_id.id, history.id))
1367 result.append(res[0])
1371 'task_id': fields.many2one('project.task', 'Task', ondelete='cascade', required=True, select=True),
1372 'type_id': fields.many2one('project.task.type', 'Stage'),
1373 'state': fields.selection([('draft', 'New'), ('cancelled', 'Cancelled'),('open', 'In Progress'),('pending', 'Pending'), ('done', 'Done')], 'Status'),
1374 'kanban_state': fields.selection([('normal', 'Normal'),('blocked', 'Blocked'),('done', 'Ready for next stage')], 'Kanban State', required=False),
1375 'date': fields.date('Date', select=True),
1376 'end_date': fields.function(_get_date, string='End Date', type="date", store={
1377 'project.task.history': (_get_related_date, None, 20)
1379 'remaining_hours': fields.float('Remaining Time', digits=(16,2)),
1380 'planned_hours': fields.float('Planned Time', digits=(16,2)),
1381 'user_id': fields.many2one('res.users', 'Responsible'),
1384 'date': fields.date.context_today,
1387 class project_task_history_cumulative(osv.osv):
1388 _name = 'project.task.history.cumulative'
1389 _table = 'project_task_history_cumulative'
1390 _inherit = 'project.task.history'
1394 'end_date': fields.date('End Date'),
1395 'project_id': fields.many2one('project.project', 'Project'),
1399 tools.drop_view_if_exists(cr, 'project_task_history_cumulative')
1401 cr.execute(""" CREATE VIEW project_task_history_cumulative AS (
1403 history.date::varchar||'-'||history.history_id::varchar AS id,
1404 history.date AS end_date,
1409 h.date+generate_series(0, CAST((coalesce(h.end_date, DATE 'tomorrow')::date - h.date) AS integer)-1) AS date,
1410 h.task_id, h.type_id, h.user_id, h.kanban_state, h.state,
1411 greatest(h.remaining_hours, 1) AS remaining_hours, greatest(h.planned_hours, 1) AS planned_hours,
1414 project_task_history AS h
1415 JOIN project_task AS t ON (h.task_id = t.id)
1421 class project_category(osv.osv):
1422 """ Category of project's task (or issue) """
1423 _name = "project.category"
1424 _description = "Category of project's task, issue, ..."
1426 'name': fields.char('Name', size=64, required=True, translate=True),
1428 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: