def check_student_email_id_and_send_mail(student_mail_id, name_of_student,
print_format, name,
predefined_text_content,
predefined_text_value,
email_id_of_cc):
orientation = "Landscape" if print_format == 'Microsoft Certificate' or print_format == "Microsoft Zertifikat" else "Portrait"
if print_format in ["Microsoft Certificate", "Microsoft Zertifikat"]:
attach_file_name = print_format
print_format = "Microsoft Certificate"
elif print_format in [
"New Horizons Certificate", "New Horizons Zertifikat"
]:
attach_file_name = print_format
print_format = "New Horizons Certificate"
if student_mail_id:
recipients = [student_mail_id]
cc = email_id_of_cc
attachments = [
frappe.attach_print("Certificate",
name,
file_name=attach_file_name,
print_format=print_format,
orientation=orientation)
]
subject = print_format
message = predefined_text_value
else:
recipients = [frappe.session.user]
cc = email_id_of_cc
attachments = [
frappe.attach_print("Certificate",
name,
file_name=attach_file_name,
print_format=print_format,
orientation=orientation)
]
subject = print_format
message = _("Please Send Certificate to <b>{0}</b> <br>".format(
name_of_student)) + predefined_text_value
try:
frappe.sendmail(recipients=(recipients or []),
cc=cc,
expose_recipients="header",
sender=None,
reply_to=None,
subject=_(subject),
content=None,
reference_doctype=None,
reference_name=None,
attachments=attachments,
message=message,
message_id=None,
unsubscribe_message=None,
delayed=False,
communication=None)
except Exception, e:
frappe.throw(
_("Mail has not been Sent. Kindly Contact to Administrator"))
def send_acknowlement(self):
settings = frappe.get_doc("Non Profit Settings")
if not settings.send_email:
frappe.throw(_("You need to enable <b>Send Acknowledge Email</b> in {0}").format(
get_link_to_form("Non Profit Settings", "Non Profit Settings")))
member = frappe.get_doc("Member", self.member)
if not member.email_id:
frappe.throw(_("Email address of member {0} is missing").format(frappe.utils.get_link_to_form("Member", self.member)))
plan = frappe.get_doc("Membership Type", self.membership_type)
email = member.email_id
attachments = [frappe.attach_print("Membership", self.name, print_format=settings.membership_print_format)]
if self.invoice and settings.send_invoice:
attachments.append(frappe.attach_print("Sales Invoice", self.invoice, print_format=settings.inv_print_format))
email_template = frappe.get_doc("Email Template", settings.email_template)
context = { "doc": self, "member": member}
email_args = {
"recipients": [email],
"message": frappe.render_template(email_template.get("response"), context),
"subject": frappe.render_template(email_template.get("subject"), context),
"attachments": attachments,
"reference_doctype": self.doctype,
"reference_name": self.name
}
if not frappe.flags.in_test:
frappe.enqueue(method=frappe.sendmail, queue="short", timeout=300, is_async=True, **email_args)
else:
frappe.sendmail(**email_args)
def delivery_completed_status():
unalerted_grns = frappe.db.get_list('Purchase Receipt',
filters={
'percentage_inspected': [">",99.99],
'docstatus':"0"
},
fields=['name'],
order_by='creation desc',
as_list=False
)
#ALERT DOC OWNER
for grn in unalerted_grns:
docname = grn.name
frappe.response["grn"]=docname
#purchase_receipt_document = frappe.db.get_doc("Purchase Receipt",docname)
purchase_receipt_dict = frappe.db.get_value("Purchase Receipt",docname,['supplier','owner'],as_dict=1)
recipient = purchase_receipt_dict.owner
supplier = purchase_receipt_dict.supplier
message ="Dear "+supplier+",\nThis is to let you know that goods/services as per your delivery note "+docname+" have been successfully inspected. Please invoice as per attached copy of GRN/Certificate document"
#GET ALL INSPECTION DOCUMENTS
inspection_documents = frappe.db.get_list('Quality Inspection',
filters={
'reference_name': docname,
},
fields=['name','item_name'],
order_by='creation desc',
as_list=False
)
#CREATE AN ATTACHMENTS ARRAY
attachments =[]
#GRN DOCUMENT ATTACHMENT
grn_attachment = frappe.attach_print("Purchase Receipt", docname, file_name=docname)
attachments.append(grn_attachment)
#INSPECTION ATTACHMENT
for item in inspection_documents:
inspection = frappe.attach_print("Quality Inspection", item.name, file_name=item.item_name)
attachments.append(inspection)
email_args = {
"recipients": recipient,
"message": _(message),
"subject": "Invoice Us - ["+docname+"]",
"attachments": attachments,
"reference_doctype": "Purchase Receipt",
"reference_name": docname,
}
#email_args.update(template_args)
frappe.response["response"] = email_args
enqueue(method=frappe.sendmail, queue='short', timeout=300, **email_args)
frappe.db.set_value("Purchase Receipt", docname, "docstatus", "1")
frappe.db.set_value("Purchase Receipt", docname, "workflow_state", "To Bill")
def email_authorized_doc(authorization_request_name):
authorization_request = frappe.get_doc("Authorization Request",
authorization_request_name)
authorized_doc = frappe.get_doc(authorization_request.linked_doctype,
authorization_request.linked_docname)
recipients = [authorization_request.authorizer_email]
company = authorized_doc.company if hasattr(
authorized_doc, 'company') else get_default_company()
subject = "Your signed {0} with {1}".format(authorized_doc.doctype,
company)
message = frappe.render_template(
"templates/emails/authorization_request.html", {
"authorization_request": authorization_request,
"company": company,
"linked_doc": authorized_doc
})
print_format = "Bloomstack Contract" if authorized_doc.doctype == 'Contract' else "Standard"
attachments = [
frappe.attach_print(authorized_doc.doctype,
authorized_doc.name,
print_format=print_format)
]
frappe.sendmail(recipients=recipients,
attachments=attachments,
subject=subject,
message=message)
def email_salary_slip(self):
receiver = frappe.db.get_value("Employee", self.employee, "prefered_email")
hr_settings = frappe.get_single("HR Settings")
message = "Please see attachment"
password = None
if hr_settings.encrypt_salary_slips_in_emails:
password = generate_password_for_pdf(hr_settings.password_policy, self.employee)
message += """<br>Note: Your salary slip is password protected,
the password to unlock the PDF is of the format {0}. """.format(hr_settings.password_policy)
if receiver:
email_args = {
"recipients": [receiver],
"message": _(message),
"subject": 'Salary Slip - from {0} to {1}'.format(self.start_date, self.end_date),
"attachments": [frappe.attach_print(self.doctype, self.name, file_name=self.name, password=password)],
"reference_doctype": self.doctype,
"reference_name": self.name
}
if not frappe.flags.in_test:
enqueue(method=frappe.sendmail, queue='short', timeout=300, is_async=True, **email_args)
else:
frappe.sendmail(**email_args)
else:
msgprint(_("{0}: Employee email not found, hence email not sent").format(self.employee_name))
def send_notification(new_rv, auto_repeat_doc, print_format='Standard'):
"""Notify concerned persons about recurring document generation"""
print_format = print_format
subject = auto_repeat_doc.subject or ''
message = auto_repeat_doc.message or ''
if not auto_repeat_doc.subject:
subject = _("New {0}: #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in auto_repeat_doc.subject:
subject = frappe.render_template(auto_repeat_doc.subject,
{'doc': new_rv})
if not auto_repeat_doc.message:
message = _("Please find attached {0} #{1}").format(
new_rv.doctype, new_rv.name)
elif "{" in auto_repeat_doc.message:
message = frappe.render_template(auto_repeat_doc.message,
{'doc': new_rv})
attachments = [
frappe.attach_print(new_rv.doctype,
new_rv.name,
file_name=new_rv.name,
print_format=print_format)
]
make(doctype=new_rv.doctype,
name=new_rv.name,
recipients=auto_repeat_doc.recipients,
subject=subject,
content=message,
attachments=attachments,
send_email=1)
def get_common_email_args(doc):
doctype = doc.get("doctype")
docname = doc.get("name")
email_template = get_email_template(doc)
if email_template:
subject = frappe.render_template(email_template.subject, vars(doc))
response = frappe.render_template(email_template.response, vars(doc))
else:
subject = _("Workflow Action") + f" on {doctype}: {docname}"
response = get_link_to_form(doctype, docname, f"{doctype}: {docname}")
common_args = {
"template":
"workflow_action",
"header":
"Workflow Action",
"attachments":
[frappe.attach_print(doctype, docname, file_name=docname, doc=doc)],
"subject":
subject,
"message":
response,
}
return common_args
def send_email(self):
"""send email with payment link"""
email_args = {
"recipients":
self.email_to,
"sender":
None,
"subject":
self.subject,
"message":
self.get_message(),
"now":
True,
"attachments": [
frappe.attach_print(self.reference_doctype,
self.reference_name,
file_name=self.reference_name,
print_format=self.print_format)
]
}
enqueue(method=frappe.sendmail,
queue='short',
timeout=300,
is_async=True,
**email_args)
def get_common_email_args(doc):
doctype = doc.get('doctype')
docname = doc.get('name')
email_template = get_email_template(doc)
if email_template:
subject = frappe.render_template(email_template.subject, vars(doc))
response = frappe.render_template(email_template.response, vars(doc))
else:
subject = _('Workflow Action') + f" on {doctype}: {docname}"
response = get_link_to_form(doctype, docname, f"{doctype}: {docname}")
common_args = {
'template':
'workflow_action',
'header':
'Workflow Action',
'attachments':
[frappe.attach_print(doctype, docname, file_name=docname, doc=doc)],
'subject':
subject,
'message':
response
}
return common_args
def send_notification(self, new_doc):
"""Notify concerned people about recurring document generation"""
subject = self.subject or ''
message = self.message or ''
if not self.subject:
subject = _("New {0}: {1}").format(new_doc.doctype, new_doc.name)
elif "{" in self.subject:
subject = frappe.render_template(self.subject, {'doc': new_doc})
if not self.message:
message = _("Please find attached {0}: {1}").format(
new_doc.doctype, new_doc.name)
elif "{" in self.message:
message = frappe.render_template(self.message, {'doc': new_doc})
print_format = self.print_format or 'Standard'
attachments = [
frappe.attach_print(new_doc.doctype,
new_doc.name,
file_name=new_doc.name,
print_format=print_format)
]
recipients = self.recipients.split('\n')
make(doctype=new_doc.doctype,
name=new_doc.name,
recipients=recipients,
subject=subject,
content=message,
attachments=attachments,
send_email=1)
def include_attachments(self, message):
message_obj = self.get_message_object(message)
attachments = self.queue_doc.attachments_list
for attachment in attachments:
if attachment.get('fcontent'):
continue
fid = attachment.get("fid")
if fid:
_file = frappe.get_doc("File", fid)
fcontent = _file.get_content()
attachment.update({
'fname': _file.file_name,
'fcontent': fcontent,
'parent': message_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": message_obj})
add_attachment(**print_format_file)
return safe_encode(message_obj.as_string())
def send_notification(new_rv, subscription_doc, print_format='Standard'):
"""Notify concerned persons about recurring document generation"""
print_format = print_format
if not subscription_doc.subject:
subject = _("New {0}: #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in subscription_doc.subject:
subject = frappe.render_template(subscription_doc.subject,
{'doc': new_rv})
if not subscription_doc.message:
message = _("Please find attached {0} #{1}").format(
new_rv.doctype, new_rv.name)
elif "{" in subscription_doc.message:
message = frappe.render_template(subscription_doc.message,
{'doc': new_rv})
attachments = [
frappe.attach_print(new_rv.doctype,
new_rv.name,
file_name=new_rv.name,
print_format=print_format)
]
frappe.sendmail(subscription_doc.recipients,
subject=subject,
message=message,
attachments=attachments)
def attach_all_boms(document):
"""This function attaches drawings to the purchase order based on the items being ordered"""
document = json.loads(document)
document2 = frappe._dict(document)
current_attachments = []
for file_url in frappe.db.sql("""select file_name from `tabFile` where attached_to_doctype = %(doctype)s and attached_to_name = %(docname)s""", {'doctype': document2.doctype, 'docname': document2.name}, as_dict=True ):
current_attachments.append(file_url.file_name)
# add the directly linked drawings
boms = []
for item in document["items"]:
#add the boms
boms = get_bom_pdf(boms, item["item_code"])
count = 0
for bom_doc in boms:
#frappe.msgprint(item_doc)
bom = frappe.get_doc("BOM",bom_doc)
# Check to see if this file is attached to the one we are looking for
if not (bom.name + ".pdf") in current_attachments:
count = count + 1
my_attach = frappe.attach_print(bom.doctype, bom.name, doc=bom)
myFile = save_file(my_attach['fname'], my_attach['fcontent'], document2.doctype, document2.name, "Home/Attachments", decode=False, is_private=1)
myFile.file_name = my_attach['fname']
myFile.save()
current_attachments.append(my_attach['fname'])
frappe.msgprint("Attached {0} boms".format(count))
def send_notification(new_rv):
"""Notify concerned persons about recurring document generation"""
frappe.sendmail(new_rv.notification_email_address,
subject= _("New {0}: #{1}").format(new_rv.doctype, new_rv.name),
message = _("Please find attached {0} #{1}").format(new_rv.doctype, new_rv.name),
attachments = [frappe.attach_print(new_rv.doctype, new_rv.name, file_name=new_rv.name, print_format=new_rv.recurring_print_format)])
def prepare_to_notify(self, print_html=None, print_format=None, attachments=None):
"""Prepare to make multipart MIME Email
:param print_html: Send given value as HTML attachment.
:param print_format: Attach print format of parent document."""
if print_format:
self.content += self.get_attach_link(print_format)
self.set_incoming_outgoing_accounts()
if not self.sender:
self.sender = formataddr([frappe.session.data.full_name or "Notification", self.outgoing_email_account])
self.attachments = []
if print_html or print_format:
self.attachments.append(frappe.attach_print(self.reference_doctype, self.reference_name,
print_format=print_format, html=print_html))
if attachments:
if isinstance(attachments, basestring):
attachments = json.loads(attachments)
for a in attachments:
if isinstance(a, basestring):
# is it a filename?
try:
file = get_file(a)
self.attachments.append({"fname": file[0], "fcontent": file[1]})
except IOError:
frappe.throw(_("Unable to find attachment {0}").format(a))
else:
self.attachments.append(a)
def get_attachments(self):
attachments = [
d.name for d in get_attachments(self.doctype, self.name)
]
attachments.append(
frappe.attach_print(self.doctype, self.name, doc=self))
return attachments
def email_salary_slip(self):
receiver = frappe.db.get_value("Employee", self.employee,
"prefered_email")
if receiver:
email_args = {
"recipients": [receiver],
"message":
_("Please see attachment"),
"subject":
'Salary Slip - from {0} to {1}'.format(self.start_date,
self.end_date),
"attachments": [
frappe.attach_print(self.doctype,
self.name,
file_name=self.name)
],
"reference_doctype":
self.doctype,
"reference_name":
self.name
}
if not frappe.flags.in_test:
enqueue(method=frappe.sendmail,
queue='short',
timeout=300,
is_async=True,
**email_args)
else:
frappe.sendmail(**email_args)
else:
msgprint(
_("{0}: Employee email not found, hence email not sent").
format(self.employee_name))
def prepare_to_notify(self, print_html=None, print_format=None, attachments=None):
"""Prepare to make multipart MIME Email
:param print_html: Send given value as HTML attachment.
:param print_format: Attach print format of parent document."""
if print_format:
self.content += self.get_attach_link(print_format)
self.set_incoming_outgoing_accounts()
if not self.sender or cint(self.outgoing_email_account.always_use_account_email_id_as_sender):
self.sender = formataddr([frappe.session.data.full_name or "Notification", self.outgoing_email_account.email_id])
self.attachments = []
if print_html or print_format:
self.attachments.append(frappe.attach_print(self.reference_doctype, self.reference_name,
print_format=print_format, html=print_html))
if attachments:
if isinstance(attachments, basestring):
attachments = json.loads(attachments)
for a in attachments:
if isinstance(a, basestring):
# is it a filename?
try:
file = get_file(a)
self.attachments.append({"fname": file[0], "fcontent": file[1]})
except IOError:
frappe.throw(_("Unable to find attachment {0}").format(a))
else:
self.attachments.append(a)
def make_email_queue(email_queue):
name_list = []
for key, data in email_queue.items():
name = frappe.db.get_value('Sales Invoice', {'offline_pos_name': key},
'name')
data = json.loads(data)
sender = frappe.session.user
print_format = "POS Invoice"
attachments = [
frappe.attach_print('Sales Invoice',
name,
print_format=print_format)
]
make(subject=data.get('subject'),
content=data.get('content'),
recipients=data.get('recipients'),
sender=sender,
attachments=attachments,
send_email=True,
doctype='Sales Invoice',
name=name)
name_list.append(key)
return name_list
def supplier_rfq_mail(self, data, update_password_link, rfq_link):
full_name = get_user_fullname(frappe.session['user'])
if full_name == "Guest":
full_name = "Administrator"
args = {
'update_password_link': update_password_link,
'message': frappe.render_template(self.response, data.as_dict()),
'rfq_link': rfq_link,
'user_fullname': full_name
}
subject = _("Request for Quotation")
template = "templates/emails/request_for_quotation.html"
sender = frappe.session.user not in STANDARD_USERS and frappe.session.user or None
frappe.sendmail(recipients=data.email_id,
sender=sender,
subject=subject,
message=frappe.get_template(template).render(args),
attachments=[
frappe.attach_print('Request for Quotation',
self.name)
],
as_bulk=True)
frappe.msgprint(_("Email sent to supplier {0}").format(data.supplier))
def add_freeze_pdf_to_dt(dt, dn, printformat, language=''):
if not language:
language = frappe.get_doc(dt, dn).language or 'de'
filedata = attach_print(doctype=dt, name=dn, print_format=printformat, lang=language)
fpath = frappe.get_site_path('private', 'files', filedata['fname'])
with open(fpath, "wb") as w:
w.write(filedata['fcontent'])
file_record = {
"doctype": "File",
"file_url": '/private/files/{0}'.format(filedata['fname']),
"file_name": filedata['fname'],
"attached_to_doctype": dt,
"attached_to_name": dn,
"folder": 'Home/Attachments',
"file_size": 0,
"is_private": 1
}
if not frappe.db.exists(file_record):
f = frappe.get_doc(file_record)
f.flags.ignore_permissions = True
f.insert()
frappe.db.commit()
return
def notify_customers(docname, date, driver, vehicle, sender_email,
delivery_notification):
sender_name = get_user_fullname(sender_email)
delivery_stops = frappe.get_all('Delivery Stop', {"parent": docname})
attachments = []
parent_doc = frappe.get_doc('Delivery Trip', docname)
args = parent_doc.as_dict()
for delivery_stop in parent_doc.delivery_stops:
contact_info = frappe.db.get_value(
"Contact",
delivery_stop.contact,
["first_name", "last_name", "email_id", "gender"],
as_dict=1)
args.update(delivery_stop.as_dict())
args.update(contact_info)
if delivery_stop.delivery_notes:
delivery_notes = (delivery_stop.delivery_notes).split(",")
default_print_format = frappe.get_meta(
'Delivery Note').default_print_format
attachments = []
for delivery_note in delivery_notes:
attachments.append(
frappe.attach_print('Delivery Note',
delivery_note,
file_name="Delivery Note",
print_format=default_print_format
or "Standard"))
if not delivery_stop.notified_by_email and contact_info.email_id:
driver_info = frappe.db.get_value("Driver",
driver,
["full_name", "cell_number"],
as_dict=1)
sender_designation = frappe.db.get_value("Employee", sender_email,
["designation"])
estimated_arrival = cstr(delivery_stop.estimated_arrival)[:-3]
email_template = frappe.get_doc("Standard Reply",
delivery_notification)
message = frappe.render_template(email_template.response, args)
frappe.sendmail(recipients=contact_info.email_id,
sender=sender_email,
message=message,
attachments=attachments,
subject=_(email_template.subject).format(
getdate(date).strftime('%d.%m.%y'),
estimated_arrival))
frappe.db.set_value("Delivery Stop", delivery_stop.name,
"notified_by_email", 1)
frappe.db.set_value("Delivery Stop", delivery_stop.name,
"email_sent_to", contact_info.email_id)
frappe.msgprint(
_("Email sent to {0}").format(contact_info.email_id))
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
def send_mail_funct(self):
receiver = frappe.db.get_value("Employee", self.employee, "company_email")
if receiver:
subj = 'Salary Slip - ' + cstr(self.month) +'/'+cstr(self.fiscal_year)
frappe.sendmail([receiver], subject=subj, message = _("Please see attachment"),
attachments=[frappe.attach_print(self.doctype, self.name, file_name=self.name)])
else:
msgprint(_("Company Email ID not found, hence mail not sent"))
def send_mail_funct(self):
receiver = frappe.db.get_value("Employee", self.employee, "company_email")
if receiver:
subj = 'Salary Slip - ' + cstr(self.month) +'/'+cstr(self.fiscal_year)
frappe.sendmail([receiver], subject=subj, message = _("Please see attachment"),
attachments=[frappe.attach_print(self.doctype, self.name, file_name=self.name)])
else:
msgprint(_("Company Email ID not found, hence mail not sent"))
def email_salary_slip(self):
receiver = frappe.db.get_value("Employee", self.employee, "company_email") or \
frappe.db.get_value("Employee", self.employee, "personal_email")
if receiver:
subj = 'Salary Slip - from {0} to {1}, fiscal year {2}'.format(self.start_date, self.end_date, self.fiscal_year)
frappe.sendmail([receiver], subject=subj, message = _("Please see attachment"),
attachments=[frappe.attach_print(self.doctype, self.name, file_name=self.name)], reference_doctype= self.doctype, reference_name= self.name)
else:
msgprint(_("{0}: Employee email not found, hence email not sent").format(self.employee_name))
def email_salary_slip(self):
receiver = frappe.db.get_value("Employee", self.employee, "prefered_email")
if receiver:
subj = 'Salary Slip - from {0} to {1}'.format(self.start_date, self.end_date)
frappe.sendmail([receiver], subject=subj, message = _("Please see attachment"),
attachments=[frappe.attach_print(self.doctype, self.name, file_name=self.name)], reference_doctype= self.doctype, reference_name= self.name)
else:
msgprint(_("{0}: Employee email not found, hence email not sent").format(self.employee_name))
def get_attachments(delivery_stop):
if not (frappe.db.get_single_value("Delivery Settings", "send_with_attachment") and delivery_stop.delivery_note):
return []
dispatch_attachment = frappe.db.get_single_value("Delivery Settings", "dispatch_attachment")
attachments = frappe.attach_print("Delivery Note", delivery_stop.delivery_note,
file_name="Delivery Note", print_format=dispatch_attachment)
return [attachments]
def get_invoice_as_attachments(invoices, print_format="Sales Invoice SNS"):
# print_format = frappe.db.get_single_value("Delivery Settings", "dispatch_attachment")
attachments = []
for invoice in invoices:
attachments.append(
frappe.attach_print("Sales Invoice",
invoice,
file_name="Internal Voucher - %s" % invoice,
print_format=print_format))
return attachments
def prepare_to_notify(doc,
print_html=None,
print_format=None,
attachments=None):
"""Prepare to make multipart MIME Email
:param print_html: Send given value as HTML attachment.
:param print_format: Attach print format of parent document."""
view_link = frappe.utils.cint(
frappe.db.get_value("Print Settings", "Print Settings",
"attach_view_link"))
if print_format and view_link:
doc.content += get_attach_link(doc, print_format)
set_incoming_outgoing_accounts(doc)
if not doc.sender:
doc.sender = doc.outgoing_email_account.email_id
if not doc.sender_full_name:
doc.sender_full_name = doc.outgoing_email_account.name or _(
"Notification")
if doc.sender:
# combine for sending to get the format 'Jane <*****@*****.**>'
doc.sender = formataddr([doc.sender_full_name, doc.sender])
doc.attachments = []
if print_html or print_format:
doc.attachments.append(
frappe.attach_print(doc.reference_doctype,
doc.reference_name,
print_format=print_format,
html=print_html))
if attachments:
if isinstance(attachments, string_types):
attachments = json.loads(attachments)
for a in attachments:
if isinstance(a, string_types):
# is it a filename?
try:
file = get_file(a)
doc.attachments.append({
"fname": file[0],
"fcontent": file[1]
})
except IOError:
frappe.throw(_("Unable to find attachment {0}").format(a))
else:
doc.attachments.append(a)
def evaluate_alert(doc, alert, event):
if isinstance(alert, basestring):
alert = frappe.get_doc("Email Alert", alert)
context = {"doc": doc, "nowdate": nowdate}
if alert.condition:
if not eval(alert.condition, context):
return
if event == "Value Change" and not doc.is_new():
if doc.get(alert.value_changed) == frappe.db.get_value(
doc.doctype, doc.name, alert.value_changed):
return # value not changed
for recipient in alert.recipients:
recipients = []
if recipient.condition:
if not eval(recipient.condition, context):
continue
if recipient.email_by_document_field:
if validate_email_add(doc.get(recipient.email_by_document_field)):
recipients.append(doc.get(recipient.email_by_document_field))
# else:
# print "invalid email"
if recipient.cc:
recipient.cc = recipient.cc.replace(",", "\n")
recipients = recipients + recipient.cc.split("\n")
if not recipients:
return
subject = alert.subject
if event != "Value Change" and not doc.is_new():
# reload the doc for the latest values & comments,
# except for validate type event.
doc = frappe.get_doc(doc.doctype, doc.name)
context = {"doc": doc, "alert": alert, "comments": None}
if doc.get("_comments"):
context["comments"] = json.loads(doc.get("_comments"))
if "{" in subject:
subject = frappe.render_template(alert.subject, context)
frappe.sendmail(recipients=recipients,
subject=subject,
message=frappe.render_template(alert.message, context),
bulk=True,
reference_doctype=doc.doctype,
reference_name=doc.name,
attachments=[frappe.attach_print(doc.doctype, doc.name)]
if alert.attach_print else None)
def send(self, doc):
'''Build recipients and send email alert'''
context = get_context(doc)
recipients = []
for recipient in self.recipients:
if recipient.condition:
if not frappe.safe_eval(recipient.condition, None, context):
continue
if recipient.email_by_document_field:
if validate_email_add(
doc.get(recipient.email_by_document_field)):
recipient.email_by_document_field = doc.get(
recipient.email_by_document_field).replace(",", "\n")
recipients = recipients + recipient.email_by_document_field.split(
"\n")
# else:
# print "invalid email"
if recipient.cc:
recipient.cc = recipient.cc.replace(",", "\n")
recipients = recipients + recipient.cc.split("\n")
#For sending emails to specified role
if recipient.email_by_role:
emails = get_emails_from_role(recipient.email_by_role)
for email in emails:
recipients = recipients + email.split("\n")
if not recipients:
return
recipients = list(set(recipients))
subject = self.subject
context = {"doc": doc, "alert": self, "comments": None}
if self.is_standard:
self.load_standard_properties(context)
if doc.get("_comments"):
context["comments"] = json.loads(doc.get("_comments"))
if "{" in subject:
subject = frappe.render_template(self.subject, context)
frappe.sendmail(
recipients=recipients,
subject=subject,
message=frappe.render_template(self.message, context),
reference_doctype=doc.doctype,
reference_name=doc.name,
attachments=[frappe.attach_print(doc.doctype, doc.name)]
if self.attach_print else None)
def send_mail_funct(self):
recipients = self.recipients_list.split("\n")
if recipients and self.recipients_list !='':
subj = 'Salary Slip - ' + cstr(self.month) +'/'+cstr(self.fiscal_year)
for receiver in recipients:
frappe.sendmail([receiver], subject=subj, message = _("Please see attachment"),
attachments=[frappe.attach_print(self.doctype, self.name, file_name=self.name)])
else:
msgprint(_("Recipients not be set, hence mail not sent"))
def send_email(self):
"""send email with payment link"""
email_args = {
"recipients": self.email_to,
"sender": None,
"subject": self.subject,
"message": self.get_message(),
"now": True,
"attachments": [frappe.attach_print(self.reference_doctype, self.reference_name,
file_name=self.reference_name, print_format=self.print_format)]}
enqueue(method=frappe.sendmail, queue='short', timeout=300, async=True, **email_args)
def send_email(self):
"""send email with payment link"""
frappe.sendmail(recipients=self.email_to,
sender=None,
subject=self.subject,
message=self.get_message(),
attachments=[
frappe.attach_print(self.reference_doctype,
self.reference_name,
file_name=self.reference_name,
print_format=self.print_format)
])
def notify_customers(docname, date, driver, vehicle, sender_email, delivery_notification):
sender_name = get_user_fullname(sender_email)
delivery_stops = frappe.get_all('Delivery Stop', {"parent": docname})
attachments = []
for delivery_stop in delivery_stops:
delivery_stop_info = frappe.db.get_value(
"Delivery Stop",
delivery_stop.name,
["notified_by_email", "estimated_arrival", "details", "contact", "delivery_notes"],
as_dict=1)
contact_info = frappe.db.get_value("Contact", delivery_stop_info.contact,
["first_name", "last_name", "email_id", "gender"], as_dict=1)
if delivery_stop_info.delivery_notes:
delivery_notes = (delivery_stop_info.delivery_notes).split(",")
attachments = []
for delivery_note in delivery_notes:
default_print_format = frappe.get_value('Delivery Note', delivery_note, 'default_print_format')
attachments.append(
frappe.attach_print('Delivery Note',
delivery_note,
file_name="Delivery Note",
print_format=default_print_format or "Standard"))
if not delivery_stop_info.notified_by_email and contact_info.email_id:
driver_info = frappe.db.get_value("Driver", driver, ["full_name", "cell_number"], as_dict=1)
sender_designation = frappe.db.get_value("Employee", sender_email, ["designation"])
estimated_arrival = str(delivery_stop_info.estimated_arrival)[:-3]
email_template = frappe.get_doc("Standard Reply", delivery_notification)
message = frappe.render_template(
email_template.response,
dict(contact_info=contact_info, sender_name=sender_name,
details=delivery_stop_info.details,
estimated_arrival=estimated_arrival,
date=getdate(date).strftime('%d.%m.%y'), vehicle=vehicle,
driver_info=driver_info,
sender_designation=sender_designation)
)
frappe.sendmail(
recipients=contact_info.email_id,
sender=sender_email,
message=message,
attachments=attachments,
subject=_(email_template.subject).format(getdate(date).strftime('%d.%m.%y'),
estimated_arrival))
frappe.db.set_value("Delivery Stop", delivery_stop.name, "notified_by_email", 1)
frappe.db.set_value("Delivery Stop", delivery_stop.name,
"email_sent_to", contact_info.email_id)
frappe.msgprint(_("Email sent to {0}").format(contact_info.email_id))
def evaluate_alert(doc, alert, event):
if isinstance(alert, basestring):
alert = frappe.get_doc("Email Alert", alert)
context = {"doc": doc, "nowdate": nowdate}
if alert.condition:
if not eval(alert.condition, context):
return
if event=="Value Change" and not doc.is_new():
if doc.get(alert.value_changed) == frappe.db.get_value(doc.doctype,
doc.name, alert.value_changed):
return # value not changed
for recipient in alert.recipients:
recipients = []
if recipient.condition:
if not eval(recipient.condition, context):
continue
if recipient.email_by_document_field:
if validate_email_add(doc.get(recipient.email_by_document_field)):
recipients.append(doc.get(recipient.email_by_document_field))
# else:
# print "invalid email"
if recipient.cc:
recipient.cc = recipient.cc.replace(",", "\n")
recipients = recipients + recipient.cc.split("\n")
if not recipients:
return
subject = alert.subject
if event != "Value Change" and not doc.is_new():
# reload the doc for the latest values & comments,
# except for validate type event.
doc = frappe.get_doc(doc.doctype, doc.name)
context = {"doc": doc, "alert": alert, "comments": None}
if doc.get("_comments"):
context["comments"] = json.loads(doc.get("_comments"))
if "{" in subject:
subject = frappe.render_template(alert.subject, context)
frappe.sendmail(recipients=recipients, subject=subject,
message= frappe.render_template(alert.message, context),
bulk=True, reference_doctype = doc.doctype, reference_name = doc.name,
attachments = [frappe.attach_print(doc.doctype, doc.name)] if alert.attach_print else None)
def mail_send(email_id,n_password):
receiver = self.email_id
new_rv=self
#ath = frappe.get_doc("Add Owner","OW001")
#receiver = '*****@*****.**'
if receiver:
subj = 'Payment Details :- '
sendmail([receiver], subject=subj,
message = 'Hello Sir/Madam,'+'\n'+'\nYour Payment Details Are Attached\n'+'\n'+'\nThanks & Regards,'+'\n'+'\nSahara Prestige Co-Op Housing Society',
attachments=[frappe.attach_print(new_rv.doctype, new_rv.name, file_name=new_rv.name, print_format='')])
frappe.msgprint("Mail Send")
else:
frappe.msgprint(_("Email ID not found, hence mail not sent"))
def mail_send(email_id,n_password):
#======Send Welcome Mail=============================================================
receiver = self.email_id
new_rv=self
#ath = frappe.get_doc("Add Owner","OW001")
#receiver = '*****@*****.**'
if receiver:
subj = 'Owner Details :- '
sendmail([receiver], subject=subj,
message = 'Welcome to SatyaPuram Society'+'\n'+'\nYour Login Details Are:\n'+'\nEmail Id:'+ email_id +'\n'+'\nPassword:\n' + n_password +'\n'+'\nPlease Find Attachment of your House Details'+'\n'+'\nThanks & Regards,'+'\n'+'\nSatyaPuram Society',
attachments=[frappe.attach_print(new_rv.doctype, new_rv.name, file_name=new_rv.name, print_format='')])
frappe.msgprint("Mail Send")
else:
frappe.msgprint(_("Email ID not found, hence mail not sent"))
def email_salary_slip(self):
receiver = frappe.db.get_value("Employee", self.employee, "prefered_email")
if receiver:
email_args = {
"recipients": [receiver],
"message": _("Please see attachment"),
"subject": 'Salary Slip - from {0} to {1}'.format(self.start_date, self.end_date),
"attachments": [frappe.attach_print(self.doctype, self.name, file_name=self.name)],
"reference_doctype": self.doctype,
"reference_name": self.name
}
enqueue(method=frappe.sendmail, queue='short', timeout=300, async=True, **email_args)
else:
msgprint(_("{0}: Employee email not found, hence email not sent").format(self.employee_name))
def make_email_queue(email_queue):
name_list = []
for key, data in email_queue.items():
name = frappe.db.get_value('Sales Invoice', {'offline_pos_name': key}, 'name')
data = json.loads(data)
sender = frappe.session.user
print_format = "POS Invoice"
attachments = [frappe.attach_print('Sales Invoice', name, print_format= print_format)]
make(subject = data.get('subject'), content = data.get('content'), recipients = data.get('recipients'),
sender=sender,attachments = attachments, send_email=True,
doctype='Sales Invoice', name=name)
name_list.append(key)
return name_list
def get_attachment(doc):
""" check print settings are attach the pdf """
if not self.attach_print:
return None
print_settings = frappe.get_doc("Print Settings", "Print Settings")
if (doc.docstatus == 0 and not print_settings.allow_print_for_draft) or \
(doc.docstatus == 2 and not print_settings.allow_print_for_cancelled):
# ignoring attachment as draft and cancelled documents are not allowed to print
status = "Draft" if doc.docstatus == 0 else "Cancelled"
frappe.throw(_("""Not allowed to attach {0} document,
please enable Allow Print For {0} in Print Settings""".format(status)),
title=_("Error in Email Alert"))
else:
return [frappe.attach_print(doc.doctype, doc.name, None, self.print_format)]
def send_email(self):
"""send email with payment link"""
frappe.sendmail(
recipients=self.email_to,
sender=None,
subject=self.subject,
message=self.get_message(),
attachments=[
frappe.attach_print(
self.reference_doctype,
self.reference_name,
file_name=self.reference_name,
print_format=self.print_format,
)
],
)
def send(self, doc):
'''Build recipients and send email alert'''
context = get_context(doc)
for recipient in self.recipients:
recipients = []
if recipient.condition:
if not eval(recipient.condition, context):
continue
if recipient.email_by_document_field:
if validate_email_add(doc.get(recipient.email_by_document_field)):
recipients.append(doc.get(recipient.email_by_document_field))
# else:
# print "invalid email"
if recipient.cc:
recipient.cc = recipient.cc.replace(",", "\n")
recipients = recipients + recipient.cc.split("\n")
#For sending emails to specified role
if recipient.email_by_role:
emails = get_emails_from_role(recipient.email_by_role)
for email in emails:
recipients = recipients + email.split("\n")
if not recipients:
return
subject = self.subject
context = {"doc": doc, "alert": self, "comments": None}
if self.is_standard:
self.load_standard_properties(context)
if doc.get("_comments"):
context["comments"] = json.loads(doc.get("_comments"))
if "{" in subject:
subject = frappe.render_template(self.subject, context)
frappe.sendmail(recipients=recipients, subject=subject,
message= frappe.render_template(self.message, context),
reference_doctype = doc.doctype,
reference_name = doc.name,
attachments = [frappe.attach_print(doc.doctype, doc.name)] if self.attach_print else None)
def send_notification(new_rv, subscription_doc, print_format='Standard'):
"""Notify concerned persons about recurring document generation"""
print_format = print_format
if not subscription_doc.subject:
subject = _("New {0}: #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in subscription_doc.subject:
subject = frappe.render_template(subscription_doc.subject, {'doc': new_rv})
if not subscription_doc.message:
message = _("Please find attached {0} #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in subscription_doc.message:
message = frappe.render_template(subscription_doc.message, {'doc': new_rv})
attachments = [frappe.attach_print(new_rv.doctype, new_rv.name,
file_name=new_rv.name, print_format=print_format)]
frappe.sendmail(subscription_doc.recipients,
subject=subject, message=message, attachments=attachments)
def get_common_email_args(doc):
doctype = doc.get('doctype')
docname = doc.get('name')
email_template = get_email_template(doc)
if email_template:
subject = frappe.render_template(email_template.subject, vars(doc))
response = frappe.render_template(email_template.response, vars(doc))
else:
subject = _('Workflow Action')
response = _('{0}: {1}'.format(doctype, docname))
common_args = {
'template': 'workflow_action',
'attachments': [frappe.attach_print(doctype, docname , file_name=docname)],
'subject': subject,
'message': response
}
return common_args
def prepare_to_notify(doc, print_html=None, print_format=None, attachments=None):
"""Prepare to make multipart MIME Email
:param print_html: Send given value as HTML attachment.
:param print_format: Attach print format of parent document."""
view_link = frappe.utils.cint(frappe.db.get_value("Print Settings", "Print Settings", "attach_view_link"))
if print_format and view_link:
doc.content += get_attach_link(doc, print_format)
set_incoming_outgoing_accounts(doc)
if not doc.sender:
doc.sender = doc.outgoing_email_account.email_id
if not doc.sender_full_name:
doc.sender_full_name = doc.outgoing_email_account.name or _("Notification")
if doc.sender:
# combine for sending to get the format 'Jane <*****@*****.**>'
doc.sender = formataddr([doc.sender_full_name, doc.sender])
doc.attachments = []
if print_html or print_format:
doc.attachments.append(frappe.attach_print(doc.reference_doctype, doc.reference_name,
print_format=print_format, html=print_html))
if attachments:
if isinstance(attachments, basestring):
attachments = json.loads(attachments)
for a in attachments:
if isinstance(a, basestring):
# is it a filename?
try:
file = get_file(a)
doc.attachments.append({"fname": file[0], "fcontent": file[1]})
except IOError:
frappe.throw(_("Unable to find attachment {0}").format(a))
else:
doc.attachments.append(a)
def supplier_rfq_mail(self, data, update_password_link, rfq_link):
full_name = get_user_fullname(frappe.session['user'])
if full_name == "Guest":
full_name = "Administrator"
args = {
'update_password_link': update_password_link,
'message': frappe.render_template(self.message_for_supplier, data.as_dict()),
'rfq_link': rfq_link,
'user_fullname': full_name
}
subject = _("Request for Quotation")
template = "templates/emails/request_for_quotation.html"
sender = frappe.session.user not in STANDARD_USERS and frappe.session.user or None
frappe.sendmail(recipients=data.email_id, sender=sender, subject=subject,
message=frappe.get_template(template).render(args),
attachments = [frappe.attach_print('Request for Quotation', self.name)],as_bulk=True)
frappe.msgprint(_("Email sent to supplier {0}").format(data.supplier))
def send_notification(new_rv, auto_repeat_doc, print_format='Standard'):
"""Notify concerned persons about recurring document generation"""
print_format = print_format
subject = auto_repeat_doc.subject or ''
message = auto_repeat_doc.message or ''
if not auto_repeat_doc.subject:
subject = _("New {0}: #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in auto_repeat_doc.subject:
subject = frappe.render_template(auto_repeat_doc.subject, {'doc': new_rv})
if not auto_repeat_doc.message:
message = _("Please find attached {0} #{1}").format(new_rv.doctype, new_rv.name)
elif "{" in auto_repeat_doc.message:
message = frappe.render_template(auto_repeat_doc.message, {'doc': new_rv})
attachments = [frappe.attach_print(new_rv.doctype, new_rv.name,
file_name=new_rv.name, print_format=print_format)]
make(doctype=new_rv.doctype, name=new_rv.name, recipients=auto_repeat_doc.recipients,
subject=subject, content=message, attachments=attachments, send_email=1)
def prepare_message(email, recipient, recipients_list):
message = email.message
if not message:
return ""
# Parse "Email Account" from "Email Sender"
email_account = get_outgoing_email_account(raise_exception_not_set=False, sender=email.sender)
if frappe.conf.use_ssl and email_account.track_email_status:
# Using SSL => Publically available domain => Email Read Reciept Possible
message = message.replace("<!--email open check-->", quopri.encodestring('<img src="https://{}/api/method/frappe.core.doctype.communication.email.mark_email_as_seen?name={}"/>'.format(frappe.local.site, email.communication).encode()).decode())
else:
# No SSL => No Email Read Reciept
message = message.replace("<!--email open check-->", quopri.encodestring("".encode()).decode())
if email.add_unsubscribe_link and email.reference_doctype: # is missing the check for unsubscribe message but will not add as there will be no unsubscribe url
unsubscribe_url = get_unsubcribed_url(email.reference_doctype, email.reference_name, recipient,
email.unsubscribe_method, email.unsubscribe_params)
message = message.replace("<!--unsubscribe url-->", quopri.encodestring(unsubscribe_url.encode()).decode())
if email.expose_recipients == "header":
pass
else:
if email.expose_recipients == "footer":
if isinstance(email.show_as_cc, string_types):
email.show_as_cc = email.show_as_cc.split(",")
email_sent_to = [r.recipient for r in recipients_list]
email_sent_cc = ", ".join([e for e in email_sent_to if e in email.show_as_cc])
email_sent_to = ", ".join([e for e in email_sent_to if e not in email.show_as_cc])
if email_sent_cc:
email_sent_message = _("This email was sent to {0} and copied to {1}").format(email_sent_to,email_sent_cc)
else:
email_sent_message = _("This email was sent to {0}").format(email_sent_to)
message = message.replace("<!--cc message-->", quopri.encodestring(email_sent_message.encode()).decode())
message = message.replace("<!--recipient-->", recipient)
message = (message and message.encode('utf8')) or ''
message = safe_decode(message)
if not email.attachments:
return message
# On-demand attachments
from email.parser import Parser
msg_obj = Parser().parsestr(message)
attachments = json.loads(email.attachments)
for attachment in attachments:
if attachment.get('fcontent'): continue
fid = attachment.get("fid")
if fid:
fname, fcontent = get_file(fid)
attachment.update({
'fname': fname,
'fcontent': fcontent,
'parent': msg_obj
})
attachment.pop("fid", None)
add_attachment(**attachment)
elif attachment.get("print_format_attachment") == 1:
attachment.pop("print_format_attachment", None)
print_format_file = frappe.attach_print(**attachment)
print_format_file.update({"parent": msg_obj})
add_attachment(**print_format_file)
return msg_obj.as_string()
def get_attachments(self): attachments = [d.name for d in get_attachments(self.doctype, self.name)] attachments.append(frappe.attach_print(self.doctype, self.name, doc=self)) return attachments
