def _compute_date_begin_tz(self):
if self.date_begin:
self.date_begin_located = format_tz(
self.with_context(use_babel=True).env,
self.date_begin,
tz=self.date_tz)
else:
self.date_begin_located = False
def _compute_date_end_tz(self):
if self.date_end:
self.date_end_located = format_tz(self.with_context({
'use_babel':
True
}).env,
self.date_end,
tz=self.date_tz)
else:
self.date_end_located = False
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
diff = (event_date.date() - today.date())
if diff.days <= 0:
return _('today')
elif diff.days == 1:
return _('tomorrow')
elif (diff.days < 7):
return _('in %d days') % (diff.days, )
elif (diff.days < 14):
return _('next week')
elif event_date.month == (today + relativedelta(months=+1)).month:
return _('next month')
else:
return _('on ') + format_tz(self.with_context({'use_babel': True}).env, self.event_begin_date, tz=self.event_id.date_tz or 'UTC')
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
diff = (event_date.date() - today.date())
if diff.days == 0:
return _('Today')
elif diff.days == 1:
return _('Tomorrow')
elif event_date.isocalendar()[1] == today.isocalendar()[1]:
return _('This week')
elif today.month == event_date.month:
return _('This month')
elif event_date.month == (today + relativedelta(months=+1)):
return _('Next month')
else:
return format_tz(self.env, self.event_begin_date, tz='UTC', format='%Y%m%dT%H%M%SZ')
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
diff = (event_date.date() - today.date())
if diff.days == 0:
return _('Today')
elif diff.days == 1:
return _('Tomorrow')
elif event_date.isocalendar()[1] == today.isocalendar()[1]:
return _('This week')
elif today.month == event_date.month:
return _('This month')
elif event_date.month == (today + relativedelta(months=+1)):
return _('Next month')
else:
return format_tz(self.env, self.event_begin_date, tz='UTC', format='%Y%m%dT%H%M%SZ')
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
diff = (event_date.date() - today.date())
if diff.days <= 0:
return _('today')
elif diff.days == 1:
return _('tomorrow')
elif (diff.days < 7):
return _('in %d days') % (diff.days, )
elif (diff.days < 14):
return _('next week')
elif event_date.month == (today + relativedelta(months=+1)).month:
return _('next month')
else:
return _('on ') + format_tz(self.with_context({'use_babel': True}).env, self.event_begin_date, tz=self.event_id.date_tz or 'UTC')
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
if today.month == event_date.month:
if event_date.day == today.day:
return _('Today')
elif event_date.day - today.day == 1:
return _('Tomorrow')
elif event_date.isocalendar()[1] == today.isocalendar()[1]:
return _('This week')
else:
return _('This month')
elif event_date.month - today.month == 1:
return _('Next month')
else:
return format_tz(self.event_begin_date, tz='UTC', format='%Y%m%dT%H%M%SZ')
def get_date_range_str(self):
self.ensure_one()
today = fields.Datetime.from_string(fields.Datetime.now())
event_date = fields.Datetime.from_string(self.event_begin_date)
if today.month == event_date.month:
if event_date.day == today.day:
return _('Today')
elif event_date.day - today.day == 1:
return _('Tomorrow')
elif event_date.isocalendar()[1] == today.isocalendar()[1]:
return _('This week')
else:
return _('This month')
elif event_date.month - today.month == 1:
return _('Next month')
else:
return format_tz(self.event_begin_date, tz='UTC', format='%Y%m%dT%H%M%SZ')
def prepare_and_send(self, model, partner_ids, template_id, res_id, composition_mode='mass_mail'):
"""
Prepare the message then send it.
@param model: string, model name
@param partner_ids: int list, ids of message receivers
@param template_id: int, id of the email template
@param res_id: int, id of the record from where the email is sent
"""
template = self.env['mail.template'].browse(template_id)
# usefull to get template language
ctx = {'mail_auto_delete': template.auto_delete,
'mail_notify_user_signature': False,
'tpl_partners_only': False}
format_tz = lambda dt, tz=False, format=False: mail_template.format_tz(self._model, self._cr, self._uid,
dt, tz, format, self._context)
arg = {
'object': self.env[model].browse(res_id),
'user': self.env.user,
'ctx': ctx,
'format_tz': format_tz,
}
lang = mail_template.mako_template_env.from_string(tools.ustr(template.lang)).render(arg)
message = self.with_context(active_ids=None).create({
'model': model,
'composition_mode': composition_mode,
'partner_ids': [(6, 0, filter(None, partner_ids or []))],
'template_id': template_id,
'notify': True,
'res_id': res_id,
})
message_lang = message.with_context(lang=lang) if lang and lang != 'False' else message
value = message_lang.onchange_template_id(template_id, composition_mode, model, res_id)['value']
if value.get('attachment_ids') and (composition_mode == 'comment' or not template.report_template):
value['attachment_ids'] = [(4, attachment_id) for attachment_id in value['attachment_ids']]
message.write(value)
message.send_mail()
def _compute_date_end_tz(self):
if self.date_end:
self.date_end_located = format_tz(self.with_context({'use_babel': True}).env, self.date_end, tz=self.date_tz)
else:
self.date_end_located = False
def format_tz(dt, tz=False, format=False):
return mail_template.format_tz(self._model, self._cr, self._uid,
dt, tz, format, self._context)
def _compute_date_begin_tz(self):
if self.date_begin:
self.date_begin_located = format_tz(self.with_context(use_babel=True).env, self.date_begin, tz=self.date_tz)
else:
self.date_begin_located = False
def render_template(self,
template_txt,
model,
res_ids,
post_process=False):
""" Render the given template text, replace mako expressions
``${expr}`` with the result of evaluating these expressions
with an evaluation context containing:
- ``user``: browse_record of the current user
- ``object``: record of the document record this mail is related to
- ``context``: the context passed to the mail composition wizard
:param str template_txt: the template text to render
:param str model: model name of the document record
this mail is related to.
:param int res_ids: list of ids of document records
those mails are related to.
"""
multi_mode = True
if isinstance(res_ids, (int, long)):
multi_mode = False
res_ids = [res_ids]
results = dict.fromkeys(res_ids, u"")
# try to load the template
try:
mako_env = mako_safe_template_env if self.env.context.get('safe') \
else mako_template_env
template = mako_env.from_string(tools.ustr(template_txt))
except Exception:
_logger.info("Failed to load template %r",
template_txt,
exc_info=True)
return multi_mode and results or results[res_ids[0]]
# prepare template variables
# filter to avoid browsing [None]
records = self.env[model].browse(list(filter(None, res_ids)))
res_to_rec = dict.fromkeys(res_ids, None)
for record in records:
res_to_rec[record.id] = record
variables = {
'format_date':
lambda date, format=False, context=self._context: format_date(
self.env, date, format),
'format_tz':
lambda dt, tz=False, format=False, context=self._context:
format_tz(self.env, dt, tz, format),
'format_amount':
lambda amount, currency, context=self._context: format_amount(
self.env, amount, currency),
'format_numeric':
lambda value, column, options=None: self.format_numeric(
value, column, options), # Added by Smile
'user':
self.env.user,
'ctx':
self._context, # context kw would clash with mako internals
}
for res_id, record in res_to_rec.items():
variables['object'] = record
try:
render_result = template.render(variables)
except Exception:
_logger.info("Failed to render template %r using values %r" %
(template, variables),
exc_info=True)
raise UserError(
_("Failed to render template %r using values %r") %
(template, variables))
if render_result == u"False":
render_result = u""
results[res_id] = render_result
if post_process:
for res_id, result in results.items():
results[res_id] = self.render_post_process(result)
return multi_mode and results or results[res_ids[0]]
def get_page_by_category(self, category, content=1):
res = {'"code"': 0, '"msg"': '""'}
DocumentPage = self.env['document.page']
if not category:
res['"msg"'] = '"Category could not be empty"'
return res
if type(category) is int:
category_id = DocumentPage.browse(category)
else:
category_id = DocumentPage.search([('name', '=', category),
('partner_id', '=', False)])
if not category_id:
res['"msg"'] = '"Category not exists"'
return res
page_ids = DocumentPage.search([('parent_id', '=', category_id.id),
('partner_id', '=', False)],
order='create_date desc')
data = []
try:
for page in page_ids:
item = {}
item.update({
'"id"':
page.id or '""',
'"name"':
'\"' + (page.name or '') + '\"',
'"create_date"':
'\"' +
(page.create_date and format_tz(self.env,
page.create_date,
tz=self.env.user.tz,
format='%Y-%m-%d %H:%M:%S')
or '') + '\"',
'"write_date"':
'\"' +
(page.write_date and format_tz(self.env,
page.write_date,
tz=self.env.user.tz,
format='%Y-%m-%d %H:%M:%S')
or '') + '\"',
'"write_uid"':
'\"' + (page.write_uid and page.write_uid.name or '') +
'\"',
'"summary"':
'\"' + (page.summary or '') + '\"',
})
if content == 1:
item.update({
'"content"':
'\"' + (page.content and str(
page.content.replace("\'", "\\\'").replace(
"\"", "\\\"").encode('utf-8')) or '') + '\"'
})
data.append(item)
except Exception as e:
_logger.error("Error: %s" % (e.message or repr(e)))
return {
'"code"': 0,
'"msg"': '"Can not get content: %s"' % (e.message or repr(e))
}
return {'"code"': 1, '"msg"': '"Successfully"', '"data"': data}
def _get_dict_values(self, o, objects):
if not o:
return {}
lang_obj = self.env['res.lang']
order = objects['order']
invoice = objects['invoice']
partner = objects['partner']
address = objects['address']
address_pose = objects['address_pose']
cal_event = objects['cal_event']
lang_code = self._context.get('lang', partner.lang)
lang = lang_obj.search([('code', '=', lang_code or 'fr_FR')])
values = (
('amount_total', o, ''),
('origin', o, ''),
('date_order', order or o, ''),
('confirmation_date', order or o, ''),
('date_invoice', invoice or o, ''),
('residual', invoice or o, ''),
('number', invoice, ''),
('user_id', o, ''),
('objet', o, ''),
)
res = {
key: getattr(obj, key, default) or default
for key, obj, default in values
}
res['date_confirm_order'] = res['confirmation_date']
del res['confirmation_date']
res['user_name'] = res['user_id'] and res['user_id'].name
del res['user_id']
if cal_event:
date_event = fields.Datetime.from_string(cal_event.start)
date_event = fields.Datetime.context_timestamp(self, date_event)
date_format = lang.date_format.encode('utf-8')
res.update({
'c_title':
address.title.name or 'Madame, Monsieur',
'c_name':
address.name or (address.parent_id and address.parent_id.name)
or '',
'c_note':
partner.comment,
'c_street':
address.street or '',
'c_street2':
address.street2 or '',
'c_zip':
address.zip or '',
'c_city':
address.city or '',
'c_phone':
address.phone or '',
'c_mobile':
address.mobile or '',
'c_fax':
address.fax or '',
'c_email':
address.email or '',
'c_adr_intervention_name':
address_pose.name or address_pose.parent_id.name or '',
'c_adr_intervention_street':
address_pose.street or '',
'c_adr_intervention_street2':
address_pose.street2 or '',
'c_adr_intervention_city':
address_pose.city or '',
'c_adr_intervention_zip':
address_pose.zip or '',
'c_rdv_date':
cal_event and date_event.strftime(date_format) or '',
'c_rdv_heure':
cal_event and date_event.strftime('%H:%M') or '',
'date':
time.strftime(date_format),
'order_name':
order and order.name or '',
})
for date_field in ('date_order', 'date_confirm_order', 'date_invoice'):
if not res[date_field]:
continue
date = fields.Datetime.from_string(res[date_field])
date = date.strftime(date_format)
res[date_field] = date
# Pour rétrocompatibilité
res.update({
'c_adr_pose_name': res['c_adr_intervention_name'],
'c_adr_pose_street': res['c_adr_intervention_street'],
'c_adr_pose_street2': res['c_adr_intervention_street2'],
'c_adr_pose_city': res['c_adr_intervention_city'],
'c_adr_pose_zip': res['c_adr_intervention_zip'],
})
res.update(objects)
res.update({
'o':
o,
'format_date':
lambda date, format=False, context=self._context: format_date(
self.env, date, format),
'format_tz':
lambda dt, tz=False, format=False, context=self._context:
format_tz(self.env, dt, tz, format),
'format_amount':
lambda amount, currency, context=self._context: format_amount(
self.env, amount, currency),
'user':
self.env.user,
'ctx':
self._context, # context kw would clash with mako internals
})
return res
def _render_template(self, template_txt, model, res_ids, post_process=False):
"""Override to add website to context"""
multi_mode = True
if isinstance(res_ids, pycompat.integer_types):
multi_mode = False
res_ids = [res_ids]
results = dict.fromkeys(res_ids, u"")
# try to load the template
try:
mako_env = mako_safe_template_env if self.env.context.get('safe') else mako_template_env
template = mako_env.from_string(tools.ustr(template_txt))
except Exception:
_logger.info("Failed to load template %r", template_txt, exc_info=True)
return multi_mode and results or results[res_ids[0]]
# prepare template variables
records = self.env[model].browse(it for it in res_ids if it) # filter to avoid browsing [None]
res_to_rec = dict.fromkeys(res_ids, None)
for record in records:
res_to_rec[record.id] = record
variables = {
'format_date': lambda date, format=False, context=self._context: format_date(self.env, date, format),
'format_tz': lambda dt, tz=False, format=False, context=self._context: format_tz(self.env, dt, tz, format),
'format_amount': lambda amount, currency, context=self._context: format_amount(self.env, amount, currency),
'user': self.env.user,
'ctx': self._context, # context kw would clash with mako internals
}
# [NEW] Check website and company context
company = self.env['res.company'] # empty value
company_id = self.env.context.get('force_company')
if company_id:
company = self.env['res.company'].sudo().browse(company_id)
if self.env.context.get('website_id'):
website = self.env['website'].browse(self.env.context.get('website_id'))
else:
website = self.env.user.backend_website_id
for res_id, record in res_to_rec.items():
record_company = company
if not record_company:
if hasattr(record, 'company_id') and record.company_id:
record_company = record.company_id
record_website = website
if hasattr(record, 'website_id') and record.website_id:
record_website = record.website_id
if record_company and record_website \
and record_website.company_id != company:
# company and website are incompatible, so keep only company
record_website = self.env['website'] # empty value
record_context = dict(force_company=record_company.id, website_id=record_website.id)
variables['object'] = record.with_context(**record_context)
variables['website'] = record_website
try:
render_result = template.render(variables)
except Exception:
_logger.info("Failed to render template %r using values %r" % (template, variables), exc_info=True)
raise UserError(_("Failed to render template %r using values %r") % (template, variables))
if render_result == u"False":
render_result = u""
if post_process:
render_result = self.with_context(**record_context).render_post_process(render_result)
results[res_id] = render_result
return multi_mode and results or results[res_ids[0]]
def method_direct_trigger_demo(self):
# _logger.info("TESTTT------ %d"%date.today().weekday())
if date.today().weekday() == 6:
return
reload(sys)
sys.setdefaultencoding("utf-8")
template = self.env['mail.template'].search([('name', '=',
'REPORT TEMPLATE')])[0]
variables = {
'format_date':
lambda date, format=False, context=self._context: mail_template.
format_date(self.env, date, format),
'format_tz':
lambda dt, tz=False, format=False, context=self._context:
mail_template.format_tz(self.env, dt, tz, format),
'format_amount':
lambda amount, currency, context=self._context: mail_template.
format_amount(self.env, amount, currency),
'user':
self.env.user,
'ctx':
self._context, # context kw would clash with mako internals
}
headers = []
measures = []
if not self._context:
self._context = {'lang': u'vi_VN'}
if self.report:
# _logger.info("DO NOTHING %s"%self.report.context.replace("u\\'",'"').replace("'",'"').replace('u"','"'))
context = json.loads(
self.report.context.replace("u\\'",
'"').replace("'", '"').replace(
'u"', '"'))
active_measures = None
if 'measures' in context:
active_measures = context['measures']
elif 'pivot_measures' in context:
active_measures = context['pivot_measures']
if active_measures != None:
fields_model = self.env[self.report.model_id].fields_get()
groupby = None
if 'group_by' in context:
groupby = context['group_by']
elif 'pivot_row_groupby' in context:
groupby = context['pivot_row_groupby']
col_groupby = None
if 'col_group_by' in context:
col_groupby = context['col_group_by']
elif 'pivot_column_groupby' in context:
col_groupby = context['pivot_column_groupby']
fields = list(active_measures)
if groupby is not None:
fields.extend(
x.split(':')[0] for x in groupby if x not in fields)
if col_groupby is not None:
fields.extend(
x.split(':')[0] for x in col_groupby
if x not in fields)
datas = []
tmp_groupbys = []
tmp_domain = self.report.domain
if 'time.str' in tmp_domain:
times = re.findall(r'time.strftime\("[%,\-,\w]*"\)',
tmp_domain)
for time in times:
tmp = time.replace('time.strftime(','').replace('%Y','%d'%datetime.now().year)\
.replace('%m','%d'%datetime.now().month).replace(")",'')
tmp_domain = tmp_domain.replace(time, tmp)
domains = ast.literal_eval(tmp_domain)
# for domain in domains:
# if type(domain) is str:
#
if self.report.model_id == 'intern.invoice':
fields.append('color_notice')
datas.append(self.env[self.report.model_id].read_group(
domains, fields, tmp_groupbys, lazy=False))
for group in groupby:
tmp_groupbys.append(group)
datas.append(self.env[self.report.model_id].read_group(
domains, fields, tmp_groupbys, lazy=False))
for i, group in enumerate(groupby):
if ':' in group:
group = group.split(':')[0]
if group == 'custom_id' and self.report.model_id == 'intern.invoice':
continue
headers.append(fields_model[group])
measures.append(group)
for i, header_row in enumerate(active_measures):
headers.append(fields_model[header_row])
measures.append(header_row)
body = []
if self.report.model_id == 'intern.invoice' and 'date_exam_short' in active_measures:
# index = 0
# for i, x in enumerate(headers):
# if x
def tryconvert(date_str):
try:
return datetime.strptime(date_str, '%d-%m-%Y')
except ValueError:
return datetime(1, 1, 1)
datas[1] = sorted(datas[1],
key=lambda r:
(tryconvert(r['date_exam_short'][0])))
color = None
if self.report.model_id == 'intern.invoice':
color = []
body, row, color = self.write_body(self.report.model_id, body, datas,
0, 1, active_measures, groupby,
color, None)
# for i,data in enumerate(datas[1]):
# for j, tmp in enumerate(data):
# if type(data[tmp]) is list:
# datas[1][i][tmp] = datas[1][i][tmp][0]
# elif type(data[tmp]) is tuple:
# datas[1][i][tmp] = datas[1][i][tmp][1]
for i, data in enumerate(datas[0]):
for j, tmp in enumerate(data):
if type(data[tmp]) is list:
datas[0][i][tmp] = ''
elif type(data[tmp]) is unicode:
datas[0][i][tmp] = ''
elif type(data[tmp]) is tuple:
datas[0][i][tmp] = datas[0][i][tmp][1]
variables['headers'] = headers
variables['measures'] = measures
variables['objects'] = body
# variables['objects'] = ['1','2','3']
variables['email_template'] = template
variables['footer'] = datas[0][0]
if color is not None:
variables['color'] = color
else:
variables['color'] = False
# return self.env['report'].render('hh_automation_report.report_intern_pass_view', values=docargs)
# try:
render_result = template.body_view_id.render(variables)
# except Exception:
# _logger.info("Failed to render template %r using values %r" % (template, variables), exc_info=True)
# raise UserError(_("Failed to render template %r using values %r") % (template, variables))
if render_result == u"False":
render_result = u""
render_result = "%s<div>%s</div>" % (self.body_content, render_result)
if self.env.user and self.env.user.signature:
render_result += "<div><br></div>--<br>%s" % self.env.user.signature
mail_pool = self.env['mail.mail']
values = {}
emails = self.emails.split(',')
for i, email in enumerate(emails):
if '<' in email and '>' in email:
emails[i] = email[email.index('<') + 1:email.index('>')]
values.update({'subject': self.build_subject()})
values.update({'email_to': ','.join(emails)})
if self.emails_cc:
emails_cc = self.emails_cc.split(',')
for i, email in enumerate(emails_cc):
if '<' in email and '>' in email:
emails_cc[i] = email[email.index('<') + 1:email.index('>')]
values.update({'email_cc': ','.join(emails_cc)})
values.update({'body_html': render_result})
msg_id = mail_pool.create(values)
if msg_id:
mail_pool.send([msg_id])
