#
##############################################################################
-from openerp import SUPERUSER_ID
-from openerp.addons.base_status.base_stage import base_stage
-from openerp.addons.project.project import _TASK_STATE
-from openerp.addons.crm import crm
from datetime import datetime
-from openerp.osv import fields, osv, orm
-from openerp.tools.translate import _
-import binascii
-import time
+
+from openerp import api
+from openerp import SUPERUSER_ID
from openerp import tools
+from openerp.osv import fields, osv, orm
+from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
from openerp.tools import html2plaintext
+from openerp.tools.translate import _
+
-class project_issue_version(osv.osv):
+class project_issue_version(osv.Model):
_name = "project.issue.version"
_order = "name desc"
_columns = {
- 'name': fields.char('Version Number', size=32, required=True),
+ 'name': fields.char('Version Number', required=True),
'active': fields.boolean('Active', required=False),
}
_defaults = {
'active': 1,
}
-class project_issue(base_stage, osv.osv):
+class project_issue(osv.Model):
_name = "project.issue"
_description = "Project Issue"
- _order = "priority, create_date desc"
+ _order = "priority desc, create_date desc"
_inherit = ['mail.thread', 'ir.needaction_mixin']
+ _mail_post_access = 'read'
_track = {
- 'state': {
- 'project_issue.mt_issue_new': lambda self, cr, uid, obj, ctx=None: obj.state in ['new', 'draft'],
- 'project_issue.mt_issue_closed': lambda self, cr, uid, obj, ctx=None: obj.state == 'done',
- 'project_issue.mt_issue_started': lambda self, cr, uid, obj, ctx=None: obj.state == 'open',
- },
'stage_id': {
- 'project_issue.mt_issue_stage': lambda self, cr, uid, obj, ctx=None: obj.state not in ['new', 'draft', 'done', 'open'],
+ # this is only an heuristics; depending on your particular stage configuration it may not match all 'new' stages
+ 'project_issue.mt_issue_new': lambda self, cr, uid, obj, ctx=None: obj.stage_id and obj.stage_id.sequence <= 1,
+ 'project_issue.mt_issue_stage': lambda self, cr, uid, obj, ctx=None: obj.stage_id and obj.stage_id.sequence > 1,
+ },
+ 'user_id': {
+ 'project_issue.mt_issue_assigned': lambda self, cr, uid, obj, ctx=None: obj.user_id and obj.user_id.id,
},
'kanban_state': {
'project_issue.mt_issue_blocked': lambda self, cr, uid, obj, ctx=None: obj.kanban_state == 'blocked',
+ 'project_issue.mt_issue_ready': lambda self, cr, uid, obj, ctx=None: obj.kanban_state == 'done',
},
}
- def create(self, cr, uid, vals, context=None):
- if context is None:
- context = {}
- if vals.get('project_id') and not context.get('default_project_id'):
- context['default_project_id'] = vals.get('project_id')
-
- # context: no_log, because subtype already handle this
- create_context = dict(context, mail_create_nolog=True)
- return super(project_issue, self).create(cr, uid, vals, context=create_context)
-
def _get_default_partner(self, cr, uid, context=None):
- """ Override of base_stage to add project specific behavior """
project_id = self._get_default_project_id(cr, uid, context)
if project_id:
project = self.pool.get('project.project').browse(cr, uid, project_id, context=context)
if project and project.partner_id:
return project.partner_id.id
- return super(project_issue, self)._get_default_partner(cr, uid, context=context)
+ return False
def _get_default_project_id(self, cr, uid, context=None):
""" Gives default project by checking if present in the context """
def _get_default_stage_id(self, cr, uid, context=None):
""" Gives default stage_id """
project_id = self._get_default_project_id(cr, uid, context=context)
- return self.stage_find(cr, uid, [], project_id, [('state', '=', 'draft')], context=context)
+ return self.stage_find(cr, uid, [], project_id, [('fold', '=', False)], context=context)
def _resolve_project_id_from_context(self, cr, uid, context=None):
""" Returns ID of project based on the value of 'default_project_id'
@return: difference between current date and log date
@param context: A standard dictionary for contextual values
"""
- cal_obj = self.pool.get('resource.calendar')
- res_obj = self.pool.get('resource.resource')
+ Calendar = self.pool['resource.calendar']
- res = {}
+ res = dict.fromkeys(ids, dict())
for issue in self.browse(cr, uid, ids, context=context):
-
+ values = {
+ 'day_open': 0.0, 'day_close': 0.0,
+ 'working_hours_open': 0.0, 'working_hours_close': 0.0,
+ 'days_since_creation': 0.0, 'inactivity_days': 0.0,
+ }
# if the working hours on the project are not defined, use default ones (8 -> 12 and 13 -> 17 * 5), represented by None
- if not issue.project_id or not issue.project_id.resource_calendar_id:
- working_hours = None
+ calendar_id = None
+ if issue.project_id and issue.project_id.resource_calendar_id:
+ calendar_id = issue.project_id.resource_calendar_id.id
+
+ dt_create_date = datetime.strptime(issue.create_date, DEFAULT_SERVER_DATETIME_FORMAT)
+
+ if issue.date_open:
+ dt_date_open = datetime.strptime(issue.date_open, DEFAULT_SERVER_DATETIME_FORMAT)
+ values['day_open'] = (dt_date_open - dt_create_date).total_seconds() / (24.0 * 3600)
+ values['working_hours_open'] = Calendar._interval_hours_get(
+ cr, uid, calendar_id, dt_create_date, dt_date_open,
+ timezone_from_uid=issue.user_id.id or uid,
+ exclude_leaves=False, context=context)
+
+ if issue.date_closed:
+ dt_date_closed = datetime.strptime(issue.date_closed, DEFAULT_SERVER_DATETIME_FORMAT)
+ values['day_close'] = (dt_date_closed - dt_create_date).total_seconds() / (24.0 * 3600)
+ values['working_hours_close'] = Calendar._interval_hours_get(
+ cr, uid, calendar_id, dt_create_date, dt_date_closed,
+ timezone_from_uid=issue.user_id.id or uid,
+ exclude_leaves=False, context=context)
+
+ days_since_creation = datetime.today() - dt_create_date
+ values['days_since_creation'] = days_since_creation.days
+ if issue.date_action_last:
+ inactive_days = datetime.today() - datetime.strptime(issue.date_action_last, DEFAULT_SERVER_DATETIME_FORMAT)
+ elif issue.date_last_stage_update:
+ inactive_days = datetime.today() - datetime.strptime(issue.date_last_stage_update, DEFAULT_SERVER_DATETIME_FORMAT)
else:
- working_hours = issue.project_id.resource_calendar_id.id
+ inactive_days = datetime.today() - datetime.strptime(issue.create_date, DEFAULT_SERVER_DATETIME_FORMAT)
+ values['inactivity_days'] = inactive_days.days
- res[issue.id] = {}
+ # filter only required values
for field in fields:
- duration = 0
- ans = False
- hours = 0
-
- date_create = datetime.strptime(issue.create_date, "%Y-%m-%d %H:%M:%S")
- if field in ['working_hours_open','day_open']:
- if issue.date_open:
- date_open = datetime.strptime(issue.date_open, "%Y-%m-%d %H:%M:%S")
- ans = date_open - date_create
- date_until = issue.date_open
- #Calculating no. of working hours to open the issue
- hours = cal_obj._interval_hours_get(cr, uid, working_hours,
- date_create,
- date_open,
- timezone_from_uid=issue.user_id.id or uid,
- exclude_leaves=False,
- context=context)
- elif field in ['working_hours_close','day_close']:
- if issue.date_closed:
- date_close = datetime.strptime(issue.date_closed, "%Y-%m-%d %H:%M:%S")
- date_until = issue.date_closed
- ans = date_close - date_create
- #Calculating no. of working hours to close the issue
- hours = cal_obj._interval_hours_get(cr, uid, working_hours,
- date_create,
- date_close,
- timezone_from_uid=issue.user_id.id or uid,
- exclude_leaves=False,
- context=context)
- elif field in ['days_since_creation']:
- if issue.create_date:
- days_since_creation = datetime.today() - datetime.strptime(issue.create_date, "%Y-%m-%d %H:%M:%S")
- res[issue.id][field] = days_since_creation.days
- continue
-
- elif field in ['inactivity_days']:
- res[issue.id][field] = 0
- if issue.date_action_last:
- inactive_days = datetime.today() - datetime.strptime(issue.date_action_last, '%Y-%m-%d %H:%M:%S')
- res[issue.id][field] = inactive_days.days
- continue
- if ans:
- resource_id = False
- if issue.user_id:
- resource_ids = res_obj.search(cr, uid, [('user_id','=',issue.user_id.id)])
- if resource_ids and len(resource_ids):
- resource_id = resource_ids[0]
- duration = float(ans.days) + float(ans.seconds)/(24*3600)
-
- if field in ['working_hours_open','working_hours_close']:
- res[issue.id][field] = hours
- elif field in ['day_open','day_close']:
- res[issue.id][field] = duration
+ res[issue.id][field] = values[field]
return res
_columns = {
'id': fields.integer('ID', readonly=True),
- 'name': fields.char('Issue', size=128, required=True),
+ 'name': fields.char('Issue', required=True),
'active': fields.boolean('Active', required=False),
- 'create_date': fields.datetime('Creation Date', readonly=True,select=True),
+ 'create_date': fields.datetime('Creation Date', readonly=True, select=True),
'write_date': fields.datetime('Update Date', readonly=True),
'days_since_creation': fields.function(_compute_day, string='Days since creation date', \
multi='compute_day', type="integer", help="Difference in days between creation date and current date"),
'partner_id': fields.many2one('res.partner', 'Contact', select=1),
'company_id': fields.many2one('res.company', 'Company'),
'description': fields.text('Private Note'),
- 'state': fields.related('stage_id', 'state', type="selection", store=True,
- selection=_TASK_STATE, string="Status", readonly=True,
- help='The status is set to \'Draft\', when a case is created.\
- If the case is in progress the status is set to \'Open\'.\
- When the case is over, the status is set to \'Done\'.\
- If the case needs to be reviewed then the status is \
- set to \'Pending\'.'),
'kanban_state': fields.selection([('normal', 'Normal'),('blocked', 'Blocked'),('done', 'Ready for next stage')], 'Kanban State',
track_visibility='onchange',
help="A Issue's kanban state indicates special situations affecting it:\n"
" * Normal is the default situation\n"
" * Blocked indicates something is preventing the progress of this issue\n"
" * Ready for next stage indicates the issue is ready to be pulled to the next stage",
- readonly=True, required=False),
+ required=False),
'email_from': fields.char('Email', size=128, help="These people will receive email.", select=1),
'email_cc': fields.char('Watchers Emails', size=256, help="These email addresses will be added to the CC field of all inbound and outbound emails for this record before being sent. Separate multiple email addresses with a comma"),
- 'date_open': fields.datetime('Opened', readonly=True,select=True),
+ 'date_open': fields.datetime('Assigned', readonly=True, select=True),
# Project Issue fields
- 'date_closed': fields.datetime('Closed', readonly=True,select=True),
+ 'date_closed': fields.datetime('Closed', readonly=True, select=True),
'date': fields.datetime('Date'),
- 'channel_id': fields.many2one('crm.case.channel', 'Channel', help="Communication channel."),
+ 'date_last_stage_update': fields.datetime('Last Stage Update', select=True),
+ 'channel': fields.char('Channel', help="Communication channel."),
'categ_ids': fields.many2many('project.category', string='Tags'),
- 'priority': fields.selection(crm.AVAILABLE_PRIORITIES, 'Priority', select=True),
+ 'priority': fields.selection([('0','Low'), ('1','Normal'), ('2','High')], 'Priority', select=True),
'version_id': fields.many2one('project.issue.version', 'Version'),
'stage_id': fields.many2one ('project.task.type', 'Stage',
- track_visibility='onchange',
- domain="[('project_ids', '=', project_id)]"),
- 'project_id':fields.many2one('project.project', 'Project', track_visibility='onchange'),
+ track_visibility='onchange', select=True,
+ domain="[('project_ids', '=', project_id)]", copy=False),
+ 'project_id': fields.many2one('project.project', 'Project', track_visibility='onchange', select=True),
'duration': fields.float('Duration'),
'task_id': fields.many2one('project.task', 'Task', domain="[('project_id','=',project_id)]"),
- 'day_open': fields.function(_compute_day, string='Days to Open', \
- multi='compute_day', type="float", store=True),
- 'day_close': fields.function(_compute_day, string='Days to Close', \
- multi='compute_day', type="float", store=True),
+ 'day_open': fields.function(_compute_day, string='Days to Assign',
+ multi='compute_day', type="float",
+ store={'project.issue': (lambda self, cr, uid, ids, c={}: ids, ['date_open'], 10)}),
+ 'day_close': fields.function(_compute_day, string='Days to Close',
+ multi='compute_day', type="float",
+ store={'project.issue': (lambda self, cr, uid, ids, c={}: ids, ['date_closed'], 10)}),
'user_id': fields.many2one('res.users', 'Assigned to', required=False, select=1, track_visibility='onchange'),
- 'working_hours_open': fields.function(_compute_day, string='Working Hours to Open the Issue', \
- multi='compute_day', type="float", store=True),
- 'working_hours_close': fields.function(_compute_day, string='Working Hours to Close the Issue', \
- multi='compute_day', type="float", store=True),
- 'inactivity_days': fields.function(_compute_day, string='Days since last action', \
- multi='compute_day', type="integer", help="Difference in days between last action and current date"),
+ 'working_hours_open': fields.function(_compute_day, string='Working Hours to assign the Issue',
+ multi='compute_day', type="float",
+ store={'project.issue': (lambda self, cr, uid, ids, c={}: ids, ['date_open'], 10)}),
+ 'working_hours_close': fields.function(_compute_day, string='Working Hours to close the Issue',
+ multi='compute_day', type="float",
+ store={'project.issue': (lambda self, cr, uid, ids, c={}: ids, ['date_closed'], 10)}),
+ 'inactivity_days': fields.function(_compute_day, string='Days since last action',
+ multi='compute_day', type="integer", help="Difference in days between last action and current date"),
'color': fields.integer('Color Index'),
'user_email': fields.related('user_id', 'email', type='char', string='User Email', readonly=True),
'date_action_last': fields.datetime('Last Action', readonly=1),
_defaults = {
'active': 1,
- 'partner_id': lambda s, cr, uid, c: s._get_default_partner(cr, uid, c),
- 'email_from': lambda s, cr, uid, c: s._get_default_email(cr, uid, c),
'stage_id': lambda s, cr, uid, c: s._get_default_stage_id(cr, uid, c),
- 'section_id': lambda s, cr, uid, c: s._get_default_section_id(cr, uid, c),
'company_id': lambda s, cr, uid, c: s.pool.get('res.company')._company_default_get(cr, uid, 'crm.helpdesk', context=c),
- 'priority': crm.AVAILABLE_PRIORITIES[2][0],
+ 'priority': '0',
'kanban_state': 'normal',
+ 'date_last_stage_update': fields.datetime.now,
'user_id': lambda obj, cr, uid, context: uid,
}
'stage_id': _read_group_stage_ids
}
- def set_priority(self, cr, uid, ids, priority, *args):
- """Set lead priority
- """
- return self.write(cr, uid, ids, {'priority' : priority})
-
- def set_high_priority(self, cr, uid, ids, *args):
- """Set lead priority to high
- """
- return self.set_priority(cr, uid, ids, '1')
-
- def set_normal_priority(self, cr, uid, ids, *args):
- """Set lead priority to normal
- """
- return self.set_priority(cr, uid, ids, '3')
-
- def convert_issue_task(self, cr, uid, ids, context=None):
- if context is None:
- context = {}
-
- case_obj = self.pool.get('project.issue')
- data_obj = self.pool.get('ir.model.data')
- task_obj = self.pool.get('project.task')
-
- result = data_obj._get_id(cr, uid, 'project', 'view_task_search_form')
- res = data_obj.read(cr, uid, result, ['res_id'])
- id2 = data_obj._get_id(cr, uid, 'project', 'view_task_form2')
- id3 = data_obj._get_id(cr, uid, 'project', 'view_task_tree2')
- if id2:
- id2 = data_obj.browse(cr, uid, id2, context=context).res_id
- if id3:
- id3 = data_obj.browse(cr, uid, id3, context=context).res_id
-
- for bug in case_obj.browse(cr, uid, ids, context=context):
- new_task_id = task_obj.create(cr, uid, {
- 'name': bug.name,
- 'partner_id': bug.partner_id.id,
- 'description':bug.description,
- 'date_deadline': bug.date,
- 'project_id': bug.project_id.id,
- # priority must be in ['0','1','2','3','4'], while bug.priority is in ['1','2','3','4','5']
- 'priority': str(int(bug.priority) - 1),
- 'user_id': bug.user_id.id,
- 'planned_hours': 0.0,
- })
- vals = {
- 'task_id': new_task_id,
- 'stage_id': self.stage_find(cr, uid, [bug], bug.project_id.id, [('state', '=', 'pending')], context=context),
- }
- message = _("Project issue <b>converted</b> to task.")
- self.message_post(cr, uid, [bug.id], body=message, context=context)
- case_obj.write(cr, uid, [bug.id], vals, context=context)
-
- return {
- 'name': _('Tasks'),
- 'view_type': 'form',
- 'view_mode': 'form,tree',
- 'res_model': 'project.task',
- 'res_id': int(new_task_id),
- 'view_id': False,
- 'views': [(id2,'form'),(id3,'tree'),(False,'calendar'),(False,'graph')],
- 'type': 'ir.actions.act_window',
- 'search_view_id': res['res_id'],
- 'nodestroy': True
- }
-
def copy(self, cr, uid, id, default=None, context=None):
- issue = self.read(cr, uid, id, ['name'], context=context)
+ issue = self.read(cr, uid, [id], ['name'], context=context)[0]
if not default:
default = {}
default = default.copy()
default.update(name=_('%s (copy)') % (issue['name']))
- return super(project_issue, self).copy(cr, uid, id, default=default,
- context=context)
+ return super(project_issue, self).copy(cr, uid, id, default=default, context=context)
+
+ def create(self, cr, uid, vals, context=None):
+ context = dict(context or {})
+ if vals.get('project_id') and not context.get('default_project_id'):
+ context['default_project_id'] = vals.get('project_id')
+ if vals.get('user_id'):
+ vals['date_open'] = fields.datetime.now()
+ if 'stage_id' in vals:
+ vals.update(self.onchange_stage_id(cr, uid, None, vals.get('stage_id'), context=context)['value'])
+
+ # context: no_log, because subtype already handle this
+ create_context = dict(context, mail_create_nolog=True)
+ return super(project_issue, self).create(cr, uid, vals, context=create_context)
def write(self, cr, uid, ids, vals, context=None):
-
- #Update last action date every time the user changes the stage
+ # stage change: update date_last_stage_update
if 'stage_id' in vals:
- vals['date_action_last'] = time.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)
- state = self.pool.get('project.task.type').browse(cr, uid, vals['stage_id'], context=context).state
- for issue in self.browse(cr, uid, ids, context=context):
- # Change from draft to not draft EXCEPT cancelled: The issue has been opened -> set the opening date
- if issue.state == 'draft' and state not in ('draft', 'cancelled'):
- vals['date_open'] = time.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)
- # Change from not done to done: The issue has been closed -> set the closing date
- if issue.state != 'done' and state == 'done':
- vals['date_closed'] = time.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)
+ vals.update(self.onchange_stage_id(cr, uid, ids, vals.get('stage_id'), context=context)['value'])
+ vals['date_last_stage_update'] = fields.datetime.now()
+ if 'kanban_state' not in vals:
+ vals['kanban_state'] = 'normal'
+ # user_id change: update date_start
+ if vals.get('user_id'):
+ vals['date_open'] = fields.datetime.now()
return super(project_issue, self).write(cr, uid, ids, vals, context)
task = self.pool.get('project.task').browse(cr, uid, task_id, context=context)
return {'value': {'user_id': task.user_id.id, }}
- def case_reset(self, cr, uid, ids, context=None):
- """Resets case as draft
+ def onchange_partner_id(self, cr, uid, ids, partner_id, context=None):
+ """ This function returns value of partner email address based on partner
+ :param part: Partner's id
"""
- res = super(project_issue, self).case_reset(cr, uid, ids, context)
- self.write(cr, uid, ids, {'date_open': False, 'date_closed': False})
- return res
+ result = {}
+ if partner_id:
+ partner = self.pool['res.partner'].browse(cr, uid, partner_id, context)
+ result['email_from'] = partner.email
+ return {'value': result}
def get_empty_list_help(self, cr, uid, help, context=None):
+ context = dict(context or {})
context['empty_list_help_model'] = 'project.project'
context['empty_list_help_id'] = context.get('default_project_id')
context['empty_list_help_document_name'] = _("issues")
# Stage management
# -------------------------------------------------------
- def set_kanban_state_blocked(self, cr, uid, ids, context=None):
- return self.write(cr, uid, ids, {'kanban_state': 'blocked'}, context=context)
-
- def set_kanban_state_normal(self, cr, uid, ids, context=None):
- return self.write(cr, uid, ids, {'kanban_state': 'normal'}, context=context)
-
- def set_kanban_state_done(self, cr, uid, ids, context=None):
- return self.write(cr, uid, ids, {'kanban_state': 'done'}, context=context)
+ def onchange_stage_id(self, cr, uid, ids, stage_id, context=None):
+ if not stage_id:
+ return {'value': {}}
+ stage = self.pool['project.task.type'].browse(cr, uid, stage_id, context=context)
+ if stage.fold:
+ return {'value': {'date_closed': fields.datetime.now()}}
+ return {'value': {'date_closed': False}}
def stage_find(self, cr, uid, cases, section_id, domain=[], order='sequence', context=None):
""" Override of the base.stage method
return stage_ids[0]
return False
- def case_cancel(self, cr, uid, ids, context=None):
- """ Cancels case """
- self.case_set(cr, uid, ids, 'cancelled', {'active': True}, context=context)
- return True
-
- def case_escalate(self, cr, uid, ids, context=None):
- cases = self.browse(cr, uid, ids)
- for case in cases:
+ def case_escalate(self, cr, uid, ids, context=None): # FIXME rename this method to issue_escalate
+ for issue in self.browse(cr, uid, ids, context=context):
data = {}
- if case.project_id.project_escalation_id:
- data['project_id'] = case.project_id.project_escalation_id.id
- if case.project_id.project_escalation_id.user_id:
- data['user_id'] = case.project_id.project_escalation_id.user_id.id
- if case.task_id:
- self.pool.get('project.task').write(cr, uid, [case.task_id.id], {'project_id': data['project_id'], 'user_id': False})
- else:
+ esc_proj = issue.project_id.project_escalation_id
+ if not esc_proj:
raise osv.except_osv(_('Warning!'), _('You cannot escalate this issue.\nThe relevant Project has not configured the Escalation Project!'))
- self.case_set(cr, uid, ids, 'draft', data, context=context)
+
+ data['project_id'] = esc_proj.id
+ if esc_proj.user_id:
+ data['user_id'] = esc_proj.user_id.id
+ issue.write(data)
+
+ if issue.task_id:
+ issue.task_id.write({'project_id': esc_proj.id, 'user_id': False})
return True
# -------------------------------------------------------
def message_get_reply_to(self, cr, uid, ids, context=None):
""" Override to get the reply_to of the parent project. """
- return [issue.project_id.message_get_reply_to()[0] if issue.project_id else False
- for issue in self.browse(cr, uid, ids, context=context)]
-
- def check_mail_message_access(self, cr, uid, mids, operation, model_obj=None, context=None):
- """ mail.message document permission rule: can post a new message if can read
- because of portal document. """
- if not model_obj:
- model_obj = self
- if operation == 'create':
- model_obj.check_access_rights(cr, uid, 'read')
- model_obj.check_access_rule(cr, uid, mids, 'read', context=context)
- else:
- return super(project_issue, self).check_mail_message_access(cr, uid, mids, operation, model_obj=model_obj, context=context)
+ issues = self.browse(cr, SUPERUSER_ID, ids, context=context)
+ project_ids = set([issue.project_id.id for issue in issues if issue.project_id])
+ aliases = self.pool['project.project'].message_get_reply_to(cr, uid, list(project_ids), context=context)
+ return dict((issue.id, aliases.get(issue.project_id and issue.project_id.id or 0, False)) for issue in issues)
def message_get_suggested_recipients(self, cr, uid, ids, context=None):
recipients = super(project_issue, self).message_get_suggested_recipients(cr, uid, ids, context=context)
through message_process.
This override updates the document according to the email.
"""
- if custom_values is None: custom_values = {}
- if context is None: context = {}
- context['state_to'] = 'draft'
-
- desc = html2plaintext(msg.get('body')) if msg.get('body') else ''
-
+ if custom_values is None:
+ custom_values = {}
+ context = dict(context or {}, state_to='draft')
defaults = {
'name': msg.get('subject') or _("No Subject"),
- 'description': desc,
'email_from': msg.get('from'),
'email_cc': msg.get('cc'),
'partner_id': msg.get('author_id', False),
'user_id': False,
}
- if msg.get('priority'):
- defaults['priority'] = msg.get('priority')
-
defaults.update(custom_values)
res_id = super(project_issue, self).message_new(cr, uid, msg, custom_values=defaults, context=context)
return res_id
- def message_update(self, cr, uid, ids, msg, update_vals=None, context=None):
- """ Overrides mail_thread message_update that is called by the mailgateway
- through message_process.
- This method updates the document according to the email.
- """
- if isinstance(ids, (str, int, long)):
- ids = [ids]
- if update_vals is None: update_vals = {}
-
- # Update doc values according to the message
- if msg.get('priority'):
- update_vals['priority'] = msg.get('priority')
- # Parse 'body' to find values to update
- maps = {
- 'cost': 'planned_cost',
- 'revenue': 'planned_revenue',
- 'probability': 'probability',
- }
- for line in msg.get('body', '').split('\n'):
- line = line.strip()
- res = tools.command_re.match(line)
- if res and maps.get(res.group(1).lower(), False):
- key = maps.get(res.group(1).lower())
- update_vals[key] = res.group(2).lower()
-
- return super(project_issue, self).message_update(cr, uid, ids, msg, update_vals=update_vals, context=context)
-
+ @api.cr_uid_ids_context
def message_post(self, cr, uid, thread_id, body='', subject=None, type='notification', subtype=None, parent_id=False, attachments=None, context=None, content_subtype='html', **kwargs):
""" Overrides mail_thread message_post so that we can set the date of last action field when
a new message is posted on the issue.
context = {}
res = super(project_issue, self).message_post(cr, uid, thread_id, body=body, subject=subject, type=type, subtype=subtype, parent_id=parent_id, attachments=attachments, context=context, content_subtype=content_subtype, **kwargs)
if thread_id and subtype:
- self.write(cr, SUPERUSER_ID, thread_id, {'date_action_last': time.strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT)}, context=context)
+ self.write(cr, SUPERUSER_ID, thread_id, {'date_action_last': fields.datetime.now()}, context=context)
return res
return [('project.task', "Tasks"), ("project.issue", "Issues")]
def _issue_count(self, cr, uid, ids, field_name, arg, context=None):
- res = dict.fromkeys(ids, 0)
- issue_ids = self.pool.get('project.issue').search(cr, uid, [('project_id', 'in', ids)])
- for issue in self.pool.get('project.issue').browse(cr, uid, issue_ids, context):
- if issue.state not in ('done', 'cancelled'):
- res[issue.project_id.id] += 1
- return res
-
+ Issue = self.pool['project.issue']
+ return {
+ project_id: Issue.search_count(cr,uid, [('project_id', '=', project_id), ('stage_id.fold', '=', False)], context=context)
+ for project_id in ids
+ }
_columns = {
'project_escalation_id': fields.many2one('project.project', 'Project Escalation',
help='If any issue is escalated from the current Project, it will be listed under the project selected here.',
states={'close': [('readonly', True)], 'cancelled': [('readonly', True)]}),
- 'issue_count': fields.function(_issue_count, type='integer', string="Unclosed Issues"),
+ 'issue_count': fields.function(_issue_count, type='integer', string="Issues",),
+ 'issue_ids': fields.one2many('project.issue', 'project_id',
+ domain=[('stage_id.fold', '=', False)])
}
def _check_escalation(self, cr, uid, ids, context=None):
'use_issues': fields.boolean('Issues', help="Check this field if this project manages issues"),
}
- def on_change_template(self, cr, uid, ids, template_id, context=None):
- res = super(account_analytic_account, self).on_change_template(cr, uid, ids, template_id, context=context)
+ def on_change_template(self, cr, uid, ids, template_id, date_start=False, context=None):
+ res = super(account_analytic_account, self).on_change_template(cr, uid, ids, template_id, date_start=date_start, context=context)
if template_id and 'value' in res:
template = self.browse(cr, uid, template_id, context=context)
res['value']['use_issues'] = template.use_issues
self._check_create_write_values(cr, uid, vals, context=context)
return super(project_project, self).write(cr, uid, ids, vals, context=context)
-
+class res_partner(osv.osv):
+ def _issue_count(self, cr, uid, ids, field_name, arg, context=None):
+ Issue = self.pool['project.issue']
+ return {
+ partner_id: Issue.search_count(cr,uid, [('partner_id', '=', partner_id)])
+ for partner_id in ids
+ }
+
+ """ Inherits partner and adds Issue information in the partner form """
+ _inherit = 'res.partner'
+ _columns = {
+ 'issue_count': fields.function(_issue_count, string='# Issues', type='integer'),
+ }
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
projects / odoo / odoo.git / blobdiff