def send(self):
#Create the weekmail content and send it.
html_parser = html.parser.HTMLParser()
content = {'weekmail': html_parser.unescape(self)}
mail_content_txt = render_to_string('communication/weekmail.txt',
content)
mail_content_html = render_to_string('communication/weekmail.html',
content)
#You can change the weekmail recipients here.
recipients = settings.WEEKMAIL_RECIPIENTS
sender = settings.DEFAULT_FROM_EMAIL
try:
mail = EmailMultiAlternatives()
mail.subject = _('[Weekmail] %s') % (self.subject)
mail.body = mail_content_txt
mail.from_email = sender
mail.to = recipients
mail.cc = [sender,]
mail.attach_alternative(mail_content_html, "text/html")
for attachment in self.attached.all():
mail.attach_file(attachment.file.path)
mail.send()
self.sent_date = timezone.now()
self.save()
return True
except SMTPException:
return False
return False
def notify_by_email(sender,
to,
subject,
message_content,
cc=False,
attachment=False,
template='default.txt'):
from django.core.mail import EmailMessage
from django.core.mail import EmailMultiAlternatives
is_array = lambda var: isinstance(var, (list, tuple))
if not sender: sender = settings.EMAILS['sender']['default']
email = EmailMultiAlternatives(subject=str(settings.EMAILS['tag']) + " " +
str(subject),
from_email=sender,
to=[to])
# email.esp_extra = {"sender_domain": settings.EMAIL_SENDER_DOMAIN}
if template:
message_content['FOOTER'] = settings.EMAILS['footer']
email.body = render_to_string(template, message_content)
else:
email.body = str(message_content)
if attachment:
if is_array(attachment):
for a in attachment:
attach_to_email(email, a)
else:
attach_to_email(email, attachment)
if cc: email.cc = [cc]
try:
email.send()
return True
except:
return False
def _send(self):
if not self.sent:
self.last_attempt = timezone.now()
subject, from_email = self.subject, self.from_address
text_content = self.content
msg = EmailMultiAlternatives(subject, text_content, from_email)
if self.reply_to:
msg.reply_to = [email.strip() for email in self.reply_to.split(',')
if email.strip()]
if self.html_content:
html_content = self.html_content
msg.attach_alternative(html_content, "text/html")
msg.to = [email.strip() for email in self.to_address.split(',') if email.strip()]
msg.cc = [email.strip() for email in self.cc_address.split(',') if email.strip()]
msg.bcc = [email.strip() for email in self.bcc_address.split(',') if email.strip()]
# Add any additional attachments
for attachment in self.attachment_set.all():
path = attachment.file_attachment.path
if os.path.isfile(path):
with open(path, 'rb') as f:
content = f.read()
msg.attach(attachment.original_filename, content, None)
try:
msg.send()
self.sent = True
except Exception as e:
self.do_not_send = True
logger.error('Mail Queue Exception: {0}'.format(e))
self.save()
def build(self, context, headers=None):
# Activate language
translation.activate(self.language)
# Render template
site = get_current_site(None)
message = u'Envoyé via %s' % site
context.update({
'site' : site,
})
mail_html = render_to_string(self.template, context)
if settings.DEBUG:
self.dump(mail_html)
# Configure mail
mail = EmailMultiAlternatives(self.subject, message, headers=headers)
mail.to = self.to
mail.cc = self.cc
# Attach the rendered html
mail.attach_alternative(mail_html, 'text/html')
# Do not send, it's responsability of caller
return mail
def send_mail(self, sender, recipients, context=None, cc=None, bcc=None, sender_name="", attachments=None):
"""
This method sends the mail with the given parameters, replacing any variable fields with those in the context
"""
if isinstance(recipients, basestring):
recipients = [recipients]#To avoid exceptions in case there is a single recipient
if cc is None:
cc = []
if bcc is None:
bcc = []
if attachments is None:
attachments = {}
plainBody = Template(self.email_object.plainBody).render(Context(context))
htmlBody = Template(self.email_object.htmlBody).render(Context(context))
email = EmailMultiAlternatives()
email.subject = Template(self.email_object.subject).render(Context(context))
email.body = plainBody
email.attach_alternative(htmlBody, 'text/html')
email.from_email="%s <%s>" %(sender_name, sender)
email.to = recipients
email.cc = cc
email.bcc = bcc
for attachment in self.email_object.attachments.all():
email.attach("%s.%s" % (attachment.name, attachment.fileAttachment.file.name.split(".")[-1]), attachment.fileAttachment.file.read())
for attachment in attachments:
email.attach(attachment['filename'].encode('ascii', 'ignore'), attachment['data'])
return email.send()
def notify_by_email(sender,to,subject,message_content,cc=False,attachment=False,template='default.txt'):
from django.core.mail import EmailMessage
from django.core.mail import EmailMultiAlternatives
is_array = lambda var: isinstance(var, (list, tuple))
if not sender: sender = settings.EMAILS['sender']['default']
email = EmailMultiAlternatives(
subject=str(settings.EMAILS['tag']) + " " + str(subject),
from_email=sender,
to=[to]
)
# email.esp_extra = {"sender_domain": settings.EMAIL_SENDER_DOMAIN}
if template:
message_content['FOOTER'] = settings.EMAILS['footer']
email.body = render_to_string(template,message_content)
else: email.body = str(message_content)
if attachment:
if is_array(attachment):
for a in attachment: attach_to_email(email,a)
else: attach_to_email(email,attachment)
if cc: email.cc=[cc]
try:
email.send()
return True
except:
return False
def sendMail(self, mailFrom='*****@*****.**', mailTo=None, mailCC=None, mailBCC=None, replyTo=None, subject=None, bodyHTML=None, bodyText=None):
surpress = (EmailSuppression.objects.filter(suppression_date=date.today()).count() > 0)
if surpress:
log.warn("Surpressing e-mail")
return
if bodyText and bodyHTML:
message = EmailMultiAlternatives()
message.body = bodyText
message.attach_alternative(transform(bodyHTML), "text/html")
elif bodyText:
message = EmailMessage()
message.body = bodyText
elif bodyHTML:
message = EmailMessage()
message.body = transform(bodyHTML)
message.content_subtype = "html"
else:
raise TypeError("bodyHTML or bodyText must be set")
if not (mailTo or mailCC or mailBCC):
raise TypeError("Message must have at least one recipient")
if subject:
message.subject = subject
overrideEmail = None
#Try to get override email from settings
try:
overrideEmail = [settings.ENRICHMENT_OVERRIDE_EMAIL]
except AttributeError:
pass
#Take presidence on the parameter
if self.overrideEmail:
overrideEmail = self.overrideEmail
if not overrideEmail:
if mailTo:
message.to = list(mailTo)
if mailCC:
message.cc = list(mailCC)
if mailBCC:
message.bcc = list(mailBCC)
else:
message.to = overrideEmail
if replyTo:
message.reply_to = list(replyTo)
message.from_email = mailFrom
message.send()
def build(self, context, headers=None):
# Activate language
translation.activate(self.language)
# Render template
site = get_current_site(None)
message = u'Envoyé via %s' % site
context.update({
'site': site,
})
mail_html = render_to_string(self.template, context)
if settings.DEBUG:
self.dump(mail_html)
# Configure mail
mail = EmailMultiAlternatives(self.subject, message, headers=headers)
mail.to = self.to
mail.cc = self.cc
# Attach the rendered html
mail.attach_alternative(mail_html, 'text/html')
# Do not send, it's responsability of caller
return mail
def _send(self):
if not self.sent:
self.last_attempt = timezone.now()
subject, from_email = self.subject, self.from_address
text_content = self.content
msg = EmailMultiAlternatives(subject, text_content, from_email)
if self.reply_to:
msg.extra_headers.update({"reply-to": self.reply_to})
if self.html_content:
html_content = self.html_content
msg.attach_alternative(html_content, "text/html")
msg.to = [email.strip() for email in self.to_address.split(',') if email.strip()]
msg.cc = [email.strip() for email in self.cc_address.split(',') if email.strip()]
msg.bcc = [email.strip() for email in self.bcc_address.split(',') if email.strip()]
# Add any additional attachments
for attachment in self.attachment_set.all():
path = attachment.file_attachment.path
if os.path.isfile(path):
with open(path, 'rb') as f:
content = f.read()
msg.attach(attachment.original_filename, content, None)
try:
msg.send()
self.sent = True
except Exception as e:
self.do_not_send = True
logger.error('Mail Queue Exception: {0}'.format(e))
self.save()
def _setup_email(self):
msg = EmailMultiAlternatives(self.get_rendered_subject(),
self.get_plain_text_body(),
self.from_address,
self._normalize_to_iterable(self.to))
if self.cc:
msg.cc = self._normalize_to_iterable(self.cc)
full_bcc = self._get_bcc_with_debugging_copy()
if full_bcc:
msg.bcc = self._normalize_to_iterable(full_bcc)
msg.attach_alternative(self.get_rendered_html_body(), "text/html")
return msg
def _convert_to_django_msg(msg):
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body, alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg["Subject"])
email.to = _parse_header(msg["To"])
email.cc = _parse_header(msg.get("Cc", None))
email.bcc = _parse_header(msg.get("Bcc", None))
email.from_email = _parse_header(msg["From"])
return email
def _convert_to_django_msg(msg):
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body, alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg['Subject'])
email.to = _parse_header(msg['To'])
email.cc = _parse_header(msg.get('Cc', None))
email.bcc = _parse_header(msg.get('Bcc', None))
email.from_email = _parse_header(msg['From'])
return email
def send_email_html(self, template, context):
html_content = render_to_string(template, context)
text_content = strip_tags(html_content).strip()
email = EmailMultiAlternatives()
if self.email_subject:
email.subject = self.email_subject
if self.email_to:
email.to = [x.strip() for x in self.email_to.split(',')]
if self.email_cc:
email.cc = [x.strip() for x in self.email_cc.split(',')]
if self.email_bcc:
email.bcc = [x.strip() for x in self.email_bcc.split(',')]
if self.email_reply_to:
email.reply_to = [
x.strip() for x in self.email_reply_to.split(',')
]
# if self.email_msg:
# email.body = msg
email.body = html_content
email.attach_alternative(text_content, 'text/plain')
email.content_subtype = "html"
email.mixed_subtype = 'related'
fp = open('static/image/logo.png', 'rb')
msg_img1 = MIMEImage(fp.read())
fp.close()
msg_img1.add_header('Content-ID', '<{}>'.format("logo.png"))
email.attach(msg_img1)
fp = open(context['order'].door_image.image.url.replace('/', '', 1),
'rb')
msg_img2 = MIMEImage(fp.read())
fp.close()
msg_img2.add_header('Content-ID', '<{}>'.format("door.png"))
email.attach(msg_img2)
fp = open(context['order'].frame_image.image.url.replace('/', '', 1),
'rb')
msg_img3 = MIMEImage(fp.read())
fp.close()
msg_img3.add_header('Content-ID', '<{}>'.format("frame.png"))
email.attach(msg_img3)
fp = open(context['order'].handle.image.url.replace('/', '', 1), 'rb')
msg_img4 = MIMEImage(fp.read())
fp.close()
msg_img4.add_header('Content-ID', '<{}>'.format("handle.png"))
email.attach(msg_img4)
return email.send(fail_silently=True)
def send_email( # pylint: disable=too-many-arguments,too-many-locals,bad-continuation
name: str,
email: str,
subject: str,
message: str,
obj: object = None,
cc_list: list = None,
template: str = EMAIL_TEMPLATE,
template_path: str = EMAIL_TEMPLATE_PATH,
):
"""
Send a generic email.
:param name: name of person
:param email: email address to send to
:param subject: the email's subject
:param message: the email's body text
:param obj: the object in question
:param cc_list: the list of email address to "CC"
:param template: the template to use
"""
context = {
"name": name,
"subject": subject,
"message": message,
"object": obj,
"SITE": Site.objects.get_current(),
}
email_subject = render_to_string(
f"{template_path}/{template}_email_subject.txt",
context).replace("\n", "")
email_txt_body = render_to_string(
f"{template_path}/{template}_email_body.txt", context)
email_html_body = render_to_string(
f"{template_path}/{template}_email_body.html",
context).replace("\n", "")
subject = email_subject
from_email = settings.DEFAULT_FROM_EMAIL
to_email = f"{name} <{email}>"
text_content = email_txt_body
html_content = email_html_body
msg = EmailMultiAlternatives(subject, text_content, from_email, [to_email])
if cc_list:
msg.cc = cc_list
msg.attach_alternative(html_content, "text/html")
return msg.send(fail_silently=True)
def message(self):
m = EmailMultiAlternatives(self.subject, self.body)
m.to = self.to
m.cc = self.cc
m.bcc = self.bcc
m.from_email = self.from_email
m.alternatives = \
[(att.content, att.mimetype) for att in self.alternatives()]
for attachment in self.attachments():
m.attach(attachment.filename, attachment.content.read(),
attachment.mimetype)
m.extra_headers = self.extra_headers
return m
def _convert_to_django_msg(msg):
from django.core.mail import EmailMessage, EmailMultiAlternatives
body, alternatives = _get_content(msg)
if alternatives:
email = EmailMultiAlternatives(body=body,
alternatives=alternatives)
else:
email = EmailMessage(body=body)
email.subject = _parse_header(msg['Subject'])
email.to = _parse_header(msg['To'])
email.cc = _parse_header(msg.get('Cc', None))
email.bcc = _parse_header(msg.get('Bcc', None))
email.from_email = _parse_header(msg['From'])
return email
def send_email( # pylint: disable=too-many-arguments, too-many-locals
name: str, email: str, subject: str, message: str, obj: object = None,
cc_list: list = None, template: str = 'generic'):
"""
Sends a generic email
:param name: name of person
:param email: email address to send to
:param subject: the email's subject
:param message: the email's body text
:param obj: the object in question
:param cc_list: the list of email address to "CC"
:param template: the template to use
"""
context = {
'name': name,
'subject': subject,
'message': message,
'object': obj,
'SITE': Site.objects.get_current()
}
email_subject = render_to_string(
f'small_small_hr/email/{template}_email_subject.txt',
context).replace('\n', '')
email_txt_body = render_to_string(
f'small_small_hr/email/{template}_email_body.txt', context)
email_html_body = render_to_string(
f'small_small_hr/email/{template}_email_body.html', context
).replace('\n', '')
subject = email_subject
from_email = settings.DEFAULT_FROM_EMAIL
to_email = f'{name} <{email}>'
text_content = email_txt_body
html_content = email_html_body
msg = EmailMultiAlternatives(subject, text_content, from_email, [to_email])
if cc_list:
msg.cc = cc_list
msg.attach_alternative(html_content, "text/html")
return msg.send(fail_silently=True)
def send_mail(self,
sender,
recipients,
context=None,
cc=None,
bcc=None,
sender_name="",
attachments=None):
"""
This method sends the mail with the given parameters, replacing any variable fields with those in the context
"""
if cc is None:
cc = []
if bcc is None:
bcc = []
if attachments is None:
attachments = {}
plainBody = Template(self.email_object.plainBody).render(
Context(context))
htmlBody = Template(self.email_object.htmlBody).render(
Context(context))
email = EmailMultiAlternatives()
email.subject = Template(self.email_object.subject).render(
Context(context))
email.body = plainBody
email.attach_alternative(htmlBody, 'text/html')
email.from_email = "%s <%s>" % (sender_name, sender)
email.to = recipients
email.cc = cc
email.bcc = bcc
for attachment in self.email_object.attachments.all():
email.attach(
"%s.%s" % (attachment.name,
attachment.fileAttachment.file.name.split(".")[-1]),
attachment.fileAttachment.file.read())
for attachment in attachments:
email.attach(attachment['filename'].encode('ascii', 'ignore'),
attachment['data'])
email.tags = map(unicode.strip, self.email_object.tags.split(','))
email.track_clicks = True
return email.send()
def send_messages(data,
template,
sheet_title,
data_index=None,
email_to=None,
email_column=None,
bcc_column=None,
email_splitter=',',
email_settings=None):
heads = data[0]
if email_settings:
smtp_host = email_settings['smtp_host']
smtp_port = email_settings['smtp_port']
smtp_username = email_settings['smtp_username']
smtp_password = email_settings['smtp_password']
mail_backend = EmailBackend(host=smtp_host,
port=smtp_port,
password=smtp_password,
username=smtp_username,
use_tls=True,
timeout=10)
else:
mail_backend = None
if data_index != None:
data = data[1:][data_index]
current_task.update_state(state='PROGRESS',
meta={
'current': 0,
'total': 1
})
html_template = generate_email_template(template, heads, data)
if email_settings:
pass
from_email = email_settings['smtp_from_email']
else:
from_email = settings.DEFAULT_FROM_EMAIL
if email_to:
sended = send_mail(sheet_title,
message=strip_tags(html_template),
html_message=html_template,
recipient_list=(email_to, ),
from_email=from_email,
connection=mail_backend)
current_task.update_state(state='PROGRESS',
meta={
'current': 1,
'total': 1
})
else:
data = data[1:]
data_size = len(data)
current_task.update_state(state='PROGRESS',
meta={
'current': 0,
'total': data_size
})
if email_column:
email_column_index = heads.index(email_column)
else:
email_column_index = None
if bcc_column:
bcc_column_index = heads.index(bcc_column)
else:
bcc_column_index = None
for i, el_data in enumerate(data):
sleep(1)
email_to = el_data[email_column_index]
html_template = generate_email_template(template, heads, el_data)
if email_settings:
from_email = email_settings['smtp_from_email']
else:
from_email = settings.DEFAULT_FROM_EMAIL
msg = EmailMultiAlternatives(subject=sheet_title,
body=strip_tags(html_template),
from_email=from_email)
msg.attach_alternative(html_template, 'text/html')
if bcc_column_index:
msg.bcc = el_data[bcc_column_index].split(email_splitter)
if email_column_index:
msg.cc = el_data[email_column_index].split(email_splitter)
if mail_backend:
msg.connection = mail_backend
msg.send()
current_task.update_state(state='PROGRESS',
meta={
'current': i,
'total': data_size
})
def setUp(self):
organization, created = Organization.objects.get_or_create(name='Example Corp')
self.mailbox = Mailbox.objects.create(
name='test_mailbox',
uri='maildir://' + MAILDIR_PATH,
from_email='*****@*****.**'
)
# clear any pre-existing messages in the local mailbox
self.maildir.clear()
self.team, created = Team.objects.get_or_create(
name='Example Department',
slug='example_dept',
mailbox=self.mailbox
)
self.ticket, created = Ticket.objects.get_or_create(
title='Testing 123 Ticket',
organization=organization,
priority=4
)
self.ticket.teams.add(self.team)
self.sender_email = EmailAddress.objects.create(email_address=self._sender_email)
self.sender = Person.objects.create(
first_name='sender_first_name',
last_name='sender_last_name'
)
self.sender.email_addresses.add(self.sender_email)
self.recipient_email = EmailAddress.objects.create(email_address=self._recipient_email)
self.recipient = Person.objects.create(
first_name='recipient_first_name',
last_name='recipient_last_name',
)
self.recipient.email_addresses.add(self.recipient_email)
cc_people, cc_emails = list(), list()
for addr in self._cc_emails:
email = EmailAddress.objects.create(email_address=addr)
person = Person.objects.create(
first_name='{}_first_name'.format(addr.split('@')[0]),
last_name='{}_last_name'.format(addr.split('@')[0])
)
person.email_addresses.add(email)
cc_emails.append(email)
cc_people.append(person)
self.cc_emails = cc_emails
self.cc_people = cc_people
email_message = EmailMultiAlternatives()
email_message.body = 'Test message testing 123'
email_message.from_email = self._sender_email
email_message.to = self._recipient_email,
email_message.cc = self._cc_emails
email_message.subject = 'tests message subject'
email_message.extra_headers['Message-Id'] = 'unique_id_goes_here'
self.email_message_no_hashid_plain = copy.deepcopy(email_message)
email_message.attach_alternative(
'<html><body><p>Test message testing 123</p></body></html>',
'text/html'
)
self.email_message_no_hashid = email_message
def email_order(permanence_id, all_producers=True, closed_deliveries_id=None, producers_id=None):
from repanier.apps import REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_BOARD, \
REPANIER_SETTINGS_GROUP_NAME, REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_PRODUCER, \
REPANIER_SETTINGS_SEND_ABSTRACT_ORDER_MAIL_TO_PRODUCER, \
REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_CUSTOMER
cur_language = translation.get_language()
for language in settings.PARLER_LANGUAGES[settings.SITE_ID]:
language_code = language["code"]
translation.activate(language_code)
permanence = Permanence.objects.get(id=permanence_id)
config = Configuration.objects.get(id=DECIMAL_ONE)
filename = "{0}-{1}.xlsx".format(
slugify(_("Order")),
slugify(permanence)
)
group_filename = "{0}-{1}.xlsx".format(
slugify(REPANIER_SETTINGS_GROUP_NAME),
slugify(filename)
)
sender_email, sender_function, signature, cc_email_staff = get_signature(is_reply_to_order_email=True)
board_composition, board_composition_and_description = get_board_composition(permanence.id)
# Orders send to the preparation team
group_wb = xlsx_order.export_abstract(permanence=permanence, deliveries_id=closed_deliveries_id, wb=None)
if group_wb is not None:
abstract_ws = group_wb.get_active_sheet()
else:
abstract_ws = None
if all_producers:
if group_wb is not None:
# At least one order
group_wb = xlsx_order.export_customer_label(
permanence=permanence, deliveries_id=closed_deliveries_id, wb=group_wb
)
group_wb = xlsx_order.export_preparation(
permanence=permanence, deliveries_id=closed_deliveries_id, wb=group_wb
)
group_wb = xlsx_stock.export_permanence_stock(
permanence=permanence, customer_price=True, wb=group_wb
)
group_wb = xlsx_order.export_customer(
permanence=permanence, deliveries_id=closed_deliveries_id, deposit=True, wb=group_wb
)
group_wb = xlsx_order.export_customer(
permanence=permanence, deliveries_id=closed_deliveries_id, wb=group_wb
)
to_email_board = []
for permanence_board in PermanenceBoard.objects.filter(
permanence=permanence.id).order_by('?'):
if permanence_board.customer:
to_email_board.append(permanence_board.customer.user.email)
try:
order_staff_mail = config.order_staff_mail
except TranslationDoesNotExist:
order_staff_mail = EMPTY_STRING
# order_staff_mail_subject = "%s - %s - %s" % (
# _('Permanence preparation list'), permanence, REPANIER_SETTINGS_GROUP_NAME)
order_staff_mail_subject = "%s - %s" % (REPANIER_SETTINGS_GROUP_NAME, permanence)
template = Template(order_staff_mail)
context = TemplateContext({
'permanence_link' : mark_safe('<a href="http://%s%s">%s</a>' % (
settings.ALLOWED_HOSTS[0], reverse('order_view', args=(permanence.id,)), permanence)),
'board_composition' : mark_safe(board_composition),
'board_composition_and_description': mark_safe(board_composition_and_description),
'signature' : mark_safe(
'%s<br/>%s<br/>%s' % (signature, sender_function, REPANIER_SETTINGS_GROUP_NAME))
})
html_content = template.render(context)
email = EmailMultiAlternatives(
order_staff_mail_subject,
strip_tags(html_content),
from_email=sender_email,
to=to_email_board,
cc=cc_email_staff
)
if group_wb is not None:
email.attach(group_filename,
save_virtual_workbook(group_wb),
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
email.attach_alternative(html_content, "text/html")
if not REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_BOARD:
email.to = cc_email_staff
email.cc = []
email.bcc = []
send_email(email=email)
# Orders send to our producers
if REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_PRODUCER:
producer_set = Producer.objects.filter(
permanence=permanence.id,
language=language_code,
).order_by('?')
if producers_id is not None:
# Do not send order twice
# all_producers is True if we are sending the order to the last group of selected producers
producer_set = producer_set.filter(id__in=producers_id)
for producer in producer_set:
long_profile_name = producer.long_profile_name if producer.long_profile_name is not None else producer.short_profile_name
wb = xlsx_order.export_producer_by_product(permanence=permanence, producer=producer, wb=None)
if wb is None:
order_empty = True
duplicate = False
else:
order_empty = False
if not producer.manage_replenishment:
duplicate = True
wb = xlsx_order.export_producer_by_customer(
permanence=permanence, producer=producer, wb=wb)
else:
duplicate = False
try:
order_producer_mail = config.order_producer_mail
except TranslationDoesNotExist:
order_producer_mail = EMPTY_STRING
# order_producer_mail_subject = "%s - %s - %s" % (
# _('Permanence preparation list'), permanence, REPANIER_SETTINGS_GROUP_NAME)
order_producer_mail_subject = "%s - %s" % (REPANIER_SETTINGS_GROUP_NAME, permanence)
template = Template(order_producer_mail)
context = TemplateContext({
'name' : long_profile_name,
'long_profile_name': long_profile_name,
'order_empty' : order_empty,
'duplicate' : duplicate,
'permanence_link' : mark_safe('<a href="http://%s%s">%s</a>' % (
settings.ALLOWED_HOSTS[0], reverse('order_view', args=(permanence.id,)), permanence)),
'signature' : mark_safe(
'%s<br/>%s<br/>%s' % (signature, sender_function, REPANIER_SETTINGS_GROUP_NAME))
})
html_content = template.render(context)
producer_invoice = models.ProducerInvoice.objects.filter(
producer_id=producer.id, permanence_id=permanence.id
).only("total_price_with_tax").order_by('?').first()
if producer_invoice is not None \
and producer_invoice.total_price_with_tax < producer.minimum_order_value:
to = cc_email_staff
html_content = \
order_producer_mail_subject + '<br/><br/>' + html_content
cc = []
order_producer_mail_subject = _(
'/!\ Mail not send to our producer %s because the minimum order value has not been reached.') % long_profile_name
else:
to_email_producer = []
if producer.email:
to_email_producer.append(producer.email)
if producer.email2:
to_email_producer.append(producer.email2)
if producer.email3:
to_email_producer.append(producer.email3)
cc = cc_email_staff
email = EmailMultiAlternatives(
order_producer_mail_subject,
strip_tags(html_content),
from_email=sender_email,
to=to_email_producer,
cc=cc
)
if REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_PRODUCER and wb is not None:
if REPANIER_SETTINGS_SEND_ABSTRACT_ORDER_MAIL_TO_PRODUCER:
if abstract_ws is not None:
wb.add_sheet(abstract_ws, index=0)
email.attach(
filename,
save_virtual_workbook(wb),
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
email.attach_alternative(html_content, "text/html")
send_email(email=email)
if all_producers:
# Orders send to our customers only if they don't have already received it
# ==> customerinvoice__is_order_confirm_send=False
# customerinvoice__permanence_id=permanence.id
if REPANIER_SETTINGS_SEND_ORDER_MAIL_TO_CUSTOMER:
all_producers_closed = not (ProducerInvoice.objects.filter(
permanence_id=permanence_id,
status=PERMANENCE_OPENED
).order_by('?').exists())
if all_producers_closed:
if closed_deliveries_id is None:
customer_set = Customer.objects.filter(
represent_this_buyinggroup=False,
customerinvoice__is_order_confirm_send=False,
customerinvoice__permanence_id=permanence.id,
language=language_code
).order_by('?')
else:
customer_set = Customer.objects.filter(
represent_this_buyinggroup=False,
customerinvoice__is_order_confirm_send=False,
customerinvoice__permanence_id=permanence.id,
customerinvoice__delivery_id__in=closed_deliveries_id,
language=language_code
).order_by('?')
for customer in customer_set:
export_order_2_1_customer(
customer, filename, permanence, sender_email,
sender_function, signature, abstract_ws)
# confirm_customer_invoice(permanence_id, customer.id)
customer_invoice = CustomerInvoice.objects.filter(
customer_id=customer.id,
permanence_id=permanence_id
).order_by('?').first()
customer_invoice.confirm_order()
customer_invoice.save()
translation.activate(cur_language)