Odoo18-Base/addons/mail/models/mail_activity_plan_template.py
2025-01-06 10:57:38 +07:00

150 lines
6.8 KiB
Python

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from dateutil.relativedelta import relativedelta
from odoo import api, fields, models, _
from odoo.exceptions import ValidationError
class MailActivityPlanTemplate(models.Model):
_name = 'mail.activity.plan.template'
_order = 'sequence,id'
_description = 'Activity plan template'
_rec_name = 'summary'
plan_id = fields.Many2one(
'mail.activity.plan', string="Plan",
ondelete='cascade', required=True)
res_model = fields.Selection(related="plan_id.res_model")
company_id = fields.Many2one(related='plan_id.company_id')
sequence = fields.Integer(default=10)
activity_type_id = fields.Many2one(
'mail.activity.type', 'Activity Type',
default=lambda self: self.env.ref('mail.mail_activity_data_todo'),
domain="['|', ('res_model', '=', False), '&', ('res_model', '!=', False), ('res_model', '=', parent.res_model)]",
ondelete='restrict', required=True
)
# Activity type delay fields are ignored in favor of these
delay_count = fields.Integer(
'Interval', default=0,
help='Number of days/week/month before executing the action after or before the scheduled plan date.')
delay_unit = fields.Selection([
('days', 'days'),
('weeks', 'weeks'),
('months', 'months')],
string="Delay units", help="Unit of delay", required=True, default='days')
delay_from = fields.Selection([
('before_plan_date', 'Before Plan Date'),
('after_plan_date', 'After Plan Date'),
],
string='Trigger', default="before_plan_date", required=True)
icon = fields.Char('Icon', related='activity_type_id.icon', readonly=True)
summary = fields.Char('Summary', compute="_compute_summary", store=True, readonly=False)
responsible_type = fields.Selection([
('on_demand', 'Ask at launch'),
('other', 'Default user'),
], default='on_demand', string='Assignment', required=True,
compute="_compute_responsible_type", store=True, readonly=False)
responsible_id = fields.Many2one(
'res.users',
'Assigned to',
check_company=True, compute="_compute_responsible_id", store=True, readonly=False)
note = fields.Html('Note', compute="_compute_note", store=True, readonly=False)
@api.constrains('activity_type_id', 'plan_id')
def _check_activity_type_res_model(self):
""" Check that the plan models are compatible with the template activity
type model. Note that it depends also on "activity_type_id.res_model" and
"plan_id.res_model". That's why this method is called by those models
when the mentioned fields are updated.
"""
for template in self.filtered(lambda tpl: tpl.activity_type_id.res_model):
if template.activity_type_id.res_model != template.plan_id.res_model:
raise ValidationError(
_('The activity type "%(activity_type_name)s" is not compatible with the plan "%(plan_name)s"'
' because it is limited to the model "%(activity_type_model)s".',
activity_type_name=template.activity_type_id.name,
activity_type_model=template.activity_type_id.res_model,
plan_name=template.plan_id.name,
)
)
@api.constrains('responsible_id', 'responsible_type')
def _check_responsible(self):
""" Ensure that responsible_id is set when responsible is set to "other". """
for template in self:
if template.responsible_type == 'other' and not template.responsible_id:
raise ValidationError(_('When selecting "Default user" assignment, you must specify a responsible.'))
@api.depends('activity_type_id')
def _compute_note(self):
for template in self:
template.note = template.activity_type_id.default_note
@api.depends('activity_type_id', 'responsible_type')
def _compute_responsible_id(self):
for template in self:
template.responsible_id = template.activity_type_id.default_user_id
if template.responsible_type != 'other' and template.responsible_id:
template.responsible_id = False
@api.depends('activity_type_id')
def _compute_responsible_type(self):
for template in self:
if template.activity_type_id.default_user_id:
template.responsible_type = 'other'
else:
template.responsible_type = 'on_demand'
@api.depends('activity_type_id')
def _compute_summary(self):
for template in self:
template.summary = template.activity_type_id.summary
def _get_date_deadline(self, base_date=False):
""" Return the deadline of the activity to be created given the base date. """
self.ensure_one()
base_date = base_date or fields.Date.context_today(self)
delta = relativedelta(**{self.delay_unit: self.delay_count})
if self.delay_from == 'after_plan_date':
return base_date + delta
return base_date - delta
def _determine_responsible(self, on_demand_responsible, applied_on_record):
""" Determine the responsible for the activity based on the template
for the given record and on demand responsible.
Based on the responsible_type, this method will determine the responsible
to set on the activity for the given record (applied_on_record).
Following the responsible_type:
- on_demand: on_demand_responsible is used as responsible (allow to set it
when using the template)
- other: the responsible field is used (preset user at the template level)
Other module can extend it and base the responsible on the record on which
the activity will be set. Ex.: 'coach' on employee record will assign the
coach user of the employee.
:param <res.user> on_demand_responsible: on demand responsible
:param recordset applied_on_record: the record on which the activity
will be created
:return dict: {'responsible': <res.user>, error: str|False}
"""
self.ensure_one()
error = False
if self.responsible_type == 'other':
responsible = self.responsible_id
elif self.responsible_type == 'on_demand':
responsible = on_demand_responsible
if not responsible:
error = _('No responsible specified for %(activity_type_name)s: %(activity_summary)s.',
activity_type_name=self.activity_type_id.name,
activity_summary=self.summary or '-')
else:
raise ValueError(f'Invalid responsible value {self.responsible_type}.')
return {
'responsible': responsible,
'error': error,
}