class ProductTemplate(models.Model):
_inherit = "product.template"
quotation_only_description = fields.Html(
'Quotation Only Description',
sanitize_attributes=False,
translate=html_translate,
help="The quotation description (not used on eCommerce)")
quotation_description = fields.Html(
'Quotation Description',
compute='_compute_quotation_description',
help=
"This field uses the Quotation Only Description if it is defined, otherwise it will try to read the eCommerce Description."
)
def _compute_quotation_description(self):
for record in self:
if record.quotation_only_description:
record.quotation_description = record.quotation_only_description
elif hasattr(record,
'website_description') and record.website_description:
record.quotation_description = record.website_description
else:
record.quotation_description = ''
class KarmaRank(models.Model):
_name = 'gamification.karma.rank'
_description = 'Rank based on karma'
_inherit = 'image.mixin'
_order = 'karma_min'
name = fields.Text(string='Rank Name', translate=True, required=True)
description = fields.Html(
string='Description',
translate=html_translate,
sanitize_attributes=False,
)
description_motivational = fields.Html(
string='Motivational',
translate=html_translate,
sanitize_attributes=False,
help="Motivational phrase to reach this rank")
karma_min = fields.Integer(string='Required Karma',
help='Minimum karma needed to reach this rank')
user_ids = fields.One2many('res.users',
'rank_id',
string='Users',
help="Users having this rank")
@api.model_create_multi
def create(self, values_list):
res = super(KarmaRank, self).create(values_list)
users = self.env['res.users'].sudo().search([('karma', '>', 0)])
users._recompute_rank()
return res
def write(self, vals):
if 'karma_min' in vals:
previous_ranks = self.env['gamification.karma.rank'].search(
[], order="karma_min DESC").ids
low = min(vals['karma_min'], self.karma_min)
high = max(vals['karma_min'], self.karma_min)
res = super(KarmaRank, self).write(vals)
if 'karma_min' in vals:
after_ranks = self.env['gamification.karma.rank'].search(
[], order="karma_min DESC").ids
if previous_ranks != after_ranks:
users = self.env['res.users'].sudo().search([('karma', '>', 0)
])
else:
users = self.env['res.users'].sudo().search([
('karma', '>=', low), ('karma', '<=', high)
])
users._recompute_rank()
return res
class SaleOrder(models.Model):
_inherit = 'sale.order'
website_description = fields.Html('Website Description', sanitize_attributes=False, translate=html_translate)
@api.onchange('partner_id')
def onchange_update_description_lang(self):
if not self.sale_order_template_id:
return
else:
template = self.sale_order_template_id.with_context(lang=self.partner_id.lang)
self.website_description = template.website_description
def _compute_line_data_for_template_change(self, line):
vals = super(SaleOrder, self)._compute_line_data_for_template_change(line)
vals.update(website_description=line.website_description)
return vals
def _compute_option_data_for_template_change(self, option):
vals = super(SaleOrder, self)._compute_option_data_for_template_change(option)
vals.update(website_description=option.website_description)
return vals
@api.onchange('sale_order_template_id')
def onchange_sale_order_template_id(self):
ret = super(SaleOrder, self).onchange_sale_order_template_id()
if self.sale_order_template_id:
template = self.sale_order_template_id.with_context(lang=self.partner_id.lang)
self.website_description = template.website_description
return ret
class SaleOrderTemplateLine(models.Model):
_inherit = "sale.order.template.line"
website_description = fields.Html(
'Website Description',
related='product_id.product_tmpl_id.quotation_only_description',
translate=html_translate,
readonly=False)
@api.onchange('product_id')
def _onchange_product_id(self):
ret = super(SaleOrderTemplateLine, self)._onchange_product_id()
if self.product_id:
self.website_description = self.product_id.quotation_description
return ret
@api.model
def create(self, values):
values = self._inject_quotation_description(values)
return super(SaleOrderTemplateLine, self).create(values)
def write(self, values):
values = self._inject_quotation_description(values)
return super(SaleOrderTemplateLine, self).write(values)
def _inject_quotation_description(self, values):
values = dict(values or {})
if not values.get('website_description') and values.get('product_id'):
product = self.env['product.product'].browse(values['product_id'])
values['website_description'] = product.quotation_description
return values
class ConverterTest(models.Model):
_name = 'web_editor.converter.test'
_description = 'Web Editor Converter Test'
# disable translation export for those brilliant field labels and values
_translate = False
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('web_editor.converter.test.sub')
binary = fields.Binary(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
selection_str = fields.Selection(
[
('A', "Qu'il n'est pas arrivé à Toronto"),
('B', "Qu'il était supposé arriver à Toronto"),
('C', "Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', "La réponse D"),
],
string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
class test_model(models.Model):
_name = 'test_converter.test_model'
_description = 'Test Converter Model'
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('test_converter.test_model.sub',
group_expand='_gbf_m2o')
binary = fields.Binary(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
selection_str = fields.Selection(
[
('A', u"Qu'il n'est pas arrivé à Toronto"),
('B', u"Qu'il était supposé arriver à Toronto"),
('C', u"Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', u"La réponse D"),
],
string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
# `base` module does not contains any model that implement the functionality
# `group_expand`; test this feature here...
@api.model
def _gbf_m2o(self, subs, domain, order):
sub_ids = subs._search([], order=order, access_rights_uid=SUPERUSER_ID)
return subs.browse(sub_ids)
class SaleOrderTemplateOption(models.Model):
_inherit = "sale.order.template.option"
website_description = fields.Html('Website Description',
translate=html_translate,
sanitize_attributes=False)
@api.onchange('product_id')
def _onchange_product_id(self):
ret = super(SaleOrderTemplateOption, self)._onchange_product_id()
if self.product_id:
self.website_description = self.product_id.quotation_description
return ret
class SaleOrderTemplate(models.Model):
_inherit = "sale.order.template"
website_description = fields.Html('Website Description',
translate=html_translate,
sanitize_attributes=False)
def open_template(self):
self.ensure_one()
return {
'type': 'ir.actions.act_url',
'target': 'self',
'url': '/sale_quotation_builder/template/%d' % self.id
}
class MixedModel(models.Model):
_name = 'test_new_api.mixed'
_description = 'Test New API Mixed'
number = fields.Float(digits=(10, 2), default=3.14)
number2 = fields.Float(digits='New API Precision')
date = fields.Date()
moment = fields.Datetime()
now = fields.Datetime(compute='_compute_now')
lang = fields.Selection(string='Language', selection='_get_lang')
reference = fields.Reference(string='Related Document',
selection='_reference_models')
comment1 = fields.Html(sanitize=False)
comment2 = fields.Html(sanitize_attributes=True, strip_classes=False)
comment3 = fields.Html(sanitize_attributes=True, strip_classes=True)
comment4 = fields.Html(sanitize_attributes=True, strip_style=True)
currency_id = fields.Many2one(
'res.currency', default=lambda self: self.env.ref('base.EUR'))
amount = fields.Monetary()
def _compute_now(self):
# this is a non-stored computed field without dependencies
for message in self:
message.now = fields.Datetime.now()
@api.model
def _get_lang(self):
return self.env['res.lang'].get_installed()
@api.model
def _reference_models(self):
models = self.env['ir.model'].sudo().search([('state', '!=', 'manual')
])
return [(model.model, model.name) for model in models
if not model.model.startswith('ir.')]
class DigestTip(models.Model):
_name = 'digest.tip'
_description = 'Digest Tips'
_order = 'sequence'
sequence = fields.Integer(
'Sequence',
default=1,
help='Used to display digest tip in email template base on order')
user_ids = fields.Many2many('res.users',
string='Recipients',
help='Users having already received this tip')
tip_description = fields.Html('Tip description', translate=html_translate)
group_id = fields.Many2one(
'res.groups',
string='Authorized Group',
default=lambda self: self.env.ref('base.group_user'))
class SaleOrderOption(models.Model):
_inherit = "sale.order.option"
website_description = fields.Html('Website Description', sanitize_attributes=False, translate=html_translate)
@api.onchange('product_id', 'uom_id')
def _onchange_product_id(self):
ret = super(SaleOrderOption, self)._onchange_product_id()
if self.product_id:
product = self.product_id.with_context(lang=self.order_id.partner_id.lang)
self.website_description = product.quotation_description
return ret
def _get_values_to_add_to_order(self):
values = super(SaleOrderOption, self)._get_values_to_add_to_order()
values.update(website_description=self.website_description)
return values
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
website_description = fields.Html('Website Description', sanitize=False, translate=html_translate)
@api.model
def create(self, values):
values = self._inject_quotation_description(values)
return super(SaleOrderLine, self).create(values)
def write(self, values):
values = self._inject_quotation_description(values)
return super(SaleOrderLine, self).write(values)
def _inject_quotation_description(self, values):
values = dict(values or {})
if not values.get('website_description') and values.get('product_id'):
product = self.env['product.product'].browse(values['product_id'])
values.update(website_description=product.quotation_description)
return values
class CrmLeadForwardToPartner(models.TransientModel):
""" Forward info history to partners. """
_name = 'crm.lead.forward.to.partner'
_description = 'Lead forward to partner'
@api.model
def _convert_to_assignation_line(self, lead, partner):
lead_location = []
partner_location = []
if lead.country_id:
lead_location.append(lead.country_id.name)
if lead.city:
lead_location.append(lead.city)
if partner:
if partner.country_id:
partner_location.append(partner.country_id.name)
if partner.city:
partner_location.append(partner.city)
return {
'lead_id': lead.id,
'lead_location': ", ".join(lead_location),
'partner_assigned_id': partner and partner.id or False,
'partner_location': ", ".join(partner_location),
'lead_link': self.get_lead_portal_url(lead.id, lead.type),
}
@api.model
def default_get(self, fields):
template = self.env.ref(
'website_crm_partner_assign.email_template_lead_forward_mail',
False)
res = super(CrmLeadForwardToPartner, self).default_get(fields)
active_ids = self.env.context.get('active_ids')
default_composition_mode = self.env.context.get(
'default_composition_mode')
res['assignation_lines'] = []
if template:
res['body'] = template.body_html
if active_ids:
leads = self.env['crm.lead'].browse(active_ids)
if default_composition_mode == 'mass_mail':
partner_assigned_dict = leads.search_geo_partner()
else:
partner_assigned_dict = {
lead.id: lead.partner_assigned_id.id
for lead in leads
}
res['partner_id'] = leads[0].partner_assigned_id.id
for lead in leads:
partner_id = partner_assigned_dict.get(lead.id) or False
partner = self.env['res.partner'].browse(partner_id)
res['assignation_lines'].append(
(0, 0, self._convert_to_assignation_line(lead, partner)))
return res
def action_forward(self):
self.ensure_one()
template = self.env.ref(
'website_crm_partner_assign.email_template_lead_forward_mail',
False)
if not template:
raise UserError(
_('The Forward Email Template is not in the database'))
portal_group = self.env.ref('base.group_portal')
local_context = self.env.context.copy()
if not (self.forward_type == 'single'):
no_email = set()
for lead in self.assignation_lines:
if lead.partner_assigned_id and not lead.partner_assigned_id.email:
no_email.add(lead.partner_assigned_id.name)
if no_email:
raise UserError(
_('Set an email address for the partner(s): %s') %
", ".join(no_email))
if self.forward_type == 'single' and not self.partner_id.email:
raise UserError(
_('Set an email address for the partner %s') %
self.partner_id.name)
partners_leads = {}
for lead in self.assignation_lines:
partner = self.forward_type == 'single' and self.partner_id or lead.partner_assigned_id
lead_details = {
'lead_link': lead.lead_link,
'lead_id': lead.lead_id,
}
if partner:
partner_leads = partners_leads.get(partner.id)
if partner_leads:
partner_leads['leads'].append(lead_details)
else:
partners_leads[partner.id] = {
'partner': partner,
'leads': [lead_details]
}
for partner_id, partner_leads in partners_leads.items():
in_portal = False
if portal_group:
for contact in (
partner.child_ids
or partner).filtered(lambda contact: contact.user_ids):
in_portal = portal_group.id in [
g.id for g in contact.user_ids[0].groups_id
]
local_context['partner_id'] = partner_leads['partner']
local_context['partner_leads'] = partner_leads['leads']
local_context['partner_in_portal'] = in_portal
template.with_context(local_context).send_mail(self.id)
leads = self.env['crm.lead']
for lead_data in partner_leads['leads']:
leads |= lead_data['lead_id']
values = {
'partner_assigned_id': partner_id,
'user_id': partner_leads['partner'].user_id.id
}
leads.with_context(mail_auto_subscribe_no_notify=1).write(values)
self.env['crm.lead'].message_subscribe([partner_id])
return True
def get_lead_portal_url(self, lead_id, type):
action = type == 'opportunity' and 'action_portal_opportunities' or 'action_portal_leads'
action_ref = self.env.ref('website_crm_partner_assign.%s' % (action, ),
False)
portal_link = "%s/?db=%s#id=%s&action=%s&view_type=form" % (
self.env['ir.config_parameter'].sudo().get_param('web.base.url'),
self.env.cr.dbname, lead_id, action_ref and action_ref.id or False)
return portal_link
def get_portal_url(self):
portal_link = "%s/?db=%s" % (self.env['ir.config_parameter'].sudo(
).get_param('web.base.url'), self.env.cr.dbname)
return portal_link
forward_type = fields.Selection([
('single', 'a single partner: manual selection of partner'),
('assigned',
"several partners: automatic assignation, using GPS coordinates and partner's grades"
)
],
'Forward selected leads to',
default=lambda self: self.env.context.get(
'forward_type') or 'single')
partner_id = fields.Many2one('res.partner', 'Forward Leads To')
assignation_lines = fields.One2many('crm.lead.assignation', 'forward_id',
'Partner Assignation')
body = fields.Html('Contents',
help='Automatically sanitized HTML contents')
class HrPlanActivityType(models.Model):
_name = 'hr.plan.activity.type'
_description = 'Plan activity type'
_rec_name = 'summary'
activity_type_id = fields.Many2one(
'mail.activity.type',
'Activity Type',
default=lambda self: self.env.ref('mail.mail_activity_data_todo'),
domain=lambda self: [
'|', ('res_model_id', '=', False),
('res_model_id', '=', self.env['ir.model']._get('hr.employee').id)
])
summary = fields.Char('Summary')
responsible = fields.Selection([('coach', 'Coach'), ('manager', 'Manager'),
('employee', 'Employee'),
('other', 'Other')],
default='employee',
string='Responsible',
required=True)
responsible_id = fields.Many2one(
'res.users',
'Responsible Person',
help='Specific responsible of activity if not linked to the employee.')
note = fields.Html('Note')
@api.onchange('activity_type_id')
def _onchange_activity_type_id(self):
if self.activity_type_id and self.activity_type_id.summary and not self.summary:
self.summary = self.activity_type_id.summary
def get_responsible_id(self, employee):
if self.responsible == 'coach':
if not employee.coach_id:
raise UserError(
_('Coach of employee %s is not set.') % employee.name)
responsible = employee.coach_id.user_id
if not responsible:
raise UserError(
_('User of coach of employee %s is not set.') %
employee.name)
elif self.responsible == 'manager':
if not employee.parent_id:
raise UserError(
_('Manager of employee %s is not set.') % employee.name)
responsible = employee.parent_id.user_id
if not responsible:
raise UserError(
_('User of manager of employee %s is not set.') %
employee.name)
elif self.responsible == 'employee':
responsible = employee.user_id
if not responsible:
raise UserError(
_('User linked to employee %s is required.') %
employee.name)
elif self.responsible == 'other':
responsible = self.responsible_id
if not responsible:
raise UserError(
_('No specific user given on activity.') % employee.name)
return responsible
class SurveyQuestion(models.Model):
""" Questions that will be asked in a survey.
Each question can have one of more suggested answers (eg. in case of
dropdown choices, multi-answer checkboxes, radio buttons...).
Technical note:
survey.question is also the model used for the survey's pages (with the "is_page" field set to True).
A page corresponds to a "section" in the interface, and the fact that it separates the survey in
actual pages in the interface depends on the "questions_layout" parameter on the survey.survey model.
Pages are also used when randomizing questions. The randomization can happen within a "page".
Using the same model for questions and pages allows to put all the pages and questions together in a o2m field
(see survey.survey.question_and_page_ids) on the view side and easily reorganize your survey by dragging the
items around.
It also removes on level of encoding by directly having 'Add a page' and 'Add a question'
links on the tree view of questions, enabling a faster encoding.
However, this has the downside of making the code reading a little bit more complicated.
Efforts were made at the model level to create computed fields so that the use of these models
still seems somewhat logical. That means:
- A survey still has "page_ids" (question_and_page_ids filtered on is_page = True)
- These "page_ids" still have question_ids (questions located between this page and the next)
- These "question_ids" still have a "page_id"
That makes the use and display of these information at view and controller levels easier to understand.
"""
_name = 'survey.question'
_description = 'Survey Question'
_rec_name = 'question'
_order = 'sequence,id'
@api.model
def default_get(self, fields):
defaults = super(SurveyQuestion, self).default_get(fields)
if (not fields or 'question_type' in fields):
defaults['question_type'] = False if defaults.get('is_page') == True else 'free_text'
return defaults
# Question metadata
survey_id = fields.Many2one('survey.survey', string='Survey', ondelete='cascade')
page_id = fields.Many2one('survey.question', string='Page', compute="_compute_page_id", store=True)
question_ids = fields.One2many('survey.question', string='Questions', compute="_compute_question_ids")
scoring_type = fields.Selection(related='survey_id.scoring_type', string='Scoring Type', readonly=True)
sequence = fields.Integer('Sequence', default=10)
# Question
is_page = fields.Boolean('Is a page?')
questions_selection = fields.Selection(
related='survey_id.questions_selection', readonly=True,
help="If randomized is selected, add the number of random questions next to the section.")
random_questions_count = fields.Integer(
'Random questions count', default=1,
help="Used on randomized sections to take X random questions from all the questions of that section.")
title = fields.Char('Title', required=True, translate=True)
question = fields.Char('Question', related="title")
description = fields.Html('Description', help="Use this field to add additional explanations about your question", translate=True)
question_type = fields.Selection([
('free_text', 'Multiple Lines Text Box'),
('textbox', 'Single Line Text Box'),
('numerical_box', 'Numerical Value'),
('date', 'Date'),
('datetime', 'Datetime'),
('simple_choice', 'Multiple choice: only one answer'),
('multiple_choice', 'Multiple choice: multiple answers allowed'),
('matrix', 'Matrix')], string='Question Type')
# simple choice / multiple choice / matrix
labels_ids = fields.One2many(
'survey.label', 'question_id', string='Types of answers', copy=True,
help='Labels used for proposed choices: simple choice, multiple choice and columns of matrix')
# matrix
matrix_subtype = fields.Selection([
('simple', 'One choice per row'),
('multiple', 'Multiple choices per row')], string='Matrix Type', default='simple')
labels_ids_2 = fields.One2many(
'survey.label', 'question_id_2', string='Rows of the Matrix', copy=True,
help='Labels used for proposed choices: rows of matrix')
# Display options
column_nb = fields.Selection([
('12', '1'), ('6', '2'), ('4', '3'), ('3', '4'), ('2', '6')],
string='Number of columns', default='12',
help='These options refer to col-xx-[12|6|4|3|2] classes in Bootstrap for dropdown-based simple and multiple choice questions.')
display_mode = fields.Selection(
[('columns', 'Radio Buttons'), ('dropdown', 'Selection Box')],
string='Display Mode', default='columns', help='Display mode of simple choice questions.')
# Comments
comments_allowed = fields.Boolean('Show Comments Field')
comments_message = fields.Char('Comment Message', translate=True, default=lambda self: _("If other, please specify:"))
comment_count_as_answer = fields.Boolean('Comment Field is an Answer Choice')
# Validation
validation_required = fields.Boolean('Validate entry')
validation_email = fields.Boolean('Input must be an email')
validation_length_min = fields.Integer('Minimum Text Length')
validation_length_max = fields.Integer('Maximum Text Length')
validation_min_float_value = fields.Float('Minimum value')
validation_max_float_value = fields.Float('Maximum value')
validation_min_date = fields.Date('Minimum Date')
validation_max_date = fields.Date('Maximum Date')
validation_min_datetime = fields.Datetime('Minimum Datetime')
validation_max_datetime = fields.Datetime('Maximum Datetime')
validation_error_msg = fields.Char('Validation Error message', translate=True, default=lambda self: _("The answer you entered is not valid."))
# Constraints on number of answers (matrices)
constr_mandatory = fields.Boolean('Mandatory Answer')
constr_error_msg = fields.Char('Error message', translate=True, default=lambda self: _("This question requires an answer."))
# Answer
user_input_line_ids = fields.One2many(
'survey.user_input_line', 'question_id', string='Answers',
domain=[('skipped', '=', False)], groups='survey.group_survey_user')
_sql_constraints = [
('positive_len_min', 'CHECK (validation_length_min >= 0)', 'A length must be positive!'),
('positive_len_max', 'CHECK (validation_length_max >= 0)', 'A length must be positive!'),
('validation_length', 'CHECK (validation_length_min <= validation_length_max)', 'Max length cannot be smaller than min length!'),
('validation_float', 'CHECK (validation_min_float_value <= validation_max_float_value)', 'Max value cannot be smaller than min value!'),
('validation_date', 'CHECK (validation_min_date <= validation_max_date)', 'Max date cannot be smaller than min date!'),
('validation_datetime', 'CHECK (validation_min_datetime <= validation_max_datetime)','Max datetime cannot be smaller than min datetime!')
]
@api.onchange('validation_email')
def _onchange_validation_email(self):
if self.validation_email:
self.validation_required = False
@api.onchange('is_page')
def _onchange_is_page(self):
if self.is_page:
self.question_type = False
# Validation methods
def validate_question(self, post, answer_tag):
""" Validate question, depending on question type and parameters """
self.ensure_one()
try:
checker = getattr(self, 'validate_' + self.question_type)
except AttributeError:
_logger.warning(self.question_type + ": This type of question has no validation method")
return {}
else:
return checker(post, answer_tag)
def validate_free_text(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_textbox(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Email format validation
# Note: this validation is very basic:
# all the strings of the form
# <something>@<anything>.<extension>
# will be accepted
if answer and self.validation_email:
if not email_validator.match(answer):
errors.update({answer_tag: _('This answer must be an email address')})
# Answer validation (if properly defined)
# Length of the answer must be in a range
if answer and self.validation_required:
if not (self.validation_length_min <= len(answer) <= self.validation_length_max):
errors.update({answer_tag: self.validation_error_msg})
return errors
def validate_numerical_box(self, post, answer_tag):
self.ensure_one()
errors = {}
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Checks if user input is a number
if answer:
try:
floatanswer = float(answer)
except ValueError:
errors.update({answer_tag: _('This is not a number')})
# Answer validation (if properly defined)
if answer and self.validation_required:
# Answer is not in the right range
with tools.ignore(Exception):
floatanswer = float(answer) # check that it is a float has been done hereunder
if not (self.validation_min_float_value <= floatanswer <= self.validation_max_float_value):
errors.update({answer_tag: self.validation_error_msg})
return errors
def date_validation(self, date_type, post, answer_tag, min_value, max_value):
self.ensure_one()
errors = {}
if date_type not in ('date', 'datetime'):
raise ValueError("Unexpected date type value")
answer = post[answer_tag].strip()
# Empty answer to mandatory question
if self.constr_mandatory and not answer:
errors.update({answer_tag: self.constr_error_msg})
# Checks if user input is a date
if answer:
try:
if date_type == 'datetime':
dateanswer = fields.Datetime.from_string(answer)
else:
dateanswer = fields.Date.from_string(answer)
except ValueError:
errors.update({answer_tag: _('This is not a date')})
return errors
# Answer validation (if properly defined)
if answer and self.validation_required:
# Answer is not in the right range
try:
if date_type == 'datetime':
date_from_string = fields.Datetime.from_string
else:
date_from_string = fields.Date.from_string
dateanswer = date_from_string(answer)
min_date = date_from_string(min_value)
max_date = date_from_string(max_value)
if min_date and max_date and not (min_date <= dateanswer <= max_date):
# If Minimum and Maximum Date are entered
errors.update({answer_tag: self.validation_error_msg})
elif min_date and not min_date <= dateanswer:
# If only Minimum Date is entered and not Define Maximum Date
errors.update({answer_tag: self.validation_error_msg})
elif max_date and not dateanswer <= max_date:
# If only Maximum Date is entered and not Define Minimum Date
errors.update({answer_tag: self.validation_error_msg})
except ValueError: # check that it is a date has been done hereunder
pass
return errors
def validate_date(self, post, answer_tag):
return self.date_validation('date', post, answer_tag, self.validation_min_date, self.validation_max_date)
def validate_datetime(self, post, answer_tag):
return self.date_validation('datetime', post, answer_tag, self.validation_min_datetime, self.validation_max_datetime)
def validate_simple_choice(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.comments_allowed:
comment_tag = "%s_%s" % (answer_tag, 'comment')
# Empty answer to mandatory self
if self.constr_mandatory and answer_tag not in post:
errors.update({answer_tag: self.constr_error_msg})
if self.constr_mandatory and answer_tag in post and not post[answer_tag].strip():
errors.update({answer_tag: self.constr_error_msg})
# Answer is a comment and is empty
if self.constr_mandatory and answer_tag in post and post[answer_tag] == "-1" and self.comment_count_as_answer and comment_tag in post and not post[comment_tag].strip():
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_multiple_choice(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.constr_mandatory:
answer_candidates = dict_keys_startswith(post, answer_tag)
comment_flag = answer_candidates.pop(("%s_%s" % (answer_tag, -1)), None)
if self.comments_allowed:
comment_answer = answer_candidates.pop(("%s_%s" % (answer_tag, 'comment')), '').strip()
# Preventing answers with blank value
if all(not answer.strip() for answer in answer_candidates.values()) and answer_candidates:
errors.update({answer_tag: self.constr_error_msg})
# There is no answer neither comments (if comments count as answer)
if not answer_candidates and self.comment_count_as_answer and (not comment_flag or not comment_answer):
errors.update({answer_tag: self.constr_error_msg})
# There is no answer at all
if not answer_candidates and not self.comment_count_as_answer:
errors.update({answer_tag: self.constr_error_msg})
return errors
def validate_matrix(self, post, answer_tag):
self.ensure_one()
errors = {}
if self.constr_mandatory:
lines_number = len(self.labels_ids_2)
answer_candidates = dict_keys_startswith(post, answer_tag)
answer_candidates.pop(("%s_%s" % (answer_tag, 'comment')), '').strip()
# Number of lines that have been answered
if self.matrix_subtype == 'simple':
answer_number = len(answer_candidates)
elif self.matrix_subtype == 'multiple':
answer_number = len({sk.rsplit('_', 1)[0] for sk in answer_candidates})
else:
raise RuntimeError("Invalid matrix subtype")
# Validate that each line has been answered
if answer_number != lines_number:
errors.update({answer_tag: self.constr_error_msg})
return errors
@api.depends('survey_id.question_and_page_ids.is_page', 'survey_id.question_and_page_ids.sequence')
def _compute_question_ids(self):
"""Will take all questions of the survey for which the index is higher than the index of this page
and lower than the index of the next page."""
for question in self:
if question.is_page:
next_page_index = False
for page in question.survey_id.page_ids:
if page._index() > question._index():
next_page_index = page._index()
break
question.question_ids = question.survey_id.question_ids.filtered(lambda q:
q._index() > question._index() and (not next_page_index or q._index() < next_page_index))
else:
question.question_ids = self.env['survey.question']
@api.depends('survey_id.question_and_page_ids.is_page', 'survey_id.question_and_page_ids.sequence')
def _compute_page_id(self):
"""Will find the page to which this question belongs to by looking inside the corresponding survey"""
for question in self:
if question.is_page:
question.page_id = None
else:
question.page_id = next(
(iter(question
.survey_id
.question_and_page_ids
.filtered(lambda q: q.is_page and q.sequence < question.sequence)
.sorted(reverse=True))),
None
)
def _index(self):
"""We would normally just use the 'sequence' field of questions BUT, if the pages and questions are
created without ever moving records around, the sequence field can be set to 0 for all the questions.
However, the order of the recordset is always correct so we can rely on the index method."""
self.ensure_one()
return list(self.survey_id.question_and_page_ids).index(self)
def get_correct_answer_ids(self):
self.ensure_one()
return self.labels_ids.filtered(lambda label: label.is_correct)
class Blog(models.Model):
_name = 'blog.blog'
_description = 'Blogs'
_inherit = ['mail.thread', 'website.seo.metadata', 'website.multi.mixin']
_order = 'name'
name = fields.Char('Blog Name', required=True, translate=True)
subtitle = fields.Char('Blog Subtitle', translate=True)
active = fields.Boolean('Active', default=True)
content = fields.Html('Content', translate=html_translate, sanitize=False)
cover_properties = fields.Text(
'Cover Properties',
default=
'{"background-image": "none", "background-color": "oe_black", "opacity": "0.2", "resize_class": "cover_mid"}'
)
def write(self, vals):
res = super(Blog, self).write(vals)
if 'active' in vals:
# archiving/unarchiving a blog does it on its posts, too
post_ids = self.env['blog.post'].with_context(
active_test=False).search([('blog_id', 'in', self.ids)])
for blog_post in post_ids:
blog_post.active = vals['active']
return res
@api.returns('mail.message', lambda value: value.id)
def message_post(self, *, parent_id=False, subtype=None, **kwargs):
""" Temporary workaround to avoid spam. If someone replies on a channel
through the 'Presentation Published' email, it should be considered as a
note as we don't want all channel followers to be notified of this answer. """
self.ensure_one()
if parent_id:
parent_message = self.env['mail.message'].sudo().browse(parent_id)
if parent_message.subtype_id and parent_message.subtype_id == self.env.ref(
'website_blog.mt_blog_blog_published'):
if kwargs.get('subtype_id'):
kwargs['subtype_id'] = False
subtype = 'mail.mt_note'
return super(Blog, self).message_post(parent_id=parent_id,
subtype=subtype,
**kwargs)
def all_tags(self, join=False, min_limit=1):
BlogTag = self.env['blog.tag']
req = """
SELECT
p.blog_id, count(*), r.blog_tag_id
FROM
blog_post_blog_tag_rel r
join blog_post p on r.blog_post_id=p.id
WHERE
p.blog_id in %s
GROUP BY
p.blog_id,
r.blog_tag_id
ORDER BY
count(*) DESC
"""
self._cr.execute(req, [tuple(self.ids)])
tag_by_blog = {i.id: [] for i in self}
all_tags = set()
for blog_id, freq, tag_id in self._cr.fetchall():
if freq >= min_limit:
if join:
all_tags.add(tag_id)
else:
tag_by_blog[blog_id].append(tag_id)
if join:
return BlogTag.browse(all_tags)
for blog_id in tag_by_blog:
tag_by_blog[blog_id] = BlogTag.browse(tag_by_blog[blog_id])
return tag_by_blog
class LunchAlert(models.Model):
""" Alerts to display during a lunch order. An alert can be specific to a
given day, weekly or daily. The alert is displayed from start to end hour. """
_name = 'lunch.alert'
_description = 'Lunch Alert'
_order = 'write_date desc, id'
name = fields.Char('Alert Name', required=True)
message = fields.Html('Message', required=True)
mode = fields.Selection([('alert', 'Alert in app'),
('chat', 'Chat notification')],
string='Display',
default='alert')
recipients = fields.Selection(
[('everyone', 'Everyone'),
('last_week', 'Employee who ordered last week'),
('last_month', 'Employee who ordered last month'),
('last_year', 'Employee who ordered last year')],
string='Recipients',
default='everyone')
notification_time = fields.Float(default=10.0, string='Notification Time')
notification_moment = fields.Selection([('am', 'AM'), ('pm', 'PM')],
default='am',
required=True)
tz = fields.Selection(_tz_get,
string='Timezone',
required=True,
default=lambda self: self.env.user.tz or 'UTC')
until = fields.Date('Show Until')
recurrency_monday = fields.Boolean('Monday', default=True)
recurrency_tuesday = fields.Boolean('Tuesday', default=True)
recurrency_wednesday = fields.Boolean('Wednesday', default=True)
recurrency_thursday = fields.Boolean('Thursday', default=True)
recurrency_friday = fields.Boolean('Friday', default=True)
recurrency_saturday = fields.Boolean('Saturday', default=True)
recurrency_sunday = fields.Boolean('Sunday', default=True)
available_today = fields.Boolean('Is Displayed Today',
compute='_compute_available_today',
search='_search_available_today')
active = fields.Boolean('Active', default=True)
location_ids = fields.Many2many('lunch.location', string='Location')
_sql_constraints = [
('notification_time_range',
'CHECK(notification_time >= 0 and notification_time <= 12)',
'Notification time must be between 0 and 12')
]
@api.depends('recurrency_monday', 'recurrency_tuesday',
'recurrency_wednesday', 'recurrency_thursday',
'recurrency_friday', 'recurrency_saturday',
'recurrency_sunday')
def _compute_available_today(self):
today = fields.Date.context_today(self)
fieldname = 'recurrency_%s' % (WEEKDAY_TO_NAME[today.weekday()])
for alert in self:
alert.available_today = alert.until > today if alert.until else True and alert[
fieldname]
def _search_available_today(self, operator, value):
if (not operator in ['=', '!=']) or (not value in [True, False]):
return []
searching_for_true = (operator == '=' and value) or (operator == '!='
and not value)
today = fields.Date.context_today(self)
fieldname = 'recurrency_%s' % (WEEKDAY_TO_NAME[today.weekday()])
return expression.AND([[(fieldname, operator, value)],
expression.OR([
[('until', '=', False)],
[('until',
'>' if searching_for_true else '<', today)
],
])])
def _notify_chat(self):
records = self.search([('mode', '=', 'chat'), ('active', '=', True)])
today = fields.Date.today()
now = fields.Datetime.now()
for alert in records:
notification_to = now.astimezone(pytz.timezone(alert.tz)).replace(
second=0, microsecond=0, tzinfo=None)
notification_from = notification_to - timedelta(minutes=5)
send_at = datetime.combine(
fields.Date.today(),
float_to_time(alert.notification_time,
alert.notification_moment))
if alert.available_today and send_at > notification_from and send_at <= notification_to:
order_domain = [('state', '!=', 'cancelled')]
if alert.location_ids.ids:
order_domain = expression.AND([
order_domain,
[('user_id.last_lunch_location_id', 'in',
alert.location_ids.ids)]
])
if alert.recipients != 'everyone':
weeks = 1
if alert.recipients == 'last_month':
weeks = 4
else: # last_year
weeks = 52
delta = timedelta(weeks=weeks)
order_domain = expression.AND(
[order_domain, [('date', '>=', today - delta)]])
orders = self.env['lunch.order'].search(order_domain).mapped(
'user_id')
partner_ids = [user.partner_id.id for user in orders]
if partner_ids:
self.env['mail.thread'].message_notify(
body=alert.message, partner_ids=partner_ids)
class ServerActions(models.Model):
""" Add email option in server actions. """
_name = 'ir.actions.server'
_description = 'Server Action'
_inherit = ['ir.actions.server']
state = fields.Selection(selection_add=[
('email', 'Send Email'),
('followers', 'Add Followers'),
('next_activity', 'Create Next Activity'),
])
# Followers
partner_ids = fields.Many2many('res.partner', string='Add Followers')
channel_ids = fields.Many2many('mail.channel', string='Add Channels')
# Template
template_id = fields.Many2one(
'mail.template', 'Email Template', ondelete='set null',
domain="[('model_id', '=', model_id)]",
)
# Next Activity
activity_type_id = fields.Many2one(
'mail.activity.type', string='Activity',
domain="['|', ('res_model_id', '=', False), ('res_model_id', '=', model_id)]")
activity_summary = fields.Char('Summary')
activity_note = fields.Html('Note')
activity_date_deadline_range = fields.Integer(string='Due Date In')
activity_date_deadline_range_type = fields.Selection([
('days', 'Days'),
('weeks', 'Weeks'),
('months', 'Months'),
], string='Due type', default='days')
activity_user_type = fields.Selection([
('specific', 'Specific User'),
('generic', 'Generic User From Record')], default="specific", required=True,
help="Use 'Specific User' to always assign the same user on the next activity. Use 'Generic User From Record' to specify the field name of the user to choose on the record.")
activity_user_id = fields.Many2one('res.users', string='Responsible')
activity_user_field_name = fields.Char('User field name', help="Technical name of the user on the record", default="user_id")
@api.onchange('activity_date_deadline_range')
def _onchange_activity_date_deadline_range(self):
if self.activity_date_deadline_range < 0:
raise UserError(_("The 'Due Date In' value can't be negative."))
@api.onchange('template_id')
def on_change_template_id(self):
""" Render the raw template in the server action fields. """
if self.template_id and not self.template_id.email_from:
raise UserError(_('Your template should define email_from'))
@api.constrains('state', 'model_id')
def _check_mail_thread(self):
for action in self:
if action.state == 'followers' and not action.model_id.is_mail_thread:
raise ValidationError(_("Add Followers can only be done on a mail thread model"))
@api.constrains('state', 'model_id')
def _check_activity_mixin(self):
for action in self:
if action.state == 'next_activity' and not action.model_id.is_mail_thread:
raise ValidationError(_("A next activity can only be planned on models that use the chatter"))
@api.model
def run_action_followers_multi(self, action, eval_context=None):
Model = self.env[action.model_name]
if self.partner_ids or self.channel_ids and hasattr(Model, 'message_subscribe'):
records = Model.browse(self._context.get('active_ids', self._context.get('active_id')))
records.message_subscribe(self.partner_ids.ids, self.channel_ids.ids)
return False
@api.model
def _is_recompute(self, action):
"""When an activity is set on update of a record,
update might be triggered many times by recomputes.
When need to know it to skip these steps.
Except if the computed field is supposed to trigger the action
"""
records = self.env[action.model_name].browse(
self._context.get('active_ids', self._context.get('active_id')))
old_values = action._context.get('old_values')
if old_values:
domain_post = action._context.get('domain_post')
tracked_fields = []
if domain_post:
for leaf in domain_post:
if isinstance(leaf, (tuple, list)):
tracked_fields.append(leaf[0])
fields_to_check = [field for record, field_names in old_values.items() for field in field_names if field not in tracked_fields]
if fields_to_check:
field = records._fields[fields_to_check[0]]
# Pick an arbitrary field; if it is marked to be recomputed,
# it means we are in an extraneous write triggered by the recompute.
# In this case, we should not create a new activity.
if records & self.env.records_to_compute(field):
return True
return False
@api.model
def run_action_email(self, action, eval_context=None):
# TDE CLEANME: when going to new api with server action, remove action
if not action.template_id or not self._context.get('active_id') or self._is_recompute(action):
return False
# Clean context from default_type to avoid making attachment
# with wrong values in subsequent operations
cleaned_ctx = dict(self.env.context)
cleaned_ctx.pop('default_type', None)
cleaned_ctx.pop('default_parent_id', None)
action.template_id.with_context(cleaned_ctx).send_mail(self._context.get('active_id'), force_send=False, raise_exception=False)
return False
@api.model
def run_action_next_activity(self, action, eval_context=None):
if not action.activity_type_id or not self._context.get('active_id') or self._is_recompute(action):
return False
records = self.env[action.model_name].browse(self._context.get('active_ids', self._context.get('active_id')))
vals = {
'summary': action.activity_summary or '',
'note': action.activity_note or '',
'activity_type_id': action.activity_type_id.id,
}
if action.activity_date_deadline_range > 0:
vals['date_deadline'] = fields.Date.context_today(action) + relativedelta(**{action.activity_date_deadline_range_type: action.activity_date_deadline_range})
for record in records:
if action.activity_user_type == 'specific':
user = action.activity_user_id
elif action.activity_user_type == 'generic' and action.activity_user_field_name in record:
user = record[action.activity_user_field_name]
if user:
vals['user_id'] = user.id
record.activity_schedule(**vals)
return False
@api.model
def _get_eval_context(self, action=None):
""" Override the method giving the evaluation context but also the
context used in all subsequent calls. Add the mail_notify_force_send
key set to False in the context. This way all notification emails linked
to the currently executed action will be set in the queue instead of
sent directly. This will avoid possible break in transactions. """
eval_context = super(ServerActions, self)._get_eval_context(action=action)
ctx = dict(eval_context['env'].context)
ctx['mail_notify_force_send'] = False
eval_context['env'].context = ctx
return eval_context
class MailComposer(models.TransientModel):
""" Generic message composition wizard. You may inherit from this wizard
at model and view levels to provide specific features.
The behavior of the wizard depends on the composition_mode field:
- 'comment': post on a record. The wizard is pre-populated via ``get_record_data``
- 'mass_mail': wizard in mass mailing mode where the mail details can
contain template placeholders that will be merged with actual data
before being sent to each recipient.
"""
_name = 'mail.compose.message'
_description = 'Email composition wizard'
_log_access = True
_batch_size = 500
@api.model
def default_get(self, fields):
""" Handle composition mode. Some details about context keys:
- comment: default mode, model and ID of a record the user comments
- default_model or active_model
- default_res_id or active_id
- reply: active_id of a message the user replies to
- default_parent_id or message_id or active_id: ID of the
mail.message we reply to
- message.res_model or default_model
- message.res_id or default_res_id
- mass_mail: model and IDs of records the user mass-mails
- active_ids: record IDs
- default_model or active_model
"""
result = super(MailComposer, self).default_get(fields)
# author
if 'author_id' not in result:
result['author_id'] = self.env.user.partner_id.id
if 'email_from' not in result and self.env.user.email:
result['email_from'] = self.env.user.email_formatted
elif 'email_from' not in result:
author = self.env['res.partner'].browse(result['author_id'])
if author.email:
result['email_from'] = tools.formataddr((author.name, author.email))
# v6.1 compatibility mode
result['composition_mode'] = result.get('composition_mode', self._context.get('mail.compose.message.mode', 'comment'))
result['model'] = result.get('model', self._context.get('active_model'))
result['res_id'] = result.get('res_id', self._context.get('active_id'))
result['parent_id'] = result.get('parent_id', self._context.get('message_id'))
if 'no_auto_thread' not in result and (result['model'] not in self.env or not hasattr(self.env[result['model']], 'message_post')):
result['no_auto_thread'] = True
# default values according to composition mode - NOTE: reply is deprecated, fall back on comment
if result['composition_mode'] == 'reply':
result['composition_mode'] = 'comment'
vals = {}
if 'active_domain' in self._context: # not context.get() because we want to keep global [] domains
vals['active_domain'] = '%s' % self._context.get('active_domain')
if result['composition_mode'] == 'comment':
vals.update(self.get_record_data(result))
for field in vals:
if field in fields:
result[field] = vals[field]
# TDE HACK: as mailboxes used default_model='res.users' and default_res_id=uid
# (because of lack of an accessible pid), creating a message on its own
# profile may crash (res_users does not allow writing on it)
# Posting on its own profile works (res_users redirect to res_partner)
# but when creating the mail.message to create the mail.compose.message
# access rights issues may rise
# We therefore directly change the model and res_id
if result['model'] == 'res.users' and result['res_id'] == self._uid:
result['model'] = 'res.partner'
result['res_id'] = self.env.user.partner_id.id
if fields is not None:
[result.pop(field, None) for field in list(result) if field not in fields]
return result
@api.model
def _get_composition_mode_selection(self):
return [('comment', 'Post on a document'),
('mass_mail', 'Email Mass Mailing'),
('mass_post', 'Post on Multiple Documents')]
# content
subject = fields.Char('Subject')
body = fields.Html('Contents', default='', sanitize_style=True)
parent_id = fields.Many2one(
'mail.message', 'Parent Message', index=True, ondelete='set null',
help="Initial thread message.")
attachment_ids = fields.Many2many(
'ir.attachment', 'mail_compose_message_ir_attachments_rel',
'wizard_id', 'attachment_id', 'Attachments')
# origin
email_from = fields.Char('From', help="Email address of the sender. This field is set when no matching partner is found and replaces the author_id field in the chatter.")
author_id = fields.Many2one(
'res.partner', 'Author', index=True,
help="Author of the message. If not set, email_from may hold an email address that did not match any partner.")
# related document
model = fields.Char('Related Document Model', index=True)
res_id = fields.Integer('Related Document ID', index=True)
record_name = fields.Char('Message Record Name', help="Name get of the related document.")
# characteristics
message_type = fields.Selection([
('comment', 'Comment'),
('notification', 'System notification')],
'Type', required=True, default='comment',
help="Message type: email for email message, notification for system "
"message, comment for other messages such as user replies")
subtype_id = fields.Many2one(
'mail.message.subtype', 'Subtype', ondelete='set null', index=True,
default=lambda self: self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment'))
mail_activity_type_id = fields.Many2one(
'mail.activity.type', 'Mail Activity Type',
index=True, ondelete='set null')
# destination
composition_mode = fields.Selection(selection=_get_composition_mode_selection, string='Composition mode', default='comment')
reply_to = fields.Char('Reply-To', help='Reply email address. Setting the reply_to bypasses the automatic thread creation.')
no_auto_thread = fields.Boolean(
'No threading for answers',
help='Answers do not go in the original document discussion thread. This has an impact on the generated message-id.')
is_log = fields.Boolean('Log an Internal Note',
help='Whether the message is an internal note (comment mode only)')
partner_ids = fields.Many2many(
'res.partner', 'mail_compose_message_res_partner_rel',
'wizard_id', 'partner_id', 'Additional Contacts')
use_active_domain = fields.Boolean('Use active domain')
active_domain = fields.Text('Active domain', readonly=True)
# mass mode options
notify = fields.Boolean('Notify followers', help='Notify followers of the document (mass post only)')
auto_delete = fields.Boolean('Delete Emails', help='Delete sent emails (mass mailing only)')
auto_delete_message = fields.Boolean('Delete Message Copy', help='Do not keep a copy of the email in the document communication history (mass mailing only)')
template_id = fields.Many2one(
'mail.template', 'Use template', index=True,
domain="[('model', '=', model)]")
# technical stuff
mail_server_id = fields.Many2one('ir.mail_server', 'Outgoing mail server')
layout = fields.Char('Layout', copy=False) # xml id of layout
add_sign = fields.Boolean(default=True)
@api.model
def get_record_data(self, values):
""" Returns a defaults-like dict with initial values for the composition
wizard when sending an email related a previous email (parent_id) or
a document (model, res_id). This is based on previously computed default
values. """
result, subject = {}, False
if values.get('parent_id'):
parent = self.env['mail.message'].browse(values.get('parent_id'))
result['record_name'] = parent.record_name,
subject = tools.ustr(parent.subject or parent.record_name or '')
if not values.get('model'):
result['model'] = parent.model
if not values.get('res_id'):
result['res_id'] = parent.res_id
partner_ids = values.get('partner_ids', list()) + parent.partner_ids.ids
result['partner_ids'] = partner_ids
elif values.get('model') and values.get('res_id'):
doc_name_get = self.env[values.get('model')].browse(values.get('res_id')).name_get()
result['record_name'] = doc_name_get and doc_name_get[0][1] or ''
subject = tools.ustr(result['record_name'])
re_prefix = _('Re:')
if subject and not (subject.startswith('Re:') or subject.startswith(re_prefix)):
subject = "%s %s" % (re_prefix, subject)
result['subject'] = subject
return result
#------------------------------------------------------
# Wizard validation and send
#------------------------------------------------------
# action buttons call with positionnal arguments only, so we need an intermediary function
# to ensure the context is passed correctly
def action_send_mail(self):
self.send_mail()
return {'type': 'ir.actions.act_window_close', 'infos': 'mail_sent'}
def send_mail(self, auto_commit=False):
""" Process the wizard content and proceed with sending the related
email(s), rendering any template patterns on the fly if needed. """
notif_layout = self._context.get('custom_layout')
# Several custom layouts make use of the model description at rendering, e.g. in the
# 'View <document>' button. Some models are used for different business concepts, such as
# 'purchase.order' which is used for a RFQ and and PO. To avoid confusion, we must use a
# different wording depending on the state of the object.
# Therefore, we can set the description in the context from the beginning to avoid falling
# back on the regular display_name retrieved in '_notify_prepare_template_context'.
model_description = self._context.get('model_description')
for wizard in self:
# Duplicate attachments linked to the email.template.
# Indeed, basic mail.compose.message wizard duplicates attachments in mass
# mailing mode. But in 'single post' mode, attachments of an email template
# also have to be duplicated to avoid changing their ownership.
if wizard.attachment_ids and wizard.composition_mode != 'mass_mail' and wizard.template_id:
new_attachment_ids = []
for attachment in wizard.attachment_ids:
if attachment in wizard.template_id.attachment_ids:
new_attachment_ids.append(attachment.copy({'res_model': 'mail.compose.message', 'res_id': wizard.id}).id)
else:
new_attachment_ids.append(attachment.id)
new_attachment_ids.reverse()
wizard.write({'attachment_ids': [(6, 0, new_attachment_ids)]})
# Mass Mailing
mass_mode = wizard.composition_mode in ('mass_mail', 'mass_post')
Mail = self.env['mail.mail']
ActiveModel = self.env[wizard.model] if wizard.model and hasattr(self.env[wizard.model], 'message_post') else self.env['mail.thread']
if wizard.composition_mode == 'mass_post':
# do not send emails directly but use the queue instead
# add context key to avoid subscribing the author
ActiveModel = ActiveModel.with_context(mail_notify_force_send=False, mail_create_nosubscribe=True)
# wizard works in batch mode: [res_id] or active_ids or active_domain
if mass_mode and wizard.use_active_domain and wizard.model:
res_ids = self.env[wizard.model].search(safe_eval(wizard.active_domain)).ids
elif mass_mode and wizard.model and self._context.get('active_ids'):
res_ids = self._context['active_ids']
else:
res_ids = [wizard.res_id]
batch_size = int(self.env['ir.config_parameter'].sudo().get_param('mail.batch_size')) or self._batch_size
sliced_res_ids = [res_ids[i:i + batch_size] for i in range(0, len(res_ids), batch_size)]
if wizard.composition_mode == 'mass_mail' or wizard.is_log or (wizard.composition_mode == 'mass_post' and not wizard.notify): # log a note: subtype is False
subtype_id = False
elif wizard.subtype_id:
subtype_id = wizard.subtype_id.id
else:
subtype_id = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment')
for res_ids in sliced_res_ids:
batch_mails = Mail
all_mail_values = wizard.get_mail_values(res_ids)
for res_id, mail_values in all_mail_values.items():
if wizard.composition_mode == 'mass_mail':
batch_mails |= Mail.create(mail_values)
else:
post_params = dict(
message_type=wizard.message_type,
subtype_id=subtype_id,
email_layout_xmlid=notif_layout,
add_sign=not bool(wizard.template_id),
mail_auto_delete=wizard.template_id.auto_delete if wizard.template_id else False,
model_description=model_description)
post_params.update(mail_values)
if ActiveModel._name == 'mail.thread':
if wizard.model:
post_params['model'] = wizard.model
post_params['res_id'] = res_id
if not ActiveModel.message_notify(**post_params):
# if message_notify returns an empty record set, no recipients where found.
raise UserError(_("No recipient found."))
else:
ActiveModel.browse(res_id).message_post(**post_params)
if wizard.composition_mode == 'mass_mail':
batch_mails.send(auto_commit=auto_commit)
def get_mail_values(self, res_ids):
"""Generate the values that will be used by send_mail to create mail_messages
or mail_mails. """
self.ensure_one()
results = dict.fromkeys(res_ids, False)
rendered_values = {}
mass_mail_mode = self.composition_mode == 'mass_mail'
# render all template-based value at once
if mass_mail_mode and self.model:
rendered_values = self.render_message(res_ids)
# compute alias-based reply-to in batch
reply_to_value = dict.fromkeys(res_ids, None)
if mass_mail_mode and not self.no_auto_thread:
records = self.env[self.model].browse(res_ids)
reply_to_value = self.env['mail.thread']._notify_get_reply_to_on_records(default=self.email_from, records=records)
blacklisted_rec_ids = []
if mass_mail_mode and issubclass(type(self.env[self.model]), self.pool['mail.thread.blacklist']):
BL_sudo = self.env['mail.blacklist'].sudo()
blacklist = set(BL_sudo.search([]).mapped('email'))
if blacklist:
targets = self.env[self.model].browse(res_ids).read(['email_normalized'])
# First extract email from recipient before comparing with blacklist
blacklisted_rec_ids.extend([target['id'] for target in targets
if target['email_normalized'] and target['email_normalized'] in blacklist])
for res_id in res_ids:
# static wizard (mail.message) values
mail_values = {
'subject': self.subject,
'body': self.body or '',
'parent_id': self.parent_id and self.parent_id.id,
'partner_ids': [partner.id for partner in self.partner_ids],
'attachment_ids': [attach.id for attach in self.attachment_ids],
'author_id': self.author_id.id,
'email_from': self.email_from,
'record_name': self.record_name,
'no_auto_thread': self.no_auto_thread,
'mail_server_id': self.mail_server_id.id,
'mail_activity_type_id': self.mail_activity_type_id.id,
}
# mass mailing: rendering override wizard static values
if mass_mail_mode and self.model:
record = self.env[self.model].browse(res_id)
mail_values['headers'] = record._notify_email_headers()
# keep a copy unless specifically requested, reset record name (avoid browsing records)
mail_values.update(notification=not self.auto_delete_message, model=self.model, res_id=res_id, record_name=False)
# auto deletion of mail_mail
if self.auto_delete or self.template_id.auto_delete:
mail_values['auto_delete'] = True
# rendered values using template
email_dict = rendered_values[res_id]
mail_values['partner_ids'] += email_dict.pop('partner_ids', [])
mail_values.update(email_dict)
if not self.no_auto_thread:
mail_values.pop('reply_to')
if reply_to_value.get(res_id):
mail_values['reply_to'] = reply_to_value[res_id]
if self.no_auto_thread and not mail_values.get('reply_to'):
mail_values['reply_to'] = mail_values['email_from']
# mail_mail values: body -> body_html, partner_ids -> recipient_ids
mail_values['body_html'] = mail_values.get('body', '')
mail_values['recipient_ids'] = [(4, id) for id in mail_values.pop('partner_ids', [])]
# process attachments: should not be encoded before being processed by message_post / mail_mail create
mail_values['attachments'] = [(name, base64.b64decode(enc_cont)) for name, enc_cont in email_dict.pop('attachments', list())]
attachment_ids = []
for attach_id in mail_values.pop('attachment_ids'):
new_attach_id = self.env['ir.attachment'].browse(attach_id).copy({'res_model': self._name, 'res_id': self.id})
attachment_ids.append(new_attach_id.id)
attachment_ids.reverse()
mail_values['attachment_ids'] = self.env['mail.thread']._message_post_process_attachments(
mail_values.pop('attachments', []),
attachment_ids,
{'model': 'mail.message', 'res_id': 0}
)['attachment_ids']
# Filter out the blacklisted records by setting the mail state to cancel -> Used for Mass Mailing stats
if res_id in blacklisted_rec_ids:
mail_values['state'] = 'cancel'
# Do not post the mail into the recipient's chatter
mail_values['notification'] = False
results[res_id] = mail_values
return results
#------------------------------------------------------
# Template methods
#------------------------------------------------------
@api.onchange('template_id')
def onchange_template_id_wrapper(self):
self.ensure_one()
values = self.onchange_template_id(self.template_id.id, self.composition_mode, self.model, self.res_id)['value']
for fname, value in values.items():
setattr(self, fname, value)
def onchange_template_id(self, template_id, composition_mode, model, res_id):
""" - mass_mailing: we cannot render, so return the template values
- normal mode: return rendered values
/!\ for x2many field, this onchange return command instead of ids
"""
if template_id and composition_mode == 'mass_mail':
template = self.env['mail.template'].browse(template_id)
fields = ['subject', 'body_html', 'email_from', 'reply_to', 'mail_server_id']
values = dict((field, getattr(template, field)) for field in fields if getattr(template, field))
if template.attachment_ids:
values['attachment_ids'] = [att.id for att in template.attachment_ids]
if template.mail_server_id:
values['mail_server_id'] = template.mail_server_id.id
if template.user_signature and 'body_html' in values:
signature = self.env.user.signature
values['body_html'] = tools.append_content_to_html(values['body_html'], signature, plaintext=False)
elif template_id:
values = self.generate_email_for_composer(template_id, [res_id])[res_id]
# transform attachments into attachment_ids; not attached to the document because this will
# be done further in the posting process, allowing to clean database if email not send
attachment_ids = []
Attachment = self.env['ir.attachment']
for attach_fname, attach_datas in values.pop('attachments', []):
data_attach = {
'name': attach_fname,
'datas': attach_datas,
'res_model': 'mail.compose.message',
'res_id': 0,
'type': 'binary', # override default_type from context, possibly meant for another model!
}
attachment_ids.append(Attachment.create(data_attach).id)
if values.get('attachment_ids', []) or attachment_ids:
values['attachment_ids'] = [(6, 0, values.get('attachment_ids', []) + attachment_ids)]
else:
default_values = self.with_context(default_composition_mode=composition_mode, default_model=model, default_res_id=res_id).default_get(['composition_mode', 'model', 'res_id', 'parent_id', 'partner_ids', 'subject', 'body', 'email_from', 'reply_to', 'attachment_ids', 'mail_server_id'])
values = dict((key, default_values[key]) for key in ['subject', 'body', 'partner_ids', 'email_from', 'reply_to', 'attachment_ids', 'mail_server_id'] if key in default_values)
if values.get('body_html'):
values['body'] = values.pop('body_html')
# This onchange should return command instead of ids for x2many field.
values = self._convert_to_write(values)
return {'value': values}
def save_as_template(self):
""" hit save as template button: current form value will be a new
template attached to the current document. """
for record in self:
model = self.env['ir.model']._get(record.model or 'mail.message')
model_name = model.name or ''
template_name = "%s: %s" % (model_name, tools.ustr(record.subject))
values = {
'name': template_name,
'subject': record.subject or False,
'body_html': record.body or False,
'model_id': model.id or False,
'attachment_ids': [(6, 0, [att.id for att in record.attachment_ids])],
}
template = self.env['mail.template'].create(values)
# generate the saved template
record.write({'template_id': template.id})
record.onchange_template_id_wrapper()
return _reopen(self, record.id, record.model, context=self._context)
#------------------------------------------------------
# Template rendering
#------------------------------------------------------
def render_message(self, res_ids):
"""Generate template-based values of wizard, for the document records given
by res_ids. This method is meant to be inherited by email_template that
will produce a more complete dictionary, using Jinja2 templates.
Each template is generated for all res_ids, allowing to parse the template
once, and render it multiple times. This is useful for mass mailing where
template rendering represent a significant part of the process.
Default recipients are also computed, based on mail_thread method
_message_get_default_recipients. This allows to ensure a mass mailing has
always some recipients specified.
:param browse wizard: current mail.compose.message browse record
:param list res_ids: list of record ids
:return dict results: for each res_id, the generated template values for
subject, body, email_from and reply_to
"""
self.ensure_one()
multi_mode = True
if isinstance(res_ids, int):
multi_mode = False
res_ids = [res_ids]
subjects = self.env['mail.template']._render_template(self.subject, self.model, res_ids)
bodies = self.env['mail.template']._render_template(self.body, self.model, res_ids, post_process=True)
emails_from = self.env['mail.template']._render_template(self.email_from, self.model, res_ids)
replies_to = self.env['mail.template']._render_template(self.reply_to, self.model, res_ids)
default_recipients = {}
if not self.partner_ids:
records = self.env[self.model].browse(res_ids).sudo()
default_recipients = self.env['mail.thread']._message_get_default_recipients_on_records(records)
results = dict.fromkeys(res_ids, False)
for res_id in res_ids:
results[res_id] = {
'subject': subjects[res_id],
'body': bodies[res_id],
'email_from': emails_from[res_id],
'reply_to': replies_to[res_id],
}
results[res_id].update(default_recipients.get(res_id, dict()))
# generate template-based values
if self.template_id:
template_values = self.generate_email_for_composer(
self.template_id.id, res_ids,
fields=['email_to', 'partner_to', 'email_cc', 'attachment_ids', 'mail_server_id'])
else:
template_values = {}
for res_id in res_ids:
if template_values.get(res_id):
# recipients are managed by the template
results[res_id].pop('partner_ids', None)
results[res_id].pop('email_to', None)
results[res_id].pop('email_cc', None)
# remove attachments from template values as they should not be rendered
template_values[res_id].pop('attachment_ids', None)
else:
template_values[res_id] = dict()
# update template values by composer values
template_values[res_id].update(results[res_id])
return multi_mode and template_values or template_values[res_ids[0]]
@api.model
def generate_email_for_composer(self, template_id, res_ids, fields=None):
""" Call email_template.generate_email(), get fields relevant for
mail.compose.message, transform email_cc and email_to into partner_ids """
multi_mode = True
if isinstance(res_ids, int):
multi_mode = False
res_ids = [res_ids]
if fields is None:
fields = ['subject', 'body_html', 'email_from', 'email_to', 'partner_to', 'email_cc', 'reply_to', 'attachment_ids', 'mail_server_id']
returned_fields = fields + ['partner_ids', 'attachments']
values = dict.fromkeys(res_ids, False)
template_values = self.env['mail.template'].with_context(tpl_partners_only=True).browse(template_id).generate_email(res_ids, fields=fields)
for res_id in res_ids:
res_id_values = dict((field, template_values[res_id][field]) for field in returned_fields if template_values[res_id].get(field))
res_id_values['body'] = res_id_values.pop('body_html', '')
values[res_id] = res_id_values
return multi_mode and values or values[res_ids[0]]
class Invite(models.TransientModel):
""" Wizard to invite partners (or channels) and make them followers. """
_name = 'mail.wizard.invite'
_description = 'Invite wizard'
@api.model
def default_get(self, fields):
result = super(Invite, self).default_get(fields)
if self._context.get('mail_invite_follower_channel_only'):
result['send_mail'] = False
if 'message' not in fields:
return result
user_name = self.env.user.display_name
model = result.get('res_model')
res_id = result.get('res_id')
if model and res_id:
document = self.env['ir.model']._get(model).display_name
title = self.env[model].browse(res_id).display_name
msg_fmt = _(
'%(user_name)s invited you to follow %(document)s document: %(title)s'
)
else:
msg_fmt = _('%(user_name)s invited you to follow a new document.')
text = msg_fmt % locals()
message = html.DIV(html.P(_('Hello,')), html.P(text))
result['message'] = etree.tostring(message)
return result
res_model = fields.Char('Related Document Model',
required=True,
index=True,
help='Model of the followed resource')
res_id = fields.Integer('Related Document ID',
index=True,
help='Id of the followed resource')
partner_ids = fields.Many2many(
'res.partner',
string='Recipients',
help=
"List of partners that will be added as follower of the current document."
)
channel_ids = fields.Many2many(
'mail.channel',
string='Channels',
help=
'List of channels that will be added as listeners of the current document.',
domain=[('channel_type', '=', 'channel')])
message = fields.Html('Message')
send_mail = fields.Boolean(
'Send Email',
default=True,
help=
"If checked, the partners will receive an email warning they have been added in the document's followers."
)
def add_followers(self):
email_from = self.env['mail.message']._get_default_from()
for wizard in self:
Model = self.env[wizard.res_model]
document = Model.browse(wizard.res_id)
# filter partner_ids to get the new followers, to avoid sending email to already following partners
new_partners = wizard.partner_ids - document.message_partner_ids
new_channels = wizard.channel_ids - document.message_channel_ids
document.message_subscribe(new_partners.ids, new_channels.ids)
model_name = self.env['ir.model']._get(
wizard.res_model).display_name
# send an email if option checked and if a message exists (do not send void emails)
if wizard.send_mail and wizard.message and not wizard.message == '<br>': # when deleting the message, cleditor keeps a <br>
message = self.env['mail.message'].create({
'subject':
_('Invitation to follow %s: %s') %
(model_name, document.display_name),
'body':
wizard.message,
'record_name':
document.display_name,
'email_from':
email_from,
'reply_to':
email_from,
'model':
wizard.res_model,
'res_id':
wizard.res_id,
'no_auto_thread':
True,
'add_sign':
True,
})
partners_data = []
recipient_data = self.env[
'mail.followers']._get_recipient_data(
document, 'comment', False, pids=new_partners.ids)
for pid, cid, active, pshare, ctype, notif, groups in recipient_data:
pdata = {
'id': pid,
'share': pshare,
'active': active,
'notif': 'email',
'groups': groups or []
}
if not pshare and notif: # has an user and is not shared, is therefore user
partners_data.append(dict(pdata, type='user'))
elif pshare and notif: # has an user and is shared, is therefore portal
partners_data.append(dict(pdata, type='portal'))
else: # has no user, is therefore customer
partners_data.append(dict(pdata, type='customer'))
document._notify_record_by_email(message, {
'partners': partners_data,
'channels': []
},
send_after_commit=False)
message.unlink()
return {'type': 'ir.actions.act_window_close'}
class Module(models.Model):
_name = "ir.module.module"
_rec_name = "shortdesc"
_description = "Module"
_order = 'sequence,name'
@api.model
def fields_view_get(self,
view_id=None,
view_type='form',
toolbar=False,
submenu=False):
res = super(Module, self).fields_view_get(view_id,
view_type,
toolbar=toolbar,
submenu=False)
if view_type == 'form' and res.get('toolbar', False):
install_id = self.env.ref(
'base.action_server_module_immediate_install').id
action = [
rec for rec in res['toolbar']['action']
if rec.get('id', False) != install_id
]
res['toolbar'] = {'action': action}
return res
@classmethod
def get_module_info(cls, name):
try:
return modules.load_information_from_description_file(name)
except Exception:
_logger.debug(
'Error when trying to fetch information for module %s',
name,
exc_info=True)
return {}
@api.depends('name', 'description')
def _get_desc(self):
for module in self:
path = modules.get_module_resource(
module.name, 'static/description/index.html')
if path:
with tools.file_open(path, 'rb') as desc_file:
doc = desc_file.read()
html = lxml.html.document_fromstring(doc)
for element, attribute, link, pos in html.iterlinks():
if element.get('src') and not '//' in element.get(
'src') and not 'static/' in element.get('src'):
element.set(
'src', "/%s/static/description/%s" %
(module.name, element.get('src')))
module.description_html = tools.html_sanitize(
lxml.html.tostring(html))
else:
overrides = {
'embed_stylesheet': False,
'doctitle_xform': False,
'output_encoding': 'unicode',
'xml_declaration': False,
'file_insertion_enabled': False,
}
output = publish_string(
source=module.description
if not module.application and module.description else '',
settings_overrides=overrides,
writer=MyWriter())
module.description_html = tools.html_sanitize(output)
@api.depends('name')
def _get_latest_version(self):
default_version = modules.adapt_version('1.0')
for module in self:
module.installed_version = self.get_module_info(module.name).get(
'version', default_version)
@api.depends('name', 'state')
def _get_views(self):
IrModelData = self.env['ir.model.data'].with_context(active_test=True)
dmodels = ['ir.ui.view', 'ir.actions.report', 'ir.ui.menu']
for module in self:
# Skip uninstalled modules below, no data to find anyway.
if module.state not in ('installed', 'to upgrade', 'to remove'):
module.views_by_module = ""
module.reports_by_module = ""
module.menus_by_module = ""
continue
# then, search and group ir.model.data records
imd_models = defaultdict(list)
imd_domain = [('module', '=', module.name),
('model', 'in', tuple(dmodels))]
for data in IrModelData.sudo().search(imd_domain):
imd_models[data.model].append(data.res_id)
def browse(model):
# as this method is called before the module update, some xmlid
# may be invalid at this stage; explictly filter records before
# reading them
return self.env[model].browse(imd_models[model]).exists()
def format_view(v):
return '%s%s (%s)' % (v.inherit_id and '* INHERIT '
or '', v.name, v.type)
module.views_by_module = "\n".join(
sorted(format_view(v) for v in browse('ir.ui.view')))
module.reports_by_module = "\n".join(
sorted(r.name for r in browse('ir.actions.report')))
module.menus_by_module = "\n".join(
sorted(m.complete_name for m in browse('ir.ui.menu')))
@api.depends('icon')
def _get_icon_image(self):
for module in self:
module.icon_image = ''
if module.icon:
path_parts = module.icon.split('/')
path = modules.get_module_resource(path_parts[1],
*path_parts[2:])
else:
path = modules.module.get_module_icon(module.name)
if path:
with tools.file_open(path, 'rb') as image_file:
module.icon_image = base64.b64encode(image_file.read())
name = fields.Char('Technical Name',
readonly=True,
required=True,
index=True)
category_id = fields.Many2one('ir.module.category',
string='Category',
readonly=True,
index=True)
shortdesc = fields.Char('Module Name', readonly=True, translate=True)
summary = fields.Char('Summary', readonly=True, translate=True)
description = fields.Text('Description', readonly=True, translate=True)
description_html = fields.Html('Description HTML', compute='_get_desc')
author = fields.Char("Author", readonly=True)
maintainer = fields.Char('Maintainer', readonly=True)
contributors = fields.Text('Contributors', readonly=True)
website = fields.Char("Website", readonly=True)
# attention: Incorrect field names !!
# installed_version refers the latest version (the one on disk)
# latest_version refers the installed version (the one in database)
# published_version refers the version available on the repository
installed_version = fields.Char('Latest Version',
compute='_get_latest_version')
latest_version = fields.Char('Installed Version', readonly=True)
published_version = fields.Char('Published Version', readonly=True)
url = fields.Char('URL', readonly=True)
sequence = fields.Integer('Sequence', default=100)
dependencies_id = fields.One2many('ir.module.module.dependency',
'module_id',
string='Dependencies',
readonly=True)
exclusion_ids = fields.One2many('ir.module.module.exclusion',
'module_id',
string='Exclusions',
readonly=True)
auto_install = fields.Boolean(
'Automatic Installation',
help='An auto-installable module is automatically installed by the '
'system when all its dependencies are satisfied. '
'If the module has no dependency, it is always installed.')
state = fields.Selection(STATES,
string='Status',
default='uninstallable',
readonly=True,
index=True)
demo = fields.Boolean('Demo Data', default=False, readonly=True)
license = fields.Selection(
[('GPL-2', 'GPL Version 2'),
('GPL-2 or any later version', 'GPL-2 or later version'),
('GPL-3', 'GPL Version 3'),
('GPL-3 or any later version', 'GPL-3 or later version'),
('AGPL-3', 'Affero GPL-3'), ('LGPL-3', 'LGPL Version 3'),
('Other OSI approved licence', 'Other OSI Approved License'),
('OEEL-1', 'Coffice Enterprise Edition License v1.0'),
('OPL-1', 'Coffice Proprietary License v1.0'),
('Other proprietary', 'Other Proprietary')],
string='License',
default='LGPL-3',
readonly=True)
menus_by_module = fields.Text(string='Menus',
compute='_get_views',
store=True)
reports_by_module = fields.Text(string='Reports',
compute='_get_views',
store=True)
views_by_module = fields.Text(string='Views',
compute='_get_views',
store=True)
application = fields.Boolean('Application', readonly=True)
icon = fields.Char('Icon URL')
icon_image = fields.Binary(string='Icon', compute='_get_icon_image')
to_buy = fields.Boolean('Coffice Enterprise Module', default=False)
_sql_constraints = [
('name_uniq', 'UNIQUE (name)',
'The name of the module must be unique!'),
]
def unlink(self):
if not self:
return True
for module in self:
if module.state in ('installed', 'to upgrade', 'to remove',
'to install'):
raise UserError(
_('You are trying to remove a module that is installed or will be installed.'
))
self.clear_caches()
return super(Module, self).unlink()
@staticmethod
def _check_python_external_dependency(pydep):
try:
pkg_resources.get_distribution(pydep)
except pkg_resources.DistributionNotFound as e:
try:
importlib.import_module(pydep)
_logger.warning(
"python external dependency %s should be replaced by it's PyPI package name",
pydep)
except ImportError:
# backward compatibility attempt failed
_logger.warning("DistributionNotFound: %s", e)
raise Exception('Python library not installed: %s' % (pydep, ))
except pkg_resources.VersionConflict as e:
_logger.warning("VersionConflict: %s", e)
raise Exception('Python library version conflict: %s' % (pydep, ))
except Exception as e:
_logger.warning("get_distribution(%s) failed: %s", pydep, e)
raise Exception('Error finding python library %s' % (pydep, ))
@staticmethod
def _check_external_dependencies(terp):
depends = terp.get('external_dependencies')
if not depends:
return
for pydep in depends.get('python', []):
Module._check_python_external_dependency(pydep)
for binary in depends.get('bin', []):
try:
tools.find_in_path(binary)
except IOError:
raise Exception('Unable to find %r in path' % (binary, ))
@classmethod
def check_external_dependencies(cls, module_name, newstate='to install'):
terp = cls.get_module_info(module_name)
try:
cls._check_external_dependencies(terp)
except Exception as e:
if newstate == 'to install':
msg = _(
'Unable to install module "%s" because an external dependency is not met: %s'
)
elif newstate == 'to upgrade':
msg = _(
'Unable to upgrade module "%s" because an external dependency is not met: %s'
)
else:
msg = _(
'Unable to process module "%s" because an external dependency is not met: %s'
)
raise UserError(msg % (module_name, e.args[0]))
def _state_update(self, newstate, states_to_update, level=100):
if level < 1:
raise UserError(_('Recursion error in modules dependencies !'))
# whether some modules are installed with demo data
demo = False
for module in self:
# determine dependency modules to update/others
update_mods, ready_mods = self.browse(), self.browse()
for dep in module.dependencies_id:
if dep.state == 'unknown':
raise UserError(
_("You try to install module '%s' that depends on module '%s'.\nBut the latter module is not available in your system."
) % (
module.name,
dep.name,
))
if dep.depend_id.state == newstate:
ready_mods += dep.depend_id
else:
update_mods += dep.depend_id
# update dependency modules that require it, and determine demo for module
update_demo = update_mods._state_update(newstate,
states_to_update,
level=level - 1)
module_demo = module.demo or update_demo or any(
mod.demo for mod in ready_mods)
demo = demo or module_demo
# check dependencies and update module itself
self.check_external_dependencies(module.name, newstate)
if module.state in states_to_update:
module.write({'state': newstate, 'demo': module_demo})
return demo
@assert_log_admin_access
def button_install(self):
# domain to select auto-installable (but not yet installed) modules
auto_domain = [('state', '=', 'uninstalled'),
('auto_install', '=', True)]
# determine whether an auto-install module must be installed:
# - all its dependencies are installed or to be installed,
# - at least one dependency is 'to install'
install_states = frozenset(('installed', 'to install', 'to upgrade'))
def must_install(module):
states = {
dep.state
for dep in module.dependencies_id if dep.auto_install_required
}
return states <= install_states and 'to install' in states
modules = self
while modules:
# Mark the given modules and their dependencies to be installed.
modules._state_update('to install', ['uninstalled'])
# Determine which auto-installable modules must be installed.
modules = self.search(auto_domain).filtered(must_install)
# the modules that are installed/to install/to upgrade
install_mods = self.search([('state', 'in', list(install_states))])
# check individual exclusions
install_names = {module.name for module in install_mods}
for module in install_mods:
for exclusion in module.exclusion_ids:
if exclusion.name in install_names:
msg = _('Modules "%s" and "%s" are incompatible.')
raise UserError(
msg %
(module.shortdesc, exclusion.exclusion_id.shortdesc))
# check category exclusions
def closure(module):
todo = result = module
while todo:
result |= todo
todo = todo.dependencies_id.depend_id
return result
exclusives = self.env['ir.module.category'].search([('exclusive', '=',
True)])
for category in exclusives:
# retrieve installed modules in category and sub-categories
categories = category.search([('id', 'child_of', category.ids)])
modules = install_mods.filtered(
lambda mod: mod.category_id in categories)
# the installation is valid if all installed modules in categories
# belong to the transitive dependencies of one of them
if modules and not any(modules <= closure(module)
for module in modules):
msg = _(
'You are trying to install incompatible modules in category "%s":'
)
labels = dict(self.fields_get(['state'])['state']['selection'])
raise UserError("\n".join([msg % category.name] + [
"- %s (%s)" % (module.shortdesc, labels[module.state])
for module in modules
]))
return dict(ACTION_DICT, name=_('Install'))
@assert_log_admin_access
def button_immediate_install(self):
""" Installs the selected module(s) immediately and fully,
returns the next res.config action to execute
:returns: next res.config item to execute
:rtype: dict[str, object]
"""
_logger.info('User #%d triggered module installation', self.env.uid)
# We use here the request object (which is thread-local) as a kind of
# "global" env because the env is not usable in the following use case.
# When installing a Chart of Account, I would like to send the
# allowed companies to configure it on the correct company.
# Otherwise, the SUPERUSER won't be aware of that and will try to
# configure the CoA on his own company, which makes no sense.
if request:
request.allowed_company_ids = self.env.companies.ids
return self._button_immediate_function(type(self).button_install)
@assert_log_admin_access
def button_install_cancel(self):
self.write({'state': 'uninstalled', 'demo': False})
return True
@assert_log_admin_access
def module_uninstall(self):
""" Perform the various steps required to uninstall a module completely
including the deletion of all database structures created by the module:
tables, columns, constraints, etc.
"""
modules_to_remove = self.mapped('name')
self.env['ir.model.data']._module_data_uninstall(modules_to_remove)
# we deactivate prefetching to not try to read a column that has been deleted
self.with_context(prefetch_fields=False).write({
'state': 'uninstalled',
'latest_version': False
})
return True
def _remove_copied_views(self):
""" Remove the copies of the views installed by the modules in `self`.
Those copies do not have an external id so they will not be cleaned by
`_module_data_uninstall`. This is why we rely on `key` instead.
It is important to remove these copies because using them will crash if
they rely on data that don't exist anymore if the module is removed.
"""
domain = expression.OR([[('key', '=like', m.name + '.%')]
for m in self])
orphans = self.env['ir.ui.view'].with_context(
**{
'active_test': False,
MODULE_UNINSTALL_FLAG: True
}).search(domain)
orphans.unlink()
@api.returns('self')
def downstream_dependencies(self,
known_deps=None,
exclude_states=('uninstalled', 'uninstallable',
'to remove')):
""" Return the modules that directly or indirectly depend on the modules
in `self`, and that satisfy the `exclude_states` filter.
"""
if not self:
return self
known_deps = known_deps or self.browse()
query = """ SELECT DISTINCT m.id
FROM ir_module_module_dependency d
JOIN ir_module_module m ON (d.module_id=m.id)
WHERE
d.name IN (SELECT name from ir_module_module where id in %s) AND
m.state NOT IN %s AND
m.id NOT IN %s """
self._cr.execute(query, (tuple(self.ids), tuple(exclude_states),
tuple(known_deps.ids or self.ids)))
new_deps = self.browse([row[0] for row in self._cr.fetchall()])
missing_mods = new_deps - known_deps
known_deps |= new_deps
if missing_mods:
known_deps |= missing_mods.downstream_dependencies(
known_deps, exclude_states)
return known_deps
@api.returns('self')
def upstream_dependencies(self,
known_deps=None,
exclude_states=('installed', 'uninstallable',
'to remove')):
""" Return the dependency tree of modules of the modules in `self`, and
that satisfy the `exclude_states` filter.
"""
if not self:
return self
known_deps = known_deps or self.browse()
query = """ SELECT DISTINCT m.id
FROM ir_module_module_dependency d
JOIN ir_module_module m ON (d.module_id=m.id)
WHERE
m.name IN (SELECT name from ir_module_module_dependency where module_id in %s) AND
m.state NOT IN %s AND
m.id NOT IN %s """
self._cr.execute(query, (tuple(self.ids), tuple(exclude_states),
tuple(known_deps.ids or self.ids)))
new_deps = self.browse([row[0] for row in self._cr.fetchall()])
missing_mods = new_deps - known_deps
known_deps |= new_deps
if missing_mods:
known_deps |= missing_mods.upstream_dependencies(
known_deps, exclude_states)
return known_deps
def next(self):
"""
Return the action linked to an ir.actions.todo is there exists one that
should be executed. Otherwise, redirect to /web
"""
Todos = self.env['ir.actions.todo']
_logger.info('getting next %s', Todos)
active_todo = Todos.search([('state', '=', 'open')], limit=1)
if active_todo:
_logger.info('next action is "%s"', active_todo.name)
return active_todo.action_launch()
return {
'type': 'ir.actions.act_url',
'target': 'self',
'url': '/web',
}
def _button_immediate_function(self, function):
try:
# This is done because the installation/uninstallation/upgrade can modify a currently
# running cron job and prevent it from finishing, and since the ir_cron table is locked
# during execution, the lock won't be released until timeout.
self._cr.execute("SELECT * FROM ir_cron FOR UPDATE NOWAIT")
except psycopg2.OperationalError:
raise UserError(
_("The server is busy right now, module operations are not possible at"
" this time, please try again later."))
function(self)
self._cr.commit()
api.Environment.reset()
modules.registry.Registry.new(self._cr.dbname, update_module=True)
self._cr.commit()
env = api.Environment(self._cr, self._uid, self._context)
# pylint: disable=next-method-called
config = env['ir.module.module'].next() or {}
if config.get('type') not in ('ir.actions.act_window_close', ):
return config
# reload the client; open the first available root menu
menu = env['ir.ui.menu'].search([('parent_id', '=', False)])[:1]
return {
'type': 'ir.actions.client',
'tag': 'reload',
'params': {
'menu_id': menu.id
},
}
@assert_log_admin_access
def button_immediate_uninstall(self):
"""
Uninstall the selected module(s) immediately and fully,
returns the next res.config action to execute
"""
_logger.info('User #%d triggered module uninstallation', self.env.uid)
return self._button_immediate_function(type(self).button_uninstall)
@assert_log_admin_access
def button_uninstall(self):
if 'base' in self.mapped('name'):
raise UserError(_("The `base` module cannot be uninstalled"))
deps = self.downstream_dependencies()
(self + deps).write({'state': 'to remove'})
return dict(ACTION_DICT, name=_('Uninstall'))
@assert_log_admin_access
def button_uninstall_wizard(self):
""" Launch the wizard to uninstall the given module. """
return {
'type': 'ir.actions.act_window',
'target': 'new',
'name': _('Uninstall module'),
'view_mode': 'form',
'res_model': 'base.module.uninstall',
'context': {
'default_module_id': self.id
},
}
def button_uninstall_cancel(self):
self.write({'state': 'installed'})
return True
@assert_log_admin_access
def button_immediate_upgrade(self):
"""
Upgrade the selected module(s) immediately and fully,
return the next res.config action to execute
"""
return self._button_immediate_function(type(self).button_upgrade)
@assert_log_admin_access
def button_upgrade(self):
Dependency = self.env['ir.module.module.dependency']
self.update_list()
todo = list(self)
i = 0
while i < len(todo):
module = todo[i]
i += 1
if module.state not in ('installed', 'to upgrade'):
raise UserError(
_("Can not upgrade module '%s'. It is not installed.") %
(module.name, ))
self.check_external_dependencies(module.name, 'to upgrade')
for dep in Dependency.search([('name', '=', module.name)]):
if dep.module_id.state == 'installed' and dep.module_id not in todo:
todo.append(dep.module_id)
self.browse(module.id
for module in todo).write({'state': 'to upgrade'})
to_install = []
for module in todo:
for dep in module.dependencies_id:
if dep.state == 'unknown':
raise UserError(
_('You try to upgrade the module %s that depends on the module: %s.\nBut this module is not available in your system.'
) % (
module.name,
dep.name,
))
if dep.state == 'uninstalled':
to_install += self.search([('name', '=', dep.name)]).ids
self.browse(to_install).button_install()
return dict(ACTION_DICT, name=_('Apply Schedule Upgrade'))
@assert_log_admin_access
def button_upgrade_cancel(self):
self.write({'state': 'installed'})
return True
@staticmethod
def get_values_from_terp(terp):
return {
'description': terp.get('description', ''),
'shortdesc': terp.get('name', ''),
'author': terp.get('author', 'Unknown'),
'maintainer': terp.get('maintainer', False),
'contributors': ', '.join(terp.get('contributors', [])) or False,
'website': terp.get('website', ''),
'license': terp.get('license', 'LGPL-3'),
'sequence': terp.get('sequence', 100),
'application': terp.get('application', False),
'auto_install': terp.get('auto_install', False) is not False,
'icon': terp.get('icon', False),
'summary': terp.get('summary', ''),
'url': terp.get('url') or terp.get('live_test_url', ''),
'to_buy': False
}
@api.model
def create(self, vals):
new = super(Module, self).create(vals)
module_metadata = {
'name': 'module_%s' % vals['name'],
'model': 'ir.module.module',
'module': 'base',
'res_id': new.id,
'noupdate': True,
}
self.env['ir.model.data'].create(module_metadata)
return new
# update the list of available packages
@assert_log_admin_access
@api.model
def update_list(self):
res = [0, 0] # [update, add]
default_version = modules.adapt_version('1.0')
known_mods = self.with_context(lang=None).search([])
known_mods_names = {mod.name: mod for mod in known_mods}
# iterate through detected modules and update/create them in db
for mod_name in modules.get_modules():
mod = known_mods_names.get(mod_name)
terp = self.get_module_info(mod_name)
values = self.get_values_from_terp(terp)
if mod:
updated_values = {}
for key in values:
old = getattr(mod, key)
if (old or values[key]) and values[key] != old:
updated_values[key] = values[key]
if terp.get('installable',
True) and mod.state == 'uninstallable':
updated_values['state'] = 'uninstalled'
if parse_version(terp.get(
'version', default_version)) > parse_version(
mod.latest_version or default_version):
res[0] += 1
if updated_values:
mod.write(updated_values)
else:
mod_path = modules.get_module_path(mod_name)
if not mod_path or not terp:
continue
state = "uninstalled" if terp.get('installable',
True) else "uninstallable"
mod = self.create(dict(name=mod_name, state=state, **values))
res[1] += 1
mod._update_dependencies(terp.get('depends', []),
terp.get('auto_install'))
mod._update_exclusions(terp.get('excludes', []))
mod._update_category(terp.get('category', 'Uncategorized'))
return res
@assert_log_admin_access
def download(self, download=True):
return []
@assert_log_admin_access
@api.model
def install_from_urls(self, urls):
if not self.env.user.has_group('base.group_system'):
raise AccessDenied()
# One-click install is opt-in - cfr Issue #15225
ad_dir = tools.config.addons_data_dir
if not os.access(ad_dir, os.W_OK):
msg = (_(
"Automatic install of downloaded Apps is currently disabled."
) + "\n\n" + _(
"To enable it, make sure this directory exists and is writable on the server:"
) + "\n%s" % ad_dir)
_logger.warning(msg)
raise UserError(msg)
apps_server = urls.url_parse(self.get_apps_server())
OPENERP = coffice.release.product_name.lower()
tmp = tempfile.mkdtemp()
_logger.debug('Install from url: %r', urls)
try:
# 1. Download & unzip missing modules
for module_name, url in urls.items():
if not url:
continue # nothing to download, local version is already the last one
up = urls.url_parse(url)
if up.scheme != apps_server.scheme or up.netloc != apps_server.netloc:
raise AccessDenied()
try:
_logger.info('Downloading module `%s` from OpenERP Apps',
module_name)
response = requests.get(url)
response.raise_for_status()
content = response.content
except Exception:
_logger.exception('Failed to fetch module %s', module_name)
raise UserError(
_('The `%s` module appears to be unavailable at the moment, please try again later.'
) % module_name)
else:
zipfile.ZipFile(io.BytesIO(content)).extractall(tmp)
assert os.path.isdir(os.path.join(tmp, module_name))
# 2a. Copy/Replace module source in addons path
for module_name, url in urls.items():
if module_name == OPENERP or not url:
continue # OPENERP is special case, handled below, and no URL means local module
module_path = modules.get_module_path(module_name,
downloaded=True,
display_warning=False)
bck = backup(module_path, False)
_logger.info('Copy downloaded module `%s` to `%s`',
module_name, module_path)
shutil.move(os.path.join(tmp, module_name), module_path)
if bck:
shutil.rmtree(bck)
# 2b. Copy/Replace server+base module source if downloaded
if urls.get(OPENERP):
# special case. it contains the server and the base module.
# extract path is not the same
base_path = os.path.dirname(modules.get_module_path('base'))
# copy all modules in the SERVER/coffice/addons directory to the new "coffice" module (except base itself)
for d in os.listdir(base_path):
if d != 'base' and os.path.isdir(os.path.join(
base_path, d)):
destdir = os.path.join(
tmp, OPENERP, 'addons',
d) # XXX 'coffice' subdirectory ?
shutil.copytree(os.path.join(base_path, d), destdir)
# then replace the server by the new "base" module
server_dir = tools.config['root_path'] # XXX or dirname()
bck = backup(server_dir)
_logger.info('Copy downloaded module `coffice` to `%s`',
server_dir)
shutil.move(os.path.join(tmp, OPENERP), server_dir)
#if bck:
# shutil.rmtree(bck)
self.update_list()
with_urls = [
module_name for module_name, url in urls.items() if url
]
downloaded = self.search([('name', 'in', with_urls)])
installed = self.search([('id', 'in', downloaded.ids),
('state', '=', 'installed')])
to_install = self.search([('name', 'in', list(urls)),
('state', '=', 'uninstalled')])
post_install_action = to_install.button_immediate_install()
if installed or to_install:
# in this case, force server restart to reload python code...
self._cr.commit()
coffice.service.server.restart()
return {
'type': 'ir.actions.client',
'tag': 'home',
'params': {
'wait': True
},
}
return post_install_action
finally:
shutil.rmtree(tmp)
@api.model
def get_apps_server(self):
return tools.config.get('apps_server', 'https://apps.coffice.com/apps')
def _update_dependencies(self, depends=None, auto_install_requirements=()):
existing = set(dep.name for dep in self.dependencies_id)
needed = set(depends or [])
for dep in (needed - existing):
self._cr.execute(
'INSERT INTO ir_module_module_dependency (module_id, name) values (%s, %s)',
(self.id, dep))
for dep in (existing - needed):
self._cr.execute(
'DELETE FROM ir_module_module_dependency WHERE module_id = %s and name = %s',
(self.id, dep))
self._cr.execute(
'UPDATE ir_module_module_dependency SET auto_install_required = (name = any(%s)) WHERE module_id = %s',
(list(auto_install_requirements or ()), self.id))
self.invalidate_cache(['dependencies_id'], self.ids)
def _update_exclusions(self, excludes=None):
existing = set(excl.name for excl in self.exclusion_ids)
needed = set(excludes or [])
for name in (needed - existing):
self._cr.execute(
'INSERT INTO ir_module_module_exclusion (module_id, name) VALUES (%s, %s)',
(self.id, name))
for name in (existing - needed):
self._cr.execute(
'DELETE FROM ir_module_module_exclusion WHERE module_id=%s AND name=%s',
(self.id, name))
self.invalidate_cache(['exclusion_ids'], self.ids)
def _update_category(self, category='Uncategorized'):
current_category = self.category_id
current_category_path = []
while current_category:
current_category_path.insert(0, current_category.name)
current_category = current_category.parent_id
categs = category.split('/')
if categs != current_category_path:
cat_id = modules.db.create_categories(self._cr, categs)
self.write({'category_id': cat_id})
def _update_translations(self, filter_lang=None):
if not filter_lang:
langs = self.env['res.lang'].get_installed()
filter_lang = [code for code, _ in langs]
elif not isinstance(filter_lang, (list, tuple)):
filter_lang = [filter_lang]
update_mods = self.filtered(lambda r: r.state in
('installed', 'to install', 'to upgrade'))
mod_dict = {
mod.name: mod.dependencies_id.mapped('name')
for mod in update_mods
}
mod_names = topological_sort(mod_dict)
self.env['ir.translation']._load_module_terms(mod_names, filter_lang)
def _check(self):
for module in self:
if not module.description_html:
_logger.warning('module %s: description is empty !',
module.name)
@api.model
@tools.ormcache()
def _installed(self):
""" Return the set of installed modules as a dictionary {name: id} """
return {
module.name: module.id
for module in self.sudo().search([('state', '=', 'installed')])
}
class Track(models.Model):
_name = "event.track"
_description = 'Event Track'
_order = 'priority, date'
_inherit = [
'mail.thread', 'mail.activity.mixin', 'website.seo.metadata',
'website.published.mixin'
]
@api.model
def _get_default_stage_id(self):
return self.env['event.track.stage'].search([], limit=1).id
name = fields.Char('Title', required=True, translate=True)
active = fields.Boolean(default=True)
user_id = fields.Many2one('res.users',
'Responsible',
tracking=True,
default=lambda self: self.env.user)
company_id = fields.Many2one('res.company', related='event_id.company_id')
partner_id = fields.Many2one('res.partner', 'Speaker')
partner_name = fields.Char('Name')
partner_email = fields.Char('Email')
partner_phone = fields.Char('Phone')
partner_biography = fields.Html('Biography')
tag_ids = fields.Many2many('event.track.tag', string='Tags')
stage_id = fields.Many2one('event.track.stage',
string='Stage',
ondelete='restrict',
index=True,
copy=False,
default=_get_default_stage_id,
group_expand='_read_group_stage_ids',
required=True,
tracking=True)
kanban_state = fields.Selection(
[('normal', 'Grey'), ('done', 'Green'), ('blocked', 'Red')],
string='Kanban State',
copy=False,
default='normal',
required=True,
tracking=True,
help=
"A track's kanban state indicates special situations affecting it:\n"
" * Grey is the default situation\n"
" * Red indicates something is preventing the progress of this track\n"
" * Green indicates the track is ready to be pulled to the next stage")
description = fields.Html(translate=html_translate,
sanitize_attributes=False)
date = fields.Datetime('Track Date')
date_end = fields.Datetime('Track End Date',
compute='_compute_end_date',
store=True)
duration = fields.Float('Duration',
default=1.5,
help="Track duration in hours.")
location_id = fields.Many2one('event.track.location', 'Room')
event_id = fields.Many2one('event.event', 'Event', required=True)
color = fields.Integer('Color Index')
priority = fields.Selection([('0', 'Low'), ('1', 'Medium'), ('2', 'High'),
('3', 'Highest')],
'Priority',
required=True,
default='1')
image = fields.Image("Image",
related='partner_id.image_128',
store=True,
readonly=False)
@api.depends('name')
def _compute_website_url(self):
super(Track, self)._compute_website_url()
for track in self:
if track.id:
track.website_url = '/event/%s/track/%s' % (slug(
track.event_id), slug(track))
@api.onchange('partner_id')
def _onchange_partner_id(self):
if self.partner_id:
self.partner_name = self.partner_id.name
self.partner_email = self.partner_id.email
self.partner_phone = self.partner_id.phone
self.partner_biography = self.partner_id.website_description
@api.depends('date', 'duration')
def _compute_end_date(self):
for track in self:
if track.date:
delta = timedelta(minutes=60 * track.duration)
track.date_end = track.date + delta
else:
track.date_end = False
@api.model
def create(self, vals):
track = super(Track, self).create(vals)
track.event_id.message_post_with_view(
'website_event_track.event_track_template_new',
values={'track': track},
subject=track.name,
subtype_id=self.env.ref('website_event_track.mt_event_track').id,
)
return track
def write(self, vals):
if 'stage_id' in vals and 'kanban_state' not in vals:
vals['kanban_state'] = 'normal'
res = super(Track, self).write(vals)
if vals.get('partner_id'):
self.message_subscribe([vals['partner_id']])
return res
@api.model
def _read_group_stage_ids(self, stages, domain, order):
""" Always display all stages """
return stages.search([], order=order)
def _track_template(self, changes):
res = super(Track, self)._track_template(changes)
track = self[0]
if 'stage_id' in changes and track.stage_id.mail_template_id:
res['stage_id'] = (track.stage_id.mail_template_id, {
'composition_mode':
'comment',
'auto_delete_message':
True,
'subtype_id':
self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
'email_layout_xmlid':
'mail.mail_notification_light'
})
return res
def _track_subtype(self, init_values):
self.ensure_one()
if 'kanban_state' in init_values and self.kanban_state == 'blocked':
return self.env.ref('website_event_track.mt_track_blocked')
elif 'kanban_state' in init_values and self.kanban_state == 'done':
return self.env.ref('website_event_track.mt_track_ready')
return super(Track, self)._track_subtype(init_values)
def _message_get_suggested_recipients(self):
recipients = super(Track, self)._message_get_suggested_recipients()
for track in self:
if track.partner_email and track.partner_email != track.partner_id.email:
track._message_add_suggested_recipient(
recipients,
email=track.partner_email,
reason=_('Speaker Email'))
return recipients
def _message_post_after_hook(self, message, msg_vals):
if self.partner_email and not self.partner_id:
# we consider that posting a message with a specified recipient (not a follower, a specific one)
# on a document without customer means that it was created through the chatter using
# suggested recipients. This heuristic allows to avoid ugly hacks in JS.
new_partner = message.partner_ids.filtered(
lambda partner: partner.email == self.partner_email)
if new_partner:
self.search([
('partner_id', '=', False),
('partner_email', '=', new_partner.email),
('stage_id.is_cancel', '=', False),
]).write({'partner_id': new_partner.id})
return super(Track, self)._message_post_after_hook(message, msg_vals)
def open_track_speakers_list(self):
return {
'name': _('Speakers'),
'domain': [('id', 'in', self.mapped('partner_id').ids)],
'view_mode': 'kanban,form',
'res_model': 'res.partner',
'view_id': False,
'type': 'ir.actions.act_window',
}
class BlogPost(models.Model):
_name = "blog.post"
_description = "Blog Post"
_inherit = [
'mail.thread', 'website.seo.metadata', 'website.published.multi.mixin'
]
_order = 'id DESC'
_mail_post_access = 'read'
def _compute_website_url(self):
super(BlogPost, self)._compute_website_url()
for blog_post in self:
blog_post.website_url = "/blog/%s/post/%s" % (slug(
blog_post.blog_id), slug(blog_post))
def _default_content(self):
return '''
<p class="o_default_snippet_text">''' + _(
"Start writing here...") + '''</p>
'''
name = fields.Char('Title', required=True, translate=True, default='')
subtitle = fields.Char('Sub Title', translate=True)
author_id = fields.Many2one('res.partner',
'Author',
default=lambda self: self.env.user.partner_id)
active = fields.Boolean('Active', default=True)
cover_properties = fields.Text(
'Cover Properties',
default=
'{"background-image": "none", "background-color": "oe_black", "opacity": "0.2", "resize_class": "cover_mid"}'
)
blog_id = fields.Many2one('blog.blog',
'Blog',
required=True,
ondelete='cascade')
tag_ids = fields.Many2many('blog.tag', string='Tags')
content = fields.Html('Content',
default=_default_content,
translate=html_translate,
sanitize=False)
teaser = fields.Text('Teaser',
compute='_compute_teaser',
inverse='_set_teaser')
teaser_manual = fields.Text(string='Teaser Content')
website_message_ids = fields.One2many(
domain=lambda self: [('model', '=', self._name),
('message_type', '=', 'comment')])
# creation / update stuff
create_date = fields.Datetime('Created on', index=True, readonly=True)
published_date = fields.Datetime('Published Date')
post_date = fields.Datetime(
'Publishing date',
compute='_compute_post_date',
inverse='_set_post_date',
store=True,
help=
"The blog post will be visible for your visitors as of this date on the website if it is set as published."
)
create_uid = fields.Many2one('res.users',
'Created by',
index=True,
readonly=True)
write_date = fields.Datetime('Last Updated on', index=True, readonly=True)
write_uid = fields.Many2one('res.users',
'Last Contributor',
index=True,
readonly=True)
author_avatar = fields.Binary(related='author_id.image_128',
string="Avatar",
readonly=False)
visits = fields.Integer('No of Views', copy=False)
website_id = fields.Many2one(related='blog_id.website_id', readonly=True)
@api.depends('content', 'teaser_manual')
def _compute_teaser(self):
for blog_post in self:
if blog_post.teaser_manual:
blog_post.teaser = blog_post.teaser_manual
else:
content = html2plaintext(blog_post.content).replace('\n', ' ')
blog_post.teaser = content[:200] + '...'
def _set_teaser(self):
for blog_post in self:
blog_post.teaser_manual = blog_post.teaser
@api.depends('create_date', 'published_date')
def _compute_post_date(self):
for blog_post in self:
if blog_post.published_date:
blog_post.post_date = blog_post.published_date
else:
blog_post.post_date = blog_post.create_date
def _set_post_date(self):
for blog_post in self:
blog_post.published_date = blog_post.post_date
if not blog_post.published_date:
blog_post._write(dict(post_date=blog_post.create_date)
) # dont trigger inverse function
def _check_for_publication(self, vals):
if vals.get('is_published'):
for post in self:
post.blog_id.message_post_with_view(
'website_blog.blog_post_template_new_post',
subject=post.name,
values={'post': post},
subtype_id=self.env['ir.model.data'].xmlid_to_res_id(
'website_blog.mt_blog_blog_published'))
return True
return False
@api.model
def create(self, vals):
post_id = super(BlogPost,
self.with_context(mail_create_nolog=True)).create(vals)
post_id._check_for_publication(vals)
return post_id
def write(self, vals):
result = True
for post in self:
copy_vals = dict(vals)
published_in_vals = set(
vals.keys()) & {'is_published', 'website_published'}
if (published_in_vals and 'published_date' not in vals
and (not post.published_date
or post.published_date <= fields.Datetime.now())):
copy_vals['published_date'] = vals[list(
published_in_vals)[0]] and fields.Datetime.now() or False
result &= super(BlogPost, self).write(copy_vals)
self._check_for_publication(vals)
return result
def get_access_action(self, access_uid=None):
""" Instead of the classic form view, redirect to the post on website
directly if user is an employee or if the post is published. """
self.ensure_one()
user = access_uid and self.env['res.users'].sudo().browse(
access_uid) or self.env.user
if user.share and not self.sudo().website_published:
return super(BlogPost, self).get_access_action(access_uid)
return {
'type': 'ir.actions.act_url',
'url': self.website_url,
'target': 'self',
'target_type': 'public',
'res_id': self.id,
}
def _notify_get_groups(self):
""" Add access button to everyone if the document is published. """
groups = super(BlogPost, self)._notify_get_groups()
if self.website_published:
for group_name, group_method, group_data in groups:
group_data['has_button_access'] = True
return groups
def _notify_record_by_inbox(self,
message,
recipients_data,
msg_vals=False,
**kwargs):
""" Override to avoid keeping all notified recipients of a comment.
We avoid tracking needaction on post comments. Only emails should be
sufficient. """
if msg_vals.get('message_type', message.message_type) == 'comment':
return
return super(BlogPost, self)._notify_record_by_inbox(message,
recipients_data,
msg_vals=msg_vals,
**kwargs)
def _default_website_meta(self):
res = super(BlogPost, self)._default_website_meta()
res['default_opengraph']['og:description'] = res['default_twitter'][
'twitter:description'] = self.subtitle
res['default_opengraph']['og:type'] = 'article'
res['default_opengraph']['article:published_time'] = self.post_date
res['default_opengraph']['article:modified_time'] = self.write_date
res['default_opengraph']['article:tag'] = self.tag_ids.mapped('name')
res['default_opengraph']['og:image'] = res['default_twitter'][
'twitter:image'] = json.loads(self.cover_properties).get(
'background-image', 'none')[4:-1]
res['default_opengraph']['og:title'] = res['default_twitter'][
'twitter:title'] = self.name
res['default_meta_description'] = self.subtitle
return res
class BaseDocumentLayout(models.TransientModel):
"""
Customise the company document layout and display a live preview
"""
_name = 'base.document.layout'
_description = 'Company Document Layout'
company_id = fields.Many2one('res.company',
default=lambda self: self.env.company,
required=True)
logo = fields.Binary(related='company_id.logo', readonly=False)
preview_logo = fields.Binary(related='logo', string="Preview logo")
report_header = fields.Text(related='company_id.report_header',
readonly=False)
report_footer = fields.Text(related='company_id.report_footer',
readonly=False)
paperformat_id = fields.Many2one(related='company_id.paperformat_id',
readonly=False)
external_report_layout_id = fields.Many2one(
related='company_id.external_report_layout_id', readonly=False)
font = fields.Selection(related='company_id.font', readonly=False)
primary_color = fields.Char(related='company_id.primary_color',
readonly=False)
secondary_color = fields.Char(related='company_id.secondary_color',
readonly=False)
custom_colors = fields.Boolean(compute="_compute_custom_colors",
readonly=False)
logo_primary_color = fields.Char(compute="_compute_logo_colors")
logo_secondary_color = fields.Char(compute="_compute_logo_colors")
report_layout_id = fields.Many2one('report.layout')
preview = fields.Html(compute='_compute_preview')
@api.depends('logo_primary_color', 'logo_secondary_color', 'primary_color',
'secondary_color')
def _compute_custom_colors(self):
for wizard in self:
logo_primary = wizard.logo_primary_color or ''
logo_secondary = wizard.logo_secondary_color or ''
# Force lower case on color to ensure that FF01AA == ff01aa
wizard.custom_colors = (
wizard.logo and wizard.primary_color and wizard.secondary_color
and
not (wizard.primary_color.lower() == logo_primary.lower() and
wizard.secondary_color.lower() == logo_secondary.lower()))
@api.depends('logo')
def _compute_logo_colors(self):
for wizard in self:
if wizard._context.get('bin_size'):
wizard_for_image = wizard.with_context(bin_size=False)
else:
wizard_for_image = wizard
wizard.logo_primary_color, wizard.logo_secondary_color = wizard_for_image._parse_logo_colors(
)
@api.depends('report_layout_id', 'logo', 'font', 'primary_color',
'secondary_color')
def _compute_preview(self):
""" compute a qweb based preview to display on the wizard """
for wizard in self:
if wizard.report_layout_id:
ir_qweb = wizard.env['ir.qweb']
wizard.preview = ir_qweb.render('base.layout_preview',
{'company': wizard})
else:
wizard.preview = False
@api.onchange('company_id')
def _onchange_company_id(self):
for wizard in self:
wizard.logo = wizard.company_id.logo
wizard.report_header = wizard.company_id.report_header
wizard.report_footer = wizard.company_id.report_footer
wizard.paperformat_id = wizard.company_id.paperformat_id
wizard.external_report_layout_id = wizard.company_id.external_report_layout_id
wizard.font = wizard.company_id.font
wizard.primary_color = wizard.company_id.primary_color
wizard.secondary_color = wizard.company_id.secondary_color
wizard_layout = wizard.env["report.layout"].search([
('view_id.key', '=',
wizard.company_id.external_report_layout_id.key)
])
wizard.report_layout_id = wizard_layout or wizard_layout.search(
[], limit=1)
if not wizard.primary_color:
wizard.primary_color = wizard.logo_primary_color or DEFAULT_PRIMARY
if not wizard.secondary_color:
wizard.secondary_color = wizard.logo_secondary_color or DEFAULT_SECONDARY
@api.onchange('custom_colors')
def _onchange_custom_colors(self):
for wizard in self:
if wizard.logo and not wizard.custom_colors:
wizard.primary_color = wizard.logo_primary_color or DEFAULT_PRIMARY
wizard.secondary_color = wizard.logo_secondary_color or DEFAULT_SECONDARY
@api.onchange('report_layout_id')
def _onchange_report_layout_id(self):
for wizard in self:
wizard.external_report_layout_id = wizard.report_layout_id.view_id
@api.onchange('logo')
def _onchange_logo(self):
for wizard in self:
# It is admitted that if the user puts the original image back, it won't change colors
company = wizard.company_id
# at that point wizard.logo has been assigned the value present in DB
if wizard.logo == company.logo and company.primary_color and company.secondary_color:
continue
if wizard.logo_primary_color:
wizard.primary_color = wizard.logo_primary_color
if wizard.logo_secondary_color:
wizard.secondary_color = wizard.logo_secondary_color
def _parse_logo_colors(self, logo=None, white_threshold=225):
"""
Identifies dominant colors
First resizes the original image to improve performance, then discards
transparent colors and white-ish colors, then calls the averaging
method twice to evaluate both primary and secondary colors.
:param logo: alternate logo to process
:param white_threshold: arbitrary value defining the maximum value a color can reach
:return colors: hex values of primary and secondary colors
"""
self.ensure_one()
logo = logo or self.logo
if not logo:
return False, False
# The "===" gives different base64 encoding a correct padding
logo += b'===' if type(logo) == bytes else '==='
try:
# Catches exceptions caused by logo not being an image
image = tools.image_fix_orientation(tools.base64_to_image(logo))
except Exception:
return False, False
base_w, base_h = image.size
w = int(50 * base_w / base_h)
h = 50
# Converts to RGBA if no alpha detected
image_converted = image.convert(
'RGBA') if 'A' not in image.getbands() else image
image_resized = image_converted.resize((w, h))
colors = []
for color in image_resized.getcolors(w * h):
if not (color[1][0] > white_threshold
and color[1][1] > white_threshold
and color[1][2] > white_threshold) and color[1][3] > 0:
colors.append(color)
if not colors: # May happen when the whole image is white
return False, False
primary, remaining = tools.average_dominant_color(colors)
secondary = tools.average_dominant_color(
remaining)[0] if len(remaining) > 0 else primary
# Lightness and saturation are calculated here.
# - If both colors have a similar lightness, the most colorful becomes primary
# - When the difference in lightness is too great, the brightest color becomes primary
l_primary = tools.get_lightness(primary)
l_secondary = tools.get_lightness(secondary)
if (l_primary < 0.2 and l_secondary < 0.2) or (l_primary >= 0.2
and l_secondary >= 0.2):
s_primary = tools.get_saturation(primary)
s_secondary = tools.get_saturation(secondary)
if s_primary < s_secondary:
primary, secondary = secondary, primary
elif l_secondary > l_primary:
primary, secondary = secondary, primary
return tools.rgb_to_hex(primary), tools.rgb_to_hex(secondary)
@api.model
def action_open_base_document_layout(self, action_ref=None):
if not action_ref:
action_ref = 'base.action_base_document_layout_configurator'
return self.env.ref(action_ref).read()[0]
def document_layout_save(self):
# meant to be overridden
return self.env.context.get('report_action') or {
'type': 'ir.actions.act_window_close'
}
class Task(models.Model):
_name = "project.task"
_description = "Task"
_date_name = "date_assign"
_inherit = ['portal.mixin', 'mail.thread.cc', 'mail.activity.mixin', 'rating.mixin']
_mail_post_access = 'read'
_order = "priority desc, sequence, id desc"
_check_company_auto = True
@api.model
def default_get(self, fields_list):
result = super(Task, self).default_get(fields_list)
# find default value from parent for the not given ones
parent_task_id = result.get('parent_id') or self._context.get('default_parent_id')
if parent_task_id:
parent_values = self._subtask_values_from_parent(parent_task_id)
for fname, value in parent_values.items():
if fname not in result:
result[fname] = value
return result
@api.model
def _get_default_partner(self):
if 'default_project_id' in self.env.context:
default_project_id = self.env['project.project'].browse(self.env.context['default_project_id'])
return default_project_id.exists().partner_id
def _get_default_stage_id(self):
""" Gives default stage_id """
project_id = self.env.context.get('default_project_id')
if not project_id:
return False
return self.stage_find(project_id, [('fold', '=', False)])
@api.model
def _default_company_id(self):
if self._context.get('default_project_id'):
return self.env['project.project'].browse(self._context['default_project_id']).company_id
return self.env.company
@api.model
def _read_group_stage_ids(self, stages, domain, order):
search_domain = [('id', 'in', stages.ids)]
if 'default_project_id' in self.env.context:
search_domain = ['|', ('project_ids', '=', self.env.context['default_project_id'])] + search_domain
stage_ids = stages._search(search_domain, order=order, access_rights_uid=SUPERUSER_ID)
return stages.browse(stage_ids)
active = fields.Boolean(default=True)
name = fields.Char(string='Title', tracking=True, required=True, index=True)
description = fields.Html(string='Description')
priority = fields.Selection([
('0', 'Normal'),
('1', 'Important'),
], default='0', index=True, string="Priority")
sequence = fields.Integer(string='Sequence', index=True, default=10,
help="Gives the sequence order when displaying a list of tasks.")
stage_id = fields.Many2one('project.task.type', string='Stage', ondelete='restrict', tracking=True, index=True,
default=_get_default_stage_id, group_expand='_read_group_stage_ids',
domain="[('project_ids', '=', project_id)]", copy=False)
tag_ids = fields.Many2many('project.tags', string='Tags')
kanban_state = fields.Selection([
('normal', 'Grey'),
('done', 'Green'),
('blocked', 'Red')], string='Kanban State',
copy=False, default='normal', required=True)
kanban_state_label = fields.Char(compute='_compute_kanban_state_label', string='Kanban State Label', tracking=True)
create_date = fields.Datetime("Created On", readonly=True, index=True)
write_date = fields.Datetime("Last Updated On", readonly=True, index=True)
date_end = fields.Datetime(string='Ending Date', index=True, copy=False)
date_assign = fields.Datetime(string='Assigning Date', index=True, copy=False, readonly=True)
date_deadline = fields.Date(string='Deadline', index=True, copy=False, tracking=True)
date_deadline_formatted = fields.Char(compute='_compute_date_deadline_formatted')
date_last_stage_update = fields.Datetime(string='Last Stage Update',
index=True,
copy=False,
readonly=True)
project_id = fields.Many2one('project.project', string='Project', default=lambda self: self.env.context.get('default_project_id'),
index=True, tracking=True, check_company=True, change_default=True)
planned_hours = fields.Float("Planned Hours", help='It is the time planned to achieve the task. If this document has sub-tasks, it means the time needed to achieve this tasks and its childs.',tracking=True)
subtask_planned_hours = fields.Float("Subtasks", compute='_compute_subtask_planned_hours', help="Computed using sum of hours planned of all subtasks created from main task. Usually these hours are less or equal to the Planned Hours (of main task).")
user_id = fields.Many2one('res.users',
string='Assigned to',
default=lambda self: self.env.uid,
index=True, tracking=True)
partner_id = fields.Many2one('res.partner',
string='Customer',
default=lambda self: self._get_default_partner(),
domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
partner_city = fields.Char(related='partner_id.city', readonly=False)
manager_id = fields.Many2one('res.users', string='Project Manager', related='project_id.user_id', readonly=True, related_sudo=False)
company_id = fields.Many2one('res.company', string='Company', required=True, default=_default_company_id)
color = fields.Integer(string='Color Index')
user_email = fields.Char(related='user_id.email', string='User Email', readonly=True, related_sudo=False)
attachment_ids = fields.One2many('ir.attachment', compute='_compute_attachment_ids', string="Main Attachments",
help="Attachment that don't come from message.")
# In the domain of displayed_image_id, we couln't use attachment_ids because a one2many is represented as a list of commands so we used res_model & res_id
displayed_image_id = fields.Many2one('ir.attachment', domain="[('res_model', '=', 'project.task'), ('res_id', '=', id), ('mimetype', 'ilike', 'image')]", string='Cover Image')
legend_blocked = fields.Char(related='stage_id.legend_blocked', string='Kanban Blocked Explanation', readonly=True, related_sudo=False)
legend_done = fields.Char(related='stage_id.legend_done', string='Kanban Valid Explanation', readonly=True, related_sudo=False)
legend_normal = fields.Char(related='stage_id.legend_normal', string='Kanban Ongoing Explanation', readonly=True, related_sudo=False)
parent_id = fields.Many2one('project.task', string='Parent Task', index=True)
child_ids = fields.One2many('project.task', 'parent_id', string="Sub-tasks", context={'active_test': False})
subtask_project_id = fields.Many2one('project.project', related="project_id.subtask_project_id", string='Sub-task Project', readonly=True)
subtask_count = fields.Integer("Sub-task count", compute='_compute_subtask_count')
email_from = fields.Char(string='Email', help="These people will receive email.", index=True)
# Computed field about working time elapsed between record creation and assignation/closing.
working_hours_open = fields.Float(compute='_compute_elapsed', string='Working hours to assign', store=True, group_operator="avg")
working_hours_close = fields.Float(compute='_compute_elapsed', string='Working hours to close', store=True, group_operator="avg")
working_days_open = fields.Float(compute='_compute_elapsed', string='Working days to assign', store=True, group_operator="avg")
working_days_close = fields.Float(compute='_compute_elapsed', string='Working days to close', store=True, group_operator="avg")
# customer portal: include comment and incoming emails in communication history
website_message_ids = fields.One2many(domain=lambda self: [('model', '=', self._name), ('message_type', 'in', ['email', 'comment'])])
@api.depends('date_deadline')
def _compute_date_deadline_formatted(self):
for task in self:
task.date_deadline_formatted = format_date(self.env, task.date_deadline) if task.date_deadline else None
def _compute_attachment_ids(self):
for task in self:
attachment_ids = self.env['ir.attachment'].search([('res_id', '=', task.id), ('res_model', '=', 'project.task')]).ids
message_attachment_ids = task.mapped('message_ids.attachment_ids').ids # from mail_thread
task.attachment_ids = [(6, 0, list(set(attachment_ids) - set(message_attachment_ids)))]
@api.depends('create_date', 'date_end', 'date_assign')
def _compute_elapsed(self):
task_linked_to_calendar = self.filtered(
lambda task: task.project_id.resource_calendar_id and task.create_date
)
for task in task_linked_to_calendar:
dt_create_date = fields.Datetime.from_string(task.create_date)
if task.date_assign:
dt_date_assign = fields.Datetime.from_string(task.date_assign)
duration_data = task.project_id.resource_calendar_id.get_work_duration_data(dt_create_date, dt_date_assign, compute_leaves=True)
task.working_hours_open = duration_data['hours']
task.working_days_open = duration_data['days']
else:
task.working_hours_open = 0.0
task.working_days_open = 0.0
if task.date_end:
dt_date_end = fields.Datetime.from_string(task.date_end)
duration_data = task.project_id.resource_calendar_id.get_work_duration_data(dt_create_date, dt_date_end, compute_leaves=True)
task.working_hours_close = duration_data['hours']
task.working_days_close = duration_data['days']
else:
task.working_hours_close = 0.0
task.working_days_close = 0.0
(self - task_linked_to_calendar).update(dict.fromkeys(
['working_hours_open', 'working_hours_close', 'working_days_open', 'working_days_close'], 0.0))
@api.depends('stage_id', 'kanban_state')
def _compute_kanban_state_label(self):
for task in self:
if task.kanban_state == 'normal':
task.kanban_state_label = task.legend_normal
elif task.kanban_state == 'blocked':
task.kanban_state_label = task.legend_blocked
else:
task.kanban_state_label = task.legend_done
def _compute_access_url(self):
super(Task, self)._compute_access_url()
for task in self:
task.access_url = '/my/task/%s' % task.id
def _compute_access_warning(self):
super(Task, self)._compute_access_warning()
for task in self.filtered(lambda x: x.project_id.privacy_visibility != 'portal'):
task.access_warning = _(
"The task cannot be shared with the recipient(s) because the privacy of the project is too restricted. Set the privacy of the project to 'Visible by following customers' in order to make it accessible by the recipient(s).")
@api.depends('child_ids.planned_hours')
def _compute_subtask_planned_hours(self):
for task in self:
task.subtask_planned_hours = sum(task.child_ids.mapped('planned_hours'))
@api.depends('child_ids')
def _compute_subtask_count(self):
""" Note: since we accept only one level subtask, we can use a read_group here """
task_data = self.env['project.task'].read_group([('parent_id', 'in', self.ids)], ['parent_id'], ['parent_id'])
mapping = dict((data['parent_id'][0], data['parent_id_count']) for data in task_data)
for task in self:
task.subtask_count = mapping.get(task.id, 0)
@api.onchange('partner_id')
def _onchange_partner_id(self):
self.email_from = self.partner_id.email
@api.onchange('parent_id')
def _onchange_parent_id(self):
if self.parent_id:
for field_name, value in self._subtask_values_from_parent(self.parent_id.id).items():
if not self[field_name]:
self[field_name] = value
@api.onchange('project_id')
def _onchange_project(self):
if self.project_id:
# find partner
if self.project_id.partner_id:
self.partner_id = self.project_id.partner_id
# find stage
if self.project_id not in self.stage_id.project_ids:
self.stage_id = self.stage_find(self.project_id.id, [('fold', '=', False)])
# keep multi company consistency
self.company_id = self.project_id.company_id
else:
self.stage_id = False
@api.constrains('parent_id', 'child_ids')
def _check_subtask_level(self):
for task in self:
if task.parent_id and task.child_ids:
raise ValidationError(_('Task %s cannot have several subtask levels.' % (task.name,)))
@api.returns('self', lambda value: value.id)
def copy(self, default=None):
if default is None:
default = {}
if not default.get('name'):
default['name'] = _("%s (copy)") % self.name
return super(Task, self).copy(default)
@api.constrains('parent_id')
def _check_parent_id(self):
for task in self:
if not task._check_recursion():
raise ValidationError(_('Error! You cannot create recursive hierarchy of task(s).'))
@api.model
def get_empty_list_help(self, help):
tname = _("task")
project_id = self.env.context.get('default_project_id', False)
if project_id:
name = self.env['project.project'].browse(project_id).label_tasks
if name: tname = name.lower()
self = self.with_context(
empty_list_help_id=self.env.context.get('default_project_id'),
empty_list_help_model='project.project',
empty_list_help_document_name=tname,
)
return super(Task, self).get_empty_list_help(help)
# ----------------------------------------
# Case management
# ----------------------------------------
def stage_find(self, section_id, domain=[], order='sequence'):
""" Override of the base.stage method
Parameter of the stage search taken from the lead:
- section_id: if set, stages must belong to this section or
be a default stage; if not set, stages must be default
stages
"""
# collect all section_ids
section_ids = []
if section_id:
section_ids.append(section_id)
section_ids.extend(self.mapped('project_id').ids)
search_domain = []
if section_ids:
search_domain = [('|')] * (len(section_ids) - 1)
for section_id in section_ids:
search_domain.append(('project_ids', '=', section_id))
search_domain += list(domain)
# perform search, return the first found
return self.env['project.task.type'].search(search_domain, order=order, limit=1).id
# ------------------------------------------------
# CRUD overrides
# ------------------------------------------------
@api.model
def create(self, vals):
# context: no_log, because subtype already handle this
context = dict(self.env.context)
# for default stage
if vals.get('project_id') and not context.get('default_project_id'):
context['default_project_id'] = vals.get('project_id')
# user_id change: update date_assign
if vals.get('user_id'):
vals['date_assign'] = fields.Datetime.now()
# Stage change: Update date_end if folded stage and date_last_stage_update
if vals.get('stage_id'):
vals.update(self.update_date_end(vals['stage_id']))
vals['date_last_stage_update'] = fields.Datetime.now()
# substask default values
if vals.get('parent_id'):
for fname, value in self._subtask_values_from_parent(vals['parent_id']).items():
if fname not in vals:
vals[fname] = value
task = super(Task, self.with_context(context)).create(vals)
return task
def write(self, vals):
now = fields.Datetime.now()
# stage change: update date_last_stage_update
if 'stage_id' in vals:
vals.update(self.update_date_end(vals['stage_id']))
vals['date_last_stage_update'] = now
# reset kanban state when changing stage
if 'kanban_state' not in vals:
vals['kanban_state'] = 'normal'
# user_id change: update date_assign
if vals.get('user_id') and 'date_assign' not in vals:
vals['date_assign'] = now
result = super(Task, self).write(vals)
# rating on stage
if 'stage_id' in vals and vals.get('stage_id'):
self.filtered(lambda x: x.project_id.rating_status == 'stage')._send_task_rating_mail(force_send=True)
return result
def update_date_end(self, stage_id):
project_task_type = self.env['project.task.type'].browse(stage_id)
if project_task_type.fold:
return {'date_end': fields.Datetime.now()}
return {'date_end': False}
# ---------------------------------------------------
# Subtasks
# ---------------------------------------------------
def _subtask_default_fields(self):
""" Return the list of field name for default value when creating a subtask """
return ['partner_id', 'email_from']
def _subtask_values_from_parent(self, parent_id):
""" Get values for substask implied field of the given"""
result = {}
parent_task = self.env['project.task'].browse(parent_id)
for field_name in self._subtask_default_fields():
result[field_name] = parent_task[field_name]
# special case for the subtask default project
result['project_id'] = parent_task.project_id.subtask_project_id
return self._convert_to_write(result)
# ---------------------------------------------------
# Mail gateway
# ---------------------------------------------------
def _track_template(self, changes):
res = super(Task, self)._track_template(changes)
test_task = self[0]
if 'stage_id' in changes and test_task.stage_id.mail_template_id:
res['stage_id'] = (test_task.stage_id.mail_template_id, {
'auto_delete_message': True,
'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
'email_layout_xmlid': 'mail.mail_notification_light'
})
return res
def _creation_subtype(self):
return self.env.ref('project.mt_task_new')
def _track_subtype(self, init_values):
self.ensure_one()
if 'kanban_state_label' in init_values and self.kanban_state == 'blocked':
return self.env.ref('project.mt_task_blocked')
elif 'kanban_state_label' in init_values and self.kanban_state == 'done':
return self.env.ref('project.mt_task_ready')
elif 'stage_id' in init_values:
return self.env.ref('project.mt_task_stage')
return super(Task, self)._track_subtype(init_values)
def _notify_get_groups(self):
""" Handle project users and managers recipients that can assign
tasks and create new one directly from notification emails. Also give
access button to portal users and portal customers. If they are notified
they should probably have access to the document. """
groups = super(Task, self)._notify_get_groups()
self.ensure_one()
project_user_group_id = self.env.ref('project.group_project_user').id
new_group = (
'group_project_user',
lambda pdata: pdata['type'] == 'user' and project_user_group_id in pdata['groups'],
{},
)
if not self.user_id and not self.stage_id.fold:
take_action = self._notify_get_action_link('assign')
project_actions = [{'url': take_action, 'title': _('I take it')}]
new_group[2]['actions'] = project_actions
groups = [new_group] + groups
for group_name, group_method, group_data in groups:
if group_name != 'customer':
group_data['has_button_access'] = True
return groups
def _notify_get_reply_to(self, default=None, records=None, company=None, doc_names=None):
""" Override to set alias of tasks to their project if any. """
aliases = self.sudo().mapped('project_id')._notify_get_reply_to(default=default, records=None, company=company, doc_names=None)
res = {task.id: aliases.get(task.project_id.id) for task in self}
leftover = self.filtered(lambda rec: not rec.project_id)
if leftover:
res.update(super(Task, leftover)._notify_get_reply_to(default=default, records=None, company=company, doc_names=doc_names))
return res
def email_split(self, msg):
email_list = tools.email_split((msg.get('to') or '') + ',' + (msg.get('cc') or ''))
# check left-part is not already an alias
aliases = self.mapped('project_id.alias_name')
return [x for x in email_list if x.split('@')[0] not in aliases]
@api.model
def message_new(self, msg, custom_values=None):
""" Overrides mail_thread message_new that is called by the mailgateway
through message_process.
This override updates the document according to the email.
"""
# remove default author when going through the mail gateway. Indeed we
# do not want to explicitly set user_id to False; however we do not
# want the gateway user to be responsible if no other responsible is
# found.
create_context = dict(self.env.context or {})
create_context['default_user_id'] = False
if custom_values is None:
custom_values = {}
defaults = {
'name': msg.get('subject') or _("No Subject"),
'email_from': msg.get('from'),
'planned_hours': 0.0,
'partner_id': msg.get('author_id')
}
defaults.update(custom_values)
task = super(Task, self.with_context(create_context)).message_new(msg, custom_values=defaults)
email_list = task.email_split(msg)
partner_ids = [p.id for p in self.env['mail.thread']._mail_find_partner_from_emails(email_list, records=task, force_create=False) if p]
task.message_subscribe(partner_ids)
return task
def message_update(self, msg, update_vals=None):
""" Override to update the task according to the email. """
email_list = self.email_split(msg)
partner_ids = [p.id for p in self.env['mail.thread']._mail_find_partner_from_emails(email_list, records=self, force_create=False) if p]
self.message_subscribe(partner_ids)
return super(Task, self).message_update(msg, update_vals=update_vals)
def _message_get_suggested_recipients(self):
recipients = super(Task, self)._message_get_suggested_recipients()
for task in self:
if task.partner_id:
reason = _('Customer Email') if task.partner_id.email else _('Customer')
task._message_add_suggested_recipient(recipients, partner=task.partner_id, reason=reason)
elif task.email_from:
task._message_add_suggested_recipient(recipients, email=task.email_from, reason=_('Customer Email'))
return recipients
def _notify_email_header_dict(self):
headers = super(Task, self)._notify_email_header_dict()
if self.project_id:
current_objects = [h for h in headers.get('X-COffice-Objects', '').split(',') if h]
current_objects.insert(0, 'project.project-%s, ' % self.project_id.id)
headers['X-COffice-Objects'] = ','.join(current_objects)
if self.tag_ids:
headers['X-COffice-Tags'] = ','.join(self.tag_ids.mapped('name'))
return headers
def _message_post_after_hook(self, message, msg_vals):
if self.email_from and not self.partner_id:
# we consider that posting a message with a specified recipient (not a follower, a specific one)
# on a document without customer means that it was created through the chatter using
# suggested recipients. This heuristic allows to avoid ugly hacks in JS.
new_partner = message.partner_ids.filtered(lambda partner: partner.email == self.email_from)
if new_partner:
self.search([
('partner_id', '=', False),
('email_from', '=', new_partner.email),
('stage_id.fold', '=', False)]).write({'partner_id': new_partner.id})
return super(Task, self)._message_post_after_hook(message, msg_vals)
def action_assign_to_me(self):
self.write({'user_id': self.env.user.id})
def action_open_parent_task(self):
return {
'name': _('Parent Task'),
'view_mode': 'form',
'res_model': 'project.task',
'res_id': self.parent_id.id,
'type': 'ir.actions.act_window',
'context': dict(self._context, create=False)
}
def action_subtask(self):
action = self.env.ref('project.project_task_action_sub_task').read()[0]
# only display subtasks of current task
action['domain'] = [('id', 'child_of', self.id), ('id', '!=', self.id)]
# update context, with all default values as 'quick_create' does not contains all field in its view
if self._context.get('default_project_id'):
default_project = self.env['project.project'].browse(self.env.context['default_project_id'])
else:
default_project = self.project_id.subtask_project_id or self.project_id
ctx = dict(self.env.context)
ctx.update({
'default_name': self.env.context.get('name', self.name) + ':',
'default_parent_id': self.id, # will give default subtask field in `default_get`
'default_company_id': default_project.company_id.id if default_project else self.env.company.id,
'search_default_parent_id': self.id,
})
parent_values = self._subtask_values_from_parent(self.id)
for fname, value in parent_values.items():
if 'default_' + fname not in ctx:
ctx['default_' + fname] = value
action['context'] = ctx
return action
# ---------------------------------------------------
# Rating business
# ---------------------------------------------------
def _send_task_rating_mail(self, force_send=False):
for task in self:
rating_template = task.stage_id.rating_template_id
if rating_template:
task.rating_send_request(rating_template, lang=task.partner_id.lang, force_send=force_send)
def rating_get_partner_id(self):
res = super(Task, self).rating_get_partner_id()
if not res and self.project_id.partner_id:
return self.project_id.partner_id
return res
def rating_apply(self, rate, token=None, feedback=None, subtype=None):
return super(Task, self).rating_apply(rate, token=token, feedback=feedback, subtype="project.mt_task_rating")
def _rating_get_parent_field_name(self):
return 'project_id'
class ActivityReport(models.Model):
""" CRM Lead Analysis """
_name = "crm.activity.report"
_auto = False
_description = "CRM Activity Analysis"
_rec_name = 'id'
date = fields.Datetime('Completion Date', readonly=True)
lead_create_date = fields.Datetime('Creation Date', readonly=True)
date_conversion = fields.Datetime('Conversion Date', readonly=True)
date_deadline = fields.Date('Expected Closing', readonly=True)
date_closed = fields.Datetime('Closed Date', readonly=True)
author_id = fields.Many2one('res.partner', 'Assigned To', readonly=True)
user_id = fields.Many2one('res.users', 'Salesperson', readonly=True)
team_id = fields.Many2one('crm.team', 'Sales Team', readonly=True)
lead_id = fields.Many2one('crm.lead', "Opportunity", readonly=True)
body = fields.Html('Activity Description', readonly=True)
subtype_id = fields.Many2one('mail.message.subtype', 'Subtype', readonly=True)
mail_activity_type_id = fields.Many2one('mail.activity.type', 'Activity Type', readonly=True)
country_id = fields.Many2one('res.country', 'Country', readonly=True)
company_id = fields.Many2one('res.company', 'Company', readonly=True)
stage_id = fields.Many2one('crm.stage', 'Stage', readonly=True)
partner_id = fields.Many2one('res.partner', 'Customer', readonly=True)
lead_type = fields.Selection(
string='Type',
selection=[('lead', 'Lead'), ('opportunity', 'Opportunity')],
help="Type is used to separate Leads and Opportunities")
active = fields.Boolean('Active', readonly=True)
def _select(self):
return """
SELECT
m.id,
l.create_date AS lead_create_date,
l.date_conversion,
l.date_deadline,
l.date_closed,
m.subtype_id,
m.mail_activity_type_id,
m.author_id,
m.date,
m.body,
l.id as lead_id,
l.user_id,
l.team_id,
l.country_id,
l.company_id,
l.stage_id,
l.partner_id,
l.type as lead_type,
l.active
"""
def _from(self):
return """
FROM mail_message AS m
"""
def _join(self):
return """
JOIN crm_lead AS l ON m.res_id = l.id
"""
def _where(self):
disccusion_subtype = self.env.ref('mail.mt_comment')
return """
WHERE
m.model = 'crm.lead' AND (m.mail_activity_type_id IS NOT NULL OR m.subtype_id = %s)
""" % (disccusion_subtype.id,)
def init(self):
tools.drop_view_if_exists(self._cr, self._table)
self._cr.execute("""
CREATE OR REPLACE VIEW %s AS (
%s
%s
%s
%s
)
""" % (self._table, self._select(), self._from(), self._join(), self._where())
)
class Note(models.Model):
_name = 'note.note'
_inherit = ['mail.thread', 'mail.activity.mixin']
_description = "Note"
_order = 'sequence'
def _get_default_stage_id(self):
return self.env['note.stage'].search([('user_id', '=', self.env.uid)],
limit=1)
name = fields.Text(compute='_compute_name',
string='Note Summary',
store=True)
user_id = fields.Many2one('res.users',
string='Owner',
default=lambda self: self.env.uid)
memo = fields.Html('Note Content')
sequence = fields.Integer('Sequence')
stage_id = fields.Many2one('note.stage',
compute='_compute_stage_id',
inverse='_inverse_stage_id',
string='Stage',
default=_get_default_stage_id)
stage_ids = fields.Many2many('note.stage',
'note_stage_rel',
'note_id',
'stage_id',
string='Stages of Users',
default=_get_default_stage_id)
open = fields.Boolean(string='Active', default=True)
date_done = fields.Date('Date done')
color = fields.Integer(string='Color Index')
tag_ids = fields.Many2many('note.tag',
'note_tags_rel',
'note_id',
'tag_id',
string='Tags')
@api.depends('memo')
def _compute_name(self):
""" Read the first line of the memo to determine the note name """
for note in self:
text = html2plaintext(note.memo) if note.memo else ''
note.name = text.strip().replace('*', '').split("\n")[0]
def _compute_stage_id(self):
first_user_stage = self.env['note.stage'].search(
[('user_id', '=', self.env.uid)], limit=1)
for note in self:
for stage in note.stage_ids.filtered(
lambda stage: stage.user_id == self.env.user):
note.stage_id = stage
# note without user's stage
if not note.stage_id:
note.stage_id = first_user_stage
def _inverse_stage_id(self):
for note in self.filtered('stage_id'):
note.stage_ids = note.stage_id + note.stage_ids.filtered(
lambda stage: stage.user_id != self.env.user)
@api.model
def name_create(self, name):
return self.create({'memo': name}).name_get()[0]
@api.model
def read_group(self,
domain,
fields,
groupby,
offset=0,
limit=None,
orderby=False,
lazy=True):
if groupby and groupby[0] == "stage_id":
stages = self.env['note.stage'].search([('user_id', '=',
self.env.uid)])
if stages: # if the user has some stages
result = [{ # notes by stage for stages user
'__context': {'group_by': groupby[1:]},
'__domain': domain + [('stage_ids.id', '=', stage.id)],
'stage_id': (stage.id, stage.name),
'stage_id_count': self.search_count(domain + [('stage_ids', '=', stage.id)]),
'__fold': stage.fold,
} for stage in stages]
# note without user's stage
nb_notes_ws = self.search_count(domain +
[('stage_ids', 'not in',
stages.ids)])
if nb_notes_ws:
# add note to the first column if it's the first stage
dom_not_in = ('stage_ids', 'not in', stages.ids)
if result and result[0]['stage_id'][0] == stages[0].id:
dom_in = result[0]['__domain'].pop()
result[0]['__domain'] = domain + [
'|', dom_in, dom_not_in
]
result[0]['stage_id_count'] += nb_notes_ws
else:
# add the first stage column
result = [{
'__context': {
'group_by': groupby[1:]
},
'__domain': domain + [dom_not_in],
'stage_id': (stages[0].id, stages[0].name),
'stage_id_count': nb_notes_ws,
'__fold': stages[0].name,
}] + result
else: # if stage_ids is empty, get note without user's stage
nb_notes_ws = self.search_count(domain)
if nb_notes_ws:
result = [{ # notes for unknown stage
'__context': {
'group_by': groupby[1:]
},
'__domain': domain,
'stage_id': False,
'stage_id_count': nb_notes_ws
}]
else:
result = []
return result
return super(Note, self).read_group(domain,
fields,
groupby,
offset=offset,
limit=limit,
orderby=orderby,
lazy=lazy)
def action_close(self):
return self.write({'open': False, 'date_done': fields.date.today()})
def action_open(self):
return self.write({'open': True})
class StockRule(models.Model):
""" A rule describe what a procurement should do; produce, buy, move, ... """
_name = 'stock.rule'
_description = "Stock Rule"
_order = "sequence, id"
_check_company_auto = True
name = fields.Char(
'Name',
required=True,
translate=True,
help="This field will fill the packing origin and the name of its moves"
)
active = fields.Boolean(
'Active',
default=True,
help=
"If unchecked, it will allow you to hide the rule without removing it."
)
group_propagation_option = fields.Selection(
[('none', 'Leave Empty'), ('propagate', 'Propagate'),
('fixed', 'Fixed')],
string="Propagation of Procurement Group",
default='propagate')
group_id = fields.Many2one('procurement.group', 'Fixed Procurement Group')
action = fields.Selection(selection=[('pull', 'Pull From'),
('push', 'Push To'),
('pull_push', 'Pull & Push')],
string='Action',
required=True)
sequence = fields.Integer('Sequence', default=20)
company_id = fields.Many2one('res.company',
'Company',
default=lambda self: self.env.company)
location_id = fields.Many2one('stock.location',
'Destination Location',
required=True,
check_company=True)
location_src_id = fields.Many2one('stock.location',
'Source Location',
check_company=True)
route_id = fields.Many2one('stock.location.route',
'Route',
required=True,
ondelete='cascade')
procure_method = fields.Selection(
[('make_to_stock', 'Take From Stock'),
('make_to_order', 'Trigger Another Rule'),
('mts_else_mto',
'Take From Stock, if unavailable, Trigger Another Rule')],
string='Supply Method',
default='make_to_stock',
required=True,
help=
"Take From Stock: the products will be taken from the available stock of the source location.\n"
"Trigger Another Rule: the system will try to find a stock rule to bring the products in the source location. The available stock will be ignored.\n"
"Take From Stock, if Unavailable, Trigger Another Rule: the products will be taken from the available stock of the source location."
"If there is no stock available, the system will try to find a rule to bring the products in the source location."
)
route_sequence = fields.Integer('Route Sequence',
related='route_id.sequence',
store=True,
readonly=False,
compute_sudo=True)
picking_type_id = fields.Many2one('stock.picking.type',
'Operation Type',
required=True,
check_company=True)
delay = fields.Integer(
'Delay',
default=0,
help=
"The expected date of the created transfer will be computed based on this delay."
)
partner_address_id = fields.Many2one(
'res.partner',
'Partner Address',
check_company=True,
help="Address where goods should be delivered. Optional.")
propagate_cancel = fields.Boolean(
'Cancel Next Move',
default=False,
help=
"When ticked, if the move created by this rule is cancelled, the next move will be cancelled too."
)
warehouse_id = fields.Many2one('stock.warehouse',
'Warehouse',
check_company=True)
propagate_warehouse_id = fields.Many2one(
'stock.warehouse',
'Warehouse to Propagate',
help=
"The warehouse to propagate on the created move/procurement, which can be different of the warehouse this rule is for (e.g for resupplying rules from another warehouse)"
)
auto = fields.Selection(
[('manual', 'Manual Operation'),
('transparent', 'Automatic No Step Added')],
string='Automatic Move',
default='manual',
index=True,
required=True,
help=
"The 'Manual Operation' value will create a stock move after the current one. "
"With 'Automatic No Step Added', the location is replaced in the original move."
)
rule_message = fields.Html(compute='_compute_action_message')
propagate_date = fields.Boolean(
string="Propagate Rescheduling",
default=True,
help='The rescheduling is propagated to the next move.')
propagate_date_minimum_delta = fields.Integer(
string='Reschedule if Higher Than',
help='The change must be higher than this value to be propagated',
default=1)
delay_alert = fields.Boolean(
'Alert if Delay',
help=
'Log an exception on the picking if this move has to be delayed (due to a change in the previous move scheduled date).',
)
@api.onchange('picking_type_id')
def _onchange_picking_type(self):
""" Modify locations to the default picking type's locations source and
destination.
Enable the delay alert if the picking type is a delivery
"""
self.location_src_id = self.picking_type_id.default_location_src_id.id
self.location_id = self.picking_type_id.default_location_dest_id.id
if self.picking_type_id.code == 'outgoing':
self.delay_alert = True
@api.onchange('route_id', 'company_id')
def _onchange_route(self):
""" Ensure that the rule's company is the same than the route's company. """
if self.route_id.company_id:
self.company_id = self.route_id.company_id
if self.picking_type_id.warehouse_id.company_id != self.route_id.company_id:
self.picking_type_id = False
domain = {
'company_id':
self.route_id.company_id
and [('id', '=', self.route_id.company_id.id)] or []
}
return {'domain': domain}
def _get_message_values(self):
""" Return the source, destination and picking_type applied on a stock
rule. The purpose of this function is to avoid code duplication in
_get_message_dict functions since it often requires those data.
"""
source = self.location_src_id and self.location_src_id.display_name or _(
'Source Location')
destination = self.location_id and self.location_id.display_name or _(
'Destination Location')
operation = self.picking_type_id and self.picking_type_id.name or _(
'Operation Type')
return source, destination, operation
def _get_message_dict(self):
""" Return a dict with the different possible message used for the
rule message. It should return one message for each stock.rule action
(except push and pull). This function is override in mrp and
purchase_stock in order to complete the dictionary.
"""
message_dict = {}
source, destination, operation = self._get_message_values()
if self.action in ('push', 'pull', 'pull_push'):
suffix = ""
if self.procure_method == 'make_to_order' and self.location_src_id:
suffix = _(
"<br>A need is created in <b>%s</b> and a rule will be triggered to fulfill it."
) % (source)
if self.procure_method == 'mts_else_mto' and self.location_src_id:
suffix = _(
"<br>If the products are not available in <b>%s</b>, a rule will be triggered to bring products in this location."
) % source
message_dict = {
'pull':
_('When products are needed in <b>%s</b>, <br/> <b>%s</b> are created from <b>%s</b> to fulfill the need.'
) % (destination, operation, source) + suffix,
'push':
_('When products arrive in <b>%s</b>, <br/> <b>%s</b> are created to send them in <b>%s</b>.'
) % (source, operation, destination)
}
return message_dict
@api.depends('action', 'location_id', 'location_src_id', 'picking_type_id',
'procure_method')
def _compute_action_message(self):
""" Generate dynamicaly a message that describe the rule purpose to the
end user.
"""
action_rules = self.filtered(lambda rule: rule.action)
for rule in action_rules:
message_dict = rule._get_message_dict()
message = message_dict.get(
rule.action) and message_dict[rule.action] or ""
if rule.action == 'pull_push':
message = message_dict['pull'] + "<br/><br/>" + message_dict[
'push']
rule.rule_message = message
(self - action_rules).rule_message = None
def _run_push(self, move):
""" Apply a push rule on a move.
If the rule is 'no step added' it will modify the destination location
on the move.
If the rule is 'manual operation' it will generate a new move in order
to complete the section define by the rule.
Care this function is not call by method run. It is called explicitely
in stock_move.py inside the method _push_apply
"""
new_date = fields.Datetime.to_string(move.date_expected +
relativedelta(days=self.delay))
if self.auto == 'transparent':
move.write({
'date': new_date,
'date_expected': new_date,
'location_dest_id': self.location_id.id
})
# avoid looping if a push rule is not well configured; otherwise call again push_apply to see if a next step is defined
if self.location_id != move.location_dest_id:
# TDE FIXME: should probably be done in the move model IMO
move._push_apply()
else:
new_move_vals = self._push_prepare_move_copy_values(move, new_date)
new_move = move.sudo().copy(new_move_vals)
move.write({'move_dest_ids': [(4, new_move.id)]})
new_move._action_confirm()
def _push_prepare_move_copy_values(self, move_to_copy, new_date):
company_id = self.company_id.id
if not company_id:
company_id = self.sudo().warehouse_id and self.sudo(
).warehouse_id.company_id.id or self.sudo(
).picking_type_id.warehouse_id.company_id.id
new_move_vals = {
'origin': move_to_copy.origin or move_to_copy.picking_id.name
or "/",
'location_id': move_to_copy.location_dest_id.id,
'location_dest_id': self.location_id.id,
'date': new_date,
'date_expected': new_date,
'company_id': company_id,
'picking_id': False,
'picking_type_id': self.picking_type_id.id,
'propagate_cancel': self.propagate_cancel,
'warehouse_id': self.warehouse_id.id,
'delay_alert': self.delay_alert
}
return new_move_vals
@api.model
def _run_pull(self, procurements):
moves_values_by_company = defaultdict(list)
mtso_products_by_locations = defaultdict(list)
# To handle the `mts_else_mto` procure method, we do a preliminary loop to
# isolate the products we would need to read the forecasted quantity,
# in order to to batch the read. We also make a sanitary check on the
# `location_src_id` field.
for procurement, rule in procurements:
if not rule.location_src_id:
msg = _('No source location defined on stock rule: %s!') % (
rule.name, )
raise UserError(msg)
if rule.procure_method == 'mts_else_mto':
mtso_products_by_locations[rule.location_src_id].append(
procurement.product_id.id)
# Get the forecasted quantity for the `mts_else_mto` procurement.
forecasted_qties_by_loc = {}
for location, product_ids in mtso_products_by_locations.items():
products = self.env['product.product'].browse(
product_ids).with_context(location=location.id)
forecasted_qties_by_loc[location] = {
product.id: product.virtual_available
for product in products
}
# Prepare the move values, adapt the `procure_method` if needed.
for procurement, rule in procurements:
procure_method = rule.procure_method
if rule.procure_method == 'mts_else_mto':
qty_needed = procurement.product_uom._compute_quantity(
procurement.product_qty, procurement.product_id.uom_id)
qty_available = forecasted_qties_by_loc[rule.location_src_id][
procurement.product_id.id]
if float_compare(qty_needed,
qty_available,
precision_rounding=procurement.product_id.
uom_id.rounding) <= 0:
procure_method = 'make_to_stock'
forecasted_qties_by_loc[rule.location_src_id][
procurement.product_id.id] -= qty_needed
else:
procure_method = 'make_to_order'
move_values = rule._get_stock_move_values(*procurement)
move_values['procure_method'] = procure_method
moves_values_by_company[procurement.company_id.id].append(
move_values)
for company_id, moves_values in moves_values_by_company.items():
# create the move as SUPERUSER because the current user may not have the rights to do it (mto product launched by a sale for example)
moves = self.env['stock.move'].sudo().with_context(
force_company=company_id).create(moves_values)
# Since action_confirm launch following procurement_group we should activate it.
moves._action_confirm()
return True
def _get_custom_move_fields(self):
""" The purpose of this method is to be override in order to easily add
fields from procurement 'values' argument to move data.
"""
return []
def _get_stock_move_values(self, product_id, product_qty, product_uom,
location_id, name, origin, company_id, values):
''' Returns a dictionary of values that will be used to create a stock move from a procurement.
This function assumes that the given procurement has a rule (action == 'pull' or 'pull_push') set on it.
:param procurement: browse record
:rtype: dictionary
'''
group_id = False
if self.group_propagation_option == 'propagate':
group_id = values.get('group_id', False) and values['group_id'].id
elif self.group_propagation_option == 'fixed':
group_id = self.group_id.id
date_expected = fields.Datetime.to_string(
fields.Datetime.from_string(values['date_planned']) -
relativedelta(days=self.delay or 0))
# it is possible that we've already got some move done, so check for the done qty and create
# a new move with the correct qty
qty_left = product_qty
move_values = {
'name':
name[:2000],
'company_id':
self.company_id.id or self.location_src_id.company_id.id
or self.location_id.company_id.id or company_id.id,
'product_id':
product_id.id,
'product_uom':
product_uom.id,
'product_uom_qty':
qty_left,
'partner_id':
self.partner_address_id.id
or (values.get('group_id', False)
and values['group_id'].partner_id.id) or False,
'location_id':
self.location_src_id.id,
'location_dest_id':
location_id.id,
'move_dest_ids':
values.get('move_dest_ids', False)
and [(4, x.id) for x in values['move_dest_ids']] or [],
'rule_id':
self.id,
'procure_method':
self.procure_method,
'origin':
origin,
'picking_type_id':
self.picking_type_id.id,
'group_id':
group_id,
'route_ids': [(4, route.id)
for route in values.get('route_ids', [])],
'warehouse_id':
self.propagate_warehouse_id.id or self.warehouse_id.id,
'date':
date_expected,
'date_expected':
date_expected,
'propagate_cancel':
self.propagate_cancel,
'propagate_date':
self.propagate_date,
'propagate_date_minimum_delta':
self.propagate_date_minimum_delta,
'description_picking':
product_id._get_description(self.picking_type_id),
'priority':
values.get('priority', "1"),
'delay_alert':
self.delay_alert,
}
for field in self._get_custom_move_fields():
if field in values:
move_values[field] = values.get(field)
return move_values
def _log_next_activity(self, product_id, note):
existing_activity = self.env['mail.activity'].search([
('res_id', '=', product_id.product_tmpl_id.id),
('res_model_id', '=',
self.env.ref('product.model_product_template').id),
('note', '=', note)
])
if not existing_activity:
# If the user deleted warning activity type.
try:
activity_type_id = self.env.ref(
'mail.mail_activity_data_warning').id
except:
activity_type_id = False
self.env['mail.activity'].create({
'activity_type_id':
activity_type_id,
'note':
note,
'user_id':
product_id.responsible_id.id or SUPERUSER_ID,
'res_id':
product_id.product_tmpl_id.id,
'res_model_id':
self.env.ref('product.model_product_template').id,
})
class EventEvent(models.Model):
"""Event"""
_name = 'event.event'
_description = 'Event'
_inherit = ['mail.thread', 'mail.activity.mixin']
_order = 'date_begin'
name = fields.Char(
string='Event', translate=True, required=True,
readonly=False, states={'done': [('readonly', True)]})
active = fields.Boolean(default=True)
user_id = fields.Many2one(
'res.users', string='Responsible',
default=lambda self: self.env.user,
tracking=True,
readonly=False, states={'done': [('readonly', True)]})
company_id = fields.Many2one(
'res.company', string='Company', change_default=True,
default=lambda self: self.env.company,
required=False, readonly=False, states={'done': [('readonly', True)]})
organizer_id = fields.Many2one(
'res.partner', string='Organizer',
tracking=True,
default=lambda self: self.env.company.partner_id,
domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
event_type_id = fields.Many2one(
'event.type', string='Category',
readonly=False, states={'done': [('readonly', True)]})
color = fields.Integer('Kanban Color Index')
event_mail_ids = fields.One2many('event.mail', 'event_id', string='Mail Schedule', copy=True)
# Seats and computation
seats_max = fields.Integer(
string='Maximum Attendees Number',
readonly=True, states={'draft': [('readonly', False)], 'confirm': [('readonly', False)]},
help="For each event you can define a maximum registration of seats(number of attendees), above this numbers the registrations are not accepted.")
seats_availability = fields.Selection(
[('limited', 'Limited'), ('unlimited', 'Unlimited')],
'Maximum Attendees', required=True, default='unlimited')
seats_min = fields.Integer(
string='Minimum Attendees',
help="For each event you can define a minimum reserved seats (number of attendees), if it does not reach the mentioned registrations the event can not be confirmed (keep 0 to ignore this rule)")
seats_reserved = fields.Integer(
string='Reserved Seats',
store=True, readonly=True, compute='_compute_seats')
seats_available = fields.Integer(
string='Available Seats',
store=True, readonly=True, compute='_compute_seats')
seats_unconfirmed = fields.Integer(
string='Unconfirmed Seat Reservations',
store=True, readonly=True, compute='_compute_seats')
seats_used = fields.Integer(
string='Number of Participants',
store=True, readonly=True, compute='_compute_seats')
seats_expected = fields.Integer(
string='Number of Expected Attendees',
compute_sudo=True, readonly=True, compute='_compute_seats')
# Registration fields
registration_ids = fields.One2many(
'event.registration', 'event_id', string='Attendees',
readonly=False, states={'done': [('readonly', True)]})
# Date fields
date_tz = fields.Selection('_tz_get', string='Timezone', required=True, default=lambda self: self.env.user.tz or 'UTC')
date_begin = fields.Datetime(
string='Start Date', required=True,
tracking=True, states={'done': [('readonly', True)]})
date_end = fields.Datetime(
string='End Date', required=True,
tracking=True, states={'done': [('readonly', True)]})
date_begin_located = fields.Char(string='Start Date Located', compute='_compute_date_begin_tz')
date_end_located = fields.Char(string='End Date Located', compute='_compute_date_end_tz')
is_one_day = fields.Boolean(compute='_compute_field_is_one_day')
state = fields.Selection([
('draft', 'Unconfirmed'), ('cancel', 'Cancelled'),
('confirm', 'Confirmed'), ('done', 'Done')],
string='Status', default='draft', readonly=True, required=True, copy=False,
help="If event is created, the status is 'Draft'. If event is confirmed for the particular dates the status is set to 'Confirmed'. If the event is over, the status is set to 'Done'. If event is cancelled the status is set to 'Cancelled'.")
auto_confirm = fields.Boolean(string='Autoconfirm Registrations')
is_online = fields.Boolean('Online Event')
address_id = fields.Many2one(
'res.partner', string='Location',
default=lambda self: self.env.company.partner_id,
readonly=False, states={'done': [('readonly', True)]},
domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]",
tracking=True)
country_id = fields.Many2one('res.country', 'Country', related='address_id.country_id', store=True, readonly=False)
twitter_hashtag = fields.Char('Twitter Hashtag')
description = fields.Html(
string='Description', translate=html_translate, sanitize_attributes=False,
readonly=False, states={'done': [('readonly', True)]})
# badge fields
badge_front = fields.Html(string='Badge Front')
badge_back = fields.Html(string='Badge Back')
badge_innerleft = fields.Html(string='Badge Inner Left')
badge_innerright = fields.Html(string='Badge Inner Right')
event_logo = fields.Html(string='Event Logo')
@api.depends('seats_max', 'registration_ids.state')
def _compute_seats(self):
""" Determine reserved, available, reserved but unconfirmed and used seats. """
# initialize fields to 0
for event in self:
event.seats_unconfirmed = event.seats_reserved = event.seats_used = event.seats_available = 0
# aggregate registrations by event and by state
if self.ids:
state_field = {
'draft': 'seats_unconfirmed',
'open': 'seats_reserved',
'done': 'seats_used',
}
query = """ SELECT event_id, state, count(event_id)
FROM event_registration
WHERE event_id IN %s AND state IN ('draft', 'open', 'done')
GROUP BY event_id, state
"""
self.env['event.registration'].flush(['event_id', 'state'])
self._cr.execute(query, (tuple(self.ids),))
for event_id, state, num in self._cr.fetchall():
event = self.browse(event_id)
event[state_field[state]] += num
# compute seats_available
for event in self:
if event.seats_max > 0:
event.seats_available = event.seats_max - (event.seats_reserved + event.seats_used)
event.seats_expected = event.seats_unconfirmed + event.seats_reserved + event.seats_used
@api.model
def _tz_get(self):
return [(x, x) for x in pytz.all_timezones]
@api.depends('date_tz', 'date_begin')
def _compute_date_begin_tz(self):
for event in self:
if event.date_begin:
event.date_begin_located = format_datetime(
self.env, event.date_begin, tz=event.date_tz, dt_format='medium')
else:
event.date_begin_located = False
@api.depends('date_tz', 'date_end')
def _compute_date_end_tz(self):
for event in self:
if event.date_end:
event.date_end_located = format_datetime(
self.env, event.date_end, tz=event.date_tz, dt_format='medium')
else:
event.date_end_located = False
@api.depends('date_begin', 'date_end', 'date_tz')
def _compute_field_is_one_day(self):
for event in self:
# Need to localize because it could begin late and finish early in
# another timezone
event = event.with_context(tz=event.date_tz)
begin_tz = fields.Datetime.context_timestamp(event, event.date_begin)
end_tz = fields.Datetime.context_timestamp(event, event.date_end)
event.is_one_day = (begin_tz.date() == end_tz.date())
@api.onchange('is_online')
def _onchange_is_online(self):
if self.is_online:
self.address_id = False
@api.onchange('event_type_id')
def _onchange_type(self):
if self.event_type_id:
self.seats_min = self.event_type_id.default_registration_min
self.seats_max = self.event_type_id.default_registration_max
if self.event_type_id.default_registration_max:
self.seats_availability = 'limited'
if self.event_type_id.auto_confirm:
self.auto_confirm = self.event_type_id.auto_confirm
if self.event_type_id.use_hashtag:
self.twitter_hashtag = self.event_type_id.default_hashtag
if self.event_type_id.use_timezone:
self.date_tz = self.event_type_id.default_timezone
self.is_online = self.event_type_id.is_online
if self.event_type_id.event_type_mail_ids:
self.event_mail_ids = [(5, 0, 0)] + [
(0, 0, {
attribute_name: line[attribute_name]
for attribute_name in self.env['event.type.mail']._get_event_mail_fields_whitelist()
})
for line in self.event_type_id.event_type_mail_ids]
@api.constrains('seats_min', 'seats_max', 'seats_availability')
def _check_seats_min_max(self):
if any(event.seats_availability == 'limited' and event.seats_min > event.seats_max for event in self):
raise ValidationError(_('Maximum attendees number should be greater than minimum attendees number.'))
@api.constrains('seats_max', 'seats_available')
def _check_seats_limit(self):
if any(event.seats_availability == 'limited' and event.seats_max and event.seats_available < 0 for event in self):
raise ValidationError(_('No more available seats.'))
@api.constrains('date_begin', 'date_end')
def _check_closing_date(self):
for event in self:
if event.date_end < event.date_begin:
raise ValidationError(_('The closing date cannot be earlier than the beginning date.'))
@api.depends('name', 'date_begin', 'date_end')
def name_get(self):
result = []
for event in self:
date_begin = fields.Datetime.from_string(event.date_begin)
date_end = fields.Datetime.from_string(event.date_end)
dates = [fields.Date.to_string(fields.Datetime.context_timestamp(event, dt)) for dt in [date_begin, date_end] if dt]
dates = sorted(set(dates))
result.append((event.id, '%s (%s)' % (event.name, ' - '.join(dates))))
return result
@api.model
def create(self, vals):
res = super(EventEvent, self).create(vals)
if res.organizer_id:
res.message_subscribe([res.organizer_id.id])
if res.auto_confirm:
res.button_confirm()
return res
def write(self, vals):
res = super(EventEvent, self).write(vals)
if vals.get('organizer_id'):
self.message_subscribe([vals['organizer_id']])
return res
@api.returns('self', lambda value: value.id)
def copy(self, default=None):
self.ensure_one()
default = dict(default or {}, name=_("%s (copy)") % (self.name))
return super(EventEvent, self).copy(default)
def button_draft(self):
self.write({'state': 'draft'})
def button_cancel(self):
if any('done' in event.mapped('registration_ids.state') for event in self):
raise UserError(_("There are already attendees who attended this event. Please reset it to draft if you want to cancel this event."))
self.registration_ids.write({'state': 'cancel'})
self.state = 'cancel'
def button_done(self):
self.write({'state': 'done'})
def button_confirm(self):
self.write({'state': 'confirm'})
def mail_attendees(self, template_id, force_send=False, filter_func=lambda self: self.state != 'cancel'):
for event in self:
for attendee in event.registration_ids.filtered(filter_func):
self.env['mail.template'].browse(template_id).send_mail(attendee.id, force_send=force_send)
def _is_event_registrable(self):
return self.date_end > fields.Datetime.now()
def _get_ics_file(self):
""" Returns iCalendar file for the event invitation.
:returns a dict of .ics file content for each event
"""
result = {}
if not vobject:
return result
for event in self:
cal = vobject.iCalendar()
cal_event = cal.add('vevent')
cal_event.add('created').value = fields.Datetime.now().replace(tzinfo=pytz.timezone('UTC'))
cal_event.add('dtstart').value = fields.Datetime.from_string(event.date_begin).replace(tzinfo=pytz.timezone('UTC'))
cal_event.add('dtend').value = fields.Datetime.from_string(event.date_end).replace(tzinfo=pytz.timezone('UTC'))
cal_event.add('summary').value = event.name
if event.address_id:
cal_event.add('location').value = event.sudo().address_id.contact_address
result[event.id] = cal.serialize().encode('utf-8')
return result
class MassMailing(models.Model):
""" MassMailing models a wave of emails for a mass mailign campaign.
A mass mailing is an occurence of sending emails. """
_name = 'mailing.mailing'
_description = 'Mass Mailing'
_inherit = ['mail.thread', 'mail.activity.mixin']
# number of periods for tracking mail_mail statistics
_period_number = 6
_order = 'sent_date DESC'
_inherits = {'utm.source': 'source_id'}
_rec_name = "subject"
@api.model
def _get_default_mail_server_id(self):
server_id = self.env['ir.config_parameter'].sudo().get_param(
'mass_mailing.mail_server_id')
try:
server_id = literal_eval(server_id) if server_id else False
return self.env['ir.mail_server'].search([('id', '=', server_id)
]).id
except ValueError:
return False
@api.model
def default_get(self, fields):
res = super(MassMailing, self).default_get(fields)
if 'reply_to_mode' in fields and not 'reply_to_mode' in res and res.get(
'mailing_model_real'):
if res['mailing_model_real'] in ['res.partner', 'mailing.contact']:
res['reply_to_mode'] = 'email'
else:
res['reply_to_mode'] = 'thread'
return res
active = fields.Boolean(default=True, tracking=True)
subject = fields.Char('Subject',
help='Subject of emails to send',
required=True,
translate=True)
email_from = fields.Char(
string='Send From',
required=True,
default=lambda self: self.env['mail.message']._get_default_from())
sent_date = fields.Datetime(string='Sent Date', copy=False)
schedule_date = fields.Datetime(string='Scheduled for', tracking=True)
# don't translate 'body_arch', the translations are only on 'body_html'
body_arch = fields.Html(string='Body', translate=False)
body_html = fields.Html(string='Body converted to be send by mail',
sanitize_attributes=False)
attachment_ids = fields.Many2many('ir.attachment',
'mass_mailing_ir_attachments_rel',
'mass_mailing_id',
'attachment_id',
string='Attachments')
keep_archives = fields.Boolean(string='Keep Archives')
campaign_id = fields.Many2one('utm.campaign', string='UTM Campaign')
source_id = fields.Many2one(
'utm.source',
string='Source',
required=True,
ondelete='cascade',
help=
"This is the link source, e.g. Search Engine, another domain, or name of email list"
)
medium_id = fields.Many2one('utm.medium',
string='Medium',
help="Delivery method: Email")
clicks_ratio = fields.Integer(compute="_compute_clicks_ratio",
string="Number of Clicks")
state = fields.Selection([('draft', 'Draft'), ('in_queue', 'In Queue'),
('sending', 'Sending'), ('done', 'Sent')],
string='Status',
required=True,
tracking=True,
copy=False,
default='draft',
group_expand='_group_expand_states')
color = fields.Integer(string='Color Index')
user_id = fields.Many2one('res.users',
string='Responsible',
tracking=True,
default=lambda self: self.env.user)
# mailing options
mailing_type = fields.Selection([('mail', 'Email')],
string="Mailing Type",
default="mail",
required=True)
reply_to_mode = fields.Selection([('thread', 'Recipient Followers'),
('email', 'Specified Email Address')],
string='Reply-To Mode',
required=True)
reply_to = fields.Char(
string='Reply To',
help='Preferred Reply-To Address',
default=lambda self: self.env['mail.message']._get_default_from())
# recipients
mailing_model_real = fields.Char(compute='_compute_model',
string='Recipients Real Model',
default='mailing.contact',
required=True)
mailing_model_id = fields.Many2one(
'ir.model',
string='Recipients Model',
domain=[('model', 'in', MASS_MAILING_BUSINESS_MODELS)],
default=lambda self: self.env.ref('mass_mailing.model_mailing_list'
).id)
mailing_model_name = fields.Char(related='mailing_model_id.model',
string='Recipients Model Name',
readonly=True,
related_sudo=True)
mailing_domain = fields.Char(string='Domain', default=[])
mail_server_id = fields.Many2one(
'ir.mail_server',
string='Mail Server',
default=_get_default_mail_server_id,
help=
"Use a specific mail server in priority. Otherwise Coffice relies on the first outgoing mail server available (based on their sequencing) as it does for normal mails."
)
contact_list_ids = fields.Many2many('mailing.list',
'mail_mass_mailing_list_rel',
string='Mailing Lists')
contact_ab_pc = fields.Integer(
string='A/B Testing percentage',
help=
'Percentage of the contacts that will be mailed. Recipients will be taken randomly.',
default=100)
unique_ab_testing = fields.Boolean(
string='Allow A/B Testing',
default=False,
help=
'If checked, recipients will be mailed only once for the whole campaign. '
'This lets you send different mailings to randomly selected recipients and test '
'the effectiveness of the mailings, without causing duplicate messages.'
)
# statistics data
mailing_trace_ids = fields.One2many('mailing.trace',
'mass_mailing_id',
string='Emails Statistics')
total = fields.Integer(compute="_compute_total")
scheduled = fields.Integer(compute="_compute_statistics")
expected = fields.Integer(compute="_compute_statistics")
ignored = fields.Integer(compute="_compute_statistics")
sent = fields.Integer(compute="_compute_statistics")
delivered = fields.Integer(compute="_compute_statistics")
opened = fields.Integer(compute="_compute_statistics")
clicked = fields.Integer(compute="_compute_statistics")
replied = fields.Integer(compute="_compute_statistics")
bounced = fields.Integer(compute="_compute_statistics")
failed = fields.Integer(compute="_compute_statistics")
received_ratio = fields.Integer(compute="_compute_statistics",
string='Received Ratio')
opened_ratio = fields.Integer(compute="_compute_statistics",
string='Opened Ratio')
replied_ratio = fields.Integer(compute="_compute_statistics",
string='Replied Ratio')
bounced_ratio = fields.Integer(compute="_compute_statistics",
string='Bounced Ratio')
next_departure = fields.Datetime(compute="_compute_next_departure",
string='Scheduled date')
def _compute_total(self):
for mass_mailing in self:
mass_mailing.total = len(mass_mailing.sudo()._get_recipients())
def _compute_clicks_ratio(self):
self.env.cr.execute(
"""
SELECT COUNT(DISTINCT(stats.id)) AS nb_mails, COUNT(DISTINCT(clicks.mailing_trace_id)) AS nb_clicks, stats.mass_mailing_id AS id
FROM mailing_trace AS stats
LEFT OUTER JOIN link_tracker_click AS clicks ON clicks.mailing_trace_id = stats.id
WHERE stats.mass_mailing_id IN %s
GROUP BY stats.mass_mailing_id
""", (tuple(self.ids), ))
mass_mailing_data = self.env.cr.dictfetchall()
mapped_data = dict([(m['id'], 100 * m['nb_clicks'] / m['nb_mails'])
for m in mass_mailing_data])
for mass_mailing in self:
mass_mailing.clicks_ratio = mapped_data.get(mass_mailing.id, 0)
@api.depends('mailing_model_id')
def _compute_model(self):
for record in self:
record.mailing_model_real = (
record.mailing_model_name != 'mailing.list'
) and record.mailing_model_name or 'mailing.contact'
def _compute_statistics(self):
""" Compute statistics of the mass mailing """
self.env.cr.execute(
"""
SELECT
m.id as mailing_id,
COUNT(s.id) AS expected,
COUNT(CASE WHEN s.sent is not null THEN 1 ELSE null END) AS sent,
COUNT(CASE WHEN s.scheduled is not null AND s.sent is null AND s.exception is null AND s.ignored is null AND s.bounced is null THEN 1 ELSE null END) AS scheduled,
COUNT(CASE WHEN s.scheduled is not null AND s.sent is null AND s.exception is null AND s.ignored is not null THEN 1 ELSE null END) AS ignored,
COUNT(CASE WHEN s.sent is not null AND s.exception is null AND s.bounced is null THEN 1 ELSE null END) AS delivered,
COUNT(CASE WHEN s.opened is not null THEN 1 ELSE null END) AS opened,
COUNT(CASE WHEN s.clicked is not null THEN 1 ELSE null END) AS clicked,
COUNT(CASE WHEN s.replied is not null THEN 1 ELSE null END) AS replied,
COUNT(CASE WHEN s.bounced is not null THEN 1 ELSE null END) AS bounced,
COUNT(CASE WHEN s.exception is not null THEN 1 ELSE null END) AS failed
FROM
mailing_trace s
RIGHT JOIN
mailing_mailing m
ON (m.id = s.mass_mailing_id)
WHERE
m.id IN %s
GROUP BY
m.id
""", (tuple(self.ids), ))
for row in self.env.cr.dictfetchall():
total = row['expected'] = (row['expected'] - row['ignored']) or 1
row['received_ratio'] = 100.0 * row['delivered'] / total
row['opened_ratio'] = 100.0 * row['opened'] / total
row['clicks_ratio'] = 100.0 * row['clicked'] / total
row['replied_ratio'] = 100.0 * row['replied'] / total
row['bounced_ratio'] = 100.0 * row['bounced'] / total
self.browse(row.pop('mailing_id')).update(row)
def _compute_next_departure(self):
cron_next_call = self.env.ref(
'mass_mailing.ir_cron_mass_mailing_queue').sudo().nextcall
str2dt = fields.Datetime.from_string
cron_time = str2dt(cron_next_call)
for mass_mailing in self:
if mass_mailing.schedule_date:
schedule_date = str2dt(mass_mailing.schedule_date)
mass_mailing.next_departure = max(schedule_date, cron_time)
else:
mass_mailing.next_departure = cron_time
@api.onchange('mailing_model_name', 'contact_list_ids')
def _onchange_model_and_list(self):
mailing_domain = literal_eval(
self.mailing_domain) if self.mailing_domain else []
if self.mailing_model_name:
if mailing_domain:
try:
self.env[self.mailing_model_name].search(mailing_domain,
limit=1)
except:
mailing_domain = []
if not mailing_domain:
if self.mailing_model_name == 'mailing.list' and self.contact_list_ids:
mailing_domain = [('list_ids', 'in',
self.contact_list_ids.ids)]
elif 'is_blacklisted' in self.env[
self.
mailing_model_name]._fields and not self.mailing_domain:
mailing_domain = [('is_blacklisted', '=', False)]
elif 'opt_out' in self.env[
self.
mailing_model_name]._fields and not self.mailing_domain:
mailing_domain = [('opt_out', '=', False)]
else:
mailing_domain = []
self.mailing_domain = repr(mailing_domain)
@api.onchange('mailing_type')
def _onchange_mailing_type(self):
if self.mailing_type == 'mail' and not self.medium_id:
self.medium_id = self.env.ref('utm.utm_medium_email').id
# ------------------------------------------------------
# ORM
# ------------------------------------------------------
@api.model
def create(self, values):
if values.get('subject') and not values.get('name'):
values['name'] = "%s %s" % (
values['subject'],
datetime.strftime(fields.datetime.now(),
tools.DEFAULT_SERVER_DATETIME_FORMAT))
if values.get('body_html'):
values['body_html'] = self._convert_inline_images_to_urls(
values['body_html'])
if 'medium_id' not in values and values.get('mailing_type',
'mail') == 'mail':
values['medium_id'] = self.env.ref('utm.utm_medium_email').id
return super(MassMailing, self).create(values)
def write(self, values):
if values.get('body_html'):
values['body_html'] = self._convert_inline_images_to_urls(
values['body_html'])
return super(MassMailing, self).write(values)
@api.returns('self', lambda value: value.id)
def copy(self, default=None):
self.ensure_one()
default = dict(default or {}, name=_('%s (copy)') % self.name)
return super(MassMailing, self).copy(default=default)
def _group_expand_states(self, states, domain, order):
return [key for key, val in type(self).state.selection]
# ------------------------------------------------------
# ACTIONS
# ------------------------------------------------------
def action_duplicate(self):
self.ensure_one()
mass_mailing_copy = self.copy()
if mass_mailing_copy:
context = dict(self.env.context)
context['form_view_initial_mode'] = 'edit'
return {
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'mailing.mailing',
'res_id': mass_mailing_copy.id,
'context': context,
}
return False
def action_test(self):
self.ensure_one()
ctx = dict(self.env.context, default_mass_mailing_id=self.id)
return {
'name': _('Test Mailing'),
'type': 'ir.actions.act_window',
'view_mode': 'form',
'res_model': 'mailing.mailing.test',
'target': 'new',
'context': ctx,
}
def action_schedule(self):
self.ensure_one()
action = self.env.ref(
'mass_mailing.mailing_mailing_schedule_date_action').read()[0]
action['context'] = dict(self.env.context,
default_mass_mailing_id=self.id)
return action
def action_put_in_queue(self):
self.write({'state': 'in_queue'})
def action_cancel(self):
self.write({'state': 'draft', 'schedule_date': False})
def action_retry_failed(self):
failed_mails = self.env['mail.mail'].sudo().search([
('mailing_id', 'in', self.ids), ('state', '=', 'exception')
])
failed_mails.mapped('mailing_trace_ids').unlink()
failed_mails.unlink()
self.write({'state': 'in_queue'})
def action_view_traces_scheduled(self):
return self._action_view_traces_filtered('scheduled')
def action_view_traces_ignored(self):
return self._action_view_traces_filtered('ignored')
def action_view_traces_failed(self):
return self._action_view_traces_filtered('failed')
def _action_view_traces_filtered(self, view_filter):
action = self.env.ref('mass_mailing.mailing_trace_action').read()[0]
action['name'] = _('%s Traces') % (self.name)
action['context'] = {
'search_default_mass_mailing_id': self.id,
}
filter_key = 'search_default_filter_%s' % (view_filter)
action['context'][filter_key] = True
return action
def action_view_sent(self):
return self._action_view_documents_filtered('sent')
def action_view_opened(self):
return self._action_view_documents_filtered('opened')
def action_view_replied(self):
return self._action_view_documents_filtered('replied')
def action_view_bounced(self):
return self._action_view_documents_filtered('bounced')
def action_view_clicked(self):
return self._action_view_documents_filtered('clicked')
def action_view_delivered(self):
return self._action_view_documents_filtered('delivered')
def _action_view_documents_filtered(self, view_filter):
if view_filter in ('sent', 'opened', 'replied', 'bounced', 'clicked'):
opened_stats = self.mailing_trace_ids.filtered(
lambda stat: stat[view_filter])
elif view_filter == ('delivered'):
opened_stats = self.mailing_trace_ids.filtered(
lambda stat: stat.sent and not stat.bounced)
else:
opened_stats = self.env['mailing.trace']
res_ids = opened_stats.mapped('res_id')
model_name = self.env['ir.model']._get(
self.mailing_model_real).display_name
return {
'name': model_name,
'type': 'ir.actions.act_window',
'view_mode': 'tree',
'res_model': self.mailing_model_real,
'domain': [('id', 'in', res_ids)],
'context': dict(self._context, create=False)
}
def update_opt_out(self, email, list_ids, value):
if len(list_ids) > 0:
model = self.env['mailing.contact'].with_context(active_test=False)
records = model.search([('email_normalized', '=',
tools.email_normalize(email))])
opt_out_records = self.env['mailing.contact.subscription'].search([
('contact_id', 'in', records.ids), ('list_id', 'in', list_ids),
('opt_out', '!=', value)
])
opt_out_records.write({'opt_out': value})
message = _('The recipient <strong>unsubscribed from %s</strong> mailing list(s)') \
if value else _('The recipient <strong>subscribed to %s</strong> mailing list(s)')
for record in records:
# filter the list_id by record
record_lists = opt_out_records.filtered(
lambda rec: rec.contact_id.id == record.id)
if len(record_lists) > 0:
record.sudo().message_post(body=_(message % ', '.join(
str(list.name)
for list in record_lists.mapped('list_id'))))
# ------------------------------------------------------
# Email Sending
# ------------------------------------------------------
def _get_opt_out_list(self):
"""Returns a set of emails opted-out in target model"""
self.ensure_one()
opt_out = {}
target = self.env[self.mailing_model_real]
if self.mailing_model_real == "mailing.contact":
# if user is opt_out on One list but not on another
# or if two user with same email address, one opted in and the other one opted out, send the mail anyway
# TODO DBE Fixme : Optimise the following to get real opt_out and opt_in
target_list_contacts = self.env[
'mailing.contact.subscription'].search([
('list_id', 'in', self.contact_list_ids.ids)
])
opt_out_contacts = target_list_contacts.filtered(
lambda rel: rel.opt_out).mapped('contact_id.email_normalized')
opt_in_contacts = target_list_contacts.filtered(
lambda rel: not rel.opt_out).mapped(
'contact_id.email_normalized')
opt_out = set(c for c in opt_out_contacts
if c not in opt_in_contacts)
_logger.info("Mass-mailing %s targets %s, blacklist: %s emails",
self, target._name, len(opt_out))
else:
_logger.info(
"Mass-mailing %s targets %s, no opt out list available", self,
target._name)
return opt_out
def _get_link_tracker_values(self):
self.ensure_one()
vals = {'mass_mailing_id': self.id}
if self.campaign_id:
vals['campaign_id'] = self.campaign_id.id
if self.source_id:
vals['source_id'] = self.source_id.id
if self.medium_id:
vals['medium_id'] = self.medium_id.id
return vals
def _get_seen_list(self):
"""Returns a set of emails already targeted by current mailing/campaign (no duplicates)"""
self.ensure_one()
target = self.env[self.mailing_model_real]
# avoid loading a large number of records in memory
# + use a basic heuristic for extracting emails
query = """
SELECT lower(substring(t.%(mail_field)s, '([^ ,;<@]+@[^> ,;]+)'))
FROM mailing_trace s
JOIN %(target)s t ON (s.res_id = t.id)
WHERE substring(t.%(mail_field)s, '([^ ,;<@]+@[^> ,;]+)') IS NOT NULL
"""
# Apply same 'get email field' rule from mail_thread.message_get_default_recipients
if 'partner_id' in target._fields:
mail_field = 'email'
query = """
SELECT lower(substring(p.%(mail_field)s, '([^ ,;<@]+@[^> ,;]+)'))
FROM mailing_trace s
JOIN %(target)s t ON (s.res_id = t.id)
JOIN res_partner p ON (t.partner_id = p.id)
WHERE substring(p.%(mail_field)s, '([^ ,;<@]+@[^> ,;]+)') IS NOT NULL
"""
elif issubclass(type(target), self.pool['mail.address.mixin']):
mail_field = 'email_normalized'
elif 'email_from' in target._fields:
mail_field = 'email_from'
elif 'partner_email' in target._fields:
mail_field = 'partner_email'
elif 'email' in target._fields:
mail_field = 'email'
else:
raise UserError(
_("Unsupported mass mailing model %s") %
self.mailing_model_id.name)
if self.unique_ab_testing:
query += """
AND s.campaign_id = %%(mailing_campaign_id)s;
"""
else:
query += """
AND s.mass_mailing_id = %%(mailing_id)s
AND s.model = %%(target_model)s;
"""
query = query % {'target': target._table, 'mail_field': mail_field}
params = {
'mailing_id': self.id,
'mailing_campaign_id': self.campaign_id.id,
'target_model': self.mailing_model_real
}
self._cr.execute(query, params)
seen_list = set(m[0] for m in self._cr.fetchall())
_logger.info("Mass-mailing %s has already reached %s %s emails", self,
len(seen_list), target._name)
return seen_list
def _get_mass_mailing_context(self):
"""Returns extra context items with pre-filled blacklist and seen list for massmailing"""
return {
'mass_mailing_opt_out_list': self._get_opt_out_list(),
'mass_mailing_seen_list': self._get_seen_list(),
'post_convert_links': self._get_link_tracker_values(),
}
def _get_recipients(self):
if self.mailing_domain:
domain = safe_eval(self.mailing_domain)
res_ids = self.env[self.mailing_model_real].search(domain).ids
else:
res_ids = []
domain = [('id', 'in', res_ids)]
# randomly choose a fragment
if self.contact_ab_pc < 100:
contact_nbr = self.env[self.mailing_model_real].search_count(
domain)
topick = int(contact_nbr / 100.0 * self.contact_ab_pc)
if self.campaign_id and self.unique_ab_testing:
already_mailed = self.campaign_id._get_mailing_recipients()[
self.campaign_id.id]
else:
already_mailed = set([])
remaining = set(res_ids).difference(already_mailed)
if topick > len(remaining):
topick = len(remaining)
res_ids = random.sample(remaining, topick)
return res_ids
def _get_remaining_recipients(self):
res_ids = self._get_recipients()
already_mailed = self.env['mailing.trace'].search_read(
[('model', '=', self.mailing_model_real),
('res_id', 'in', res_ids), ('mass_mailing_id', '=', self.id)],
['res_id'])
done_res_ids = [record['res_id'] for record in already_mailed]
return [rid for rid in res_ids if rid not in done_res_ids]
def action_send_mail(self, res_ids=None):
author_id = self.env.user.partner_id.id
for mailing in self:
if not res_ids:
res_ids = mailing._get_remaining_recipients()
if not res_ids:
raise UserError(_('There are no recipients selected.'))
composer_values = {
'author_id':
author_id,
'attachment_ids':
[(4, attachment.id) for attachment in mailing.attachment_ids],
'body':
mailing.body_html,
'subject':
mailing.subject,
'model':
mailing.mailing_model_real,
'email_from':
mailing.email_from,
'record_name':
False,
'composition_mode':
'mass_mail',
'mass_mailing_id':
mailing.id,
'mailing_list_ids':
[(4, l.id) for l in mailing.contact_list_ids],
'no_auto_thread':
mailing.reply_to_mode != 'thread',
'template_id':
None,
'mail_server_id':
mailing.mail_server_id.id,
}
if mailing.reply_to_mode == 'email':
composer_values['reply_to'] = mailing.reply_to
composer = self.env['mail.compose.message'].with_context(
active_ids=res_ids).create(composer_values)
extra_context = self._get_mass_mailing_context()
composer = composer.with_context(active_ids=res_ids,
**extra_context)
# auto-commit except in testing mode
auto_commit = not getattr(threading.currentThread(), 'testing',
False)
composer.send_mail(auto_commit=auto_commit)
mailing.write({
'state': 'done',
'sent_date': fields.Datetime.now()
})
return True
def convert_links(self):
res = {}
for mass_mailing in self:
html = mass_mailing.body_html if mass_mailing.body_html else ''
vals = {'mass_mailing_id': mass_mailing.id}
if mass_mailing.campaign_id:
vals['campaign_id'] = mass_mailing.campaign_id.id
if mass_mailing.source_id:
vals['source_id'] = mass_mailing.source_id.id
if mass_mailing.medium_id:
vals['medium_id'] = mass_mailing.medium_id.id
res[mass_mailing.id] = self.env['link.tracker'].convert_links(
html, vals, blacklist=['/unsubscribe_from_list'])
return res
@api.model
def _process_mass_mailing_queue(self):
mass_mailings = self.search([('state', 'in', ('in_queue', 'sending')),
'|',
('schedule_date', '<',
fields.Datetime.now()),
('schedule_date', '=', False)])
for mass_mailing in mass_mailings:
user = mass_mailing.write_uid or self.env.user
mass_mailing = mass_mailing.with_context(
**user.with_user(user).context_get())
if len(mass_mailing._get_remaining_recipients()) > 0:
mass_mailing.state = 'sending'
mass_mailing.action_send_mail()
else:
mass_mailing.write({
'state': 'done',
'sent_date': fields.Datetime.now()
})
# ------------------------------------------------------
# TOOLS
# ------------------------------------------------------
def _unsubscribe_token(self, res_id, email):
"""Generate a secure hash for this mailing list and parameters.
This is appended to the unsubscription URL and then checked at
unsubscription time to ensure no malicious unsubscriptions are
performed.
:param int res_id:
ID of the resource that will be unsubscribed.
:param str email:
Email of the resource that will be unsubscribed.
"""
secret = self.env["ir.config_parameter"].sudo().get_param(
"database.secret")
token = (self.env.cr.dbname, self.id, int(res_id), tools.ustr(email))
return hmac.new(secret.encode('utf-8'),
repr(token).encode('utf-8'),
hashlib.sha512).hexdigest()
def _convert_inline_images_to_urls(self, body_html):
"""
Find inline base64 encoded images, make an attachement out of
them and replace the inline image with an url to the attachement.
"""
def _image_to_url(b64image: bytes):
"""Store an image in an attachement and returns an url"""
attachment = self.env['ir.attachment'].create({
'datas':
b64image,
'name':
"cropped_image_mailing_{}".format(self.id),
'type':
'binary',
})
attachment.generate_access_token()
return '/web/image/%s?access_token=%s' % (attachment.id,
attachment.access_token)
modified = False
root = lxml.html.fromstring(body_html)
for node in root.iter('img'):
match = image_re.match(node.attrib.get('src', ''))
if match:
mime = match.group(1) # unsed
image = match.group(2).encode() # base64 image as bytes
node.attrib['src'] = _image_to_url(image)
modified = True
if modified:
return lxml.html.tostring(root)
return body_html
