def email_sending(project_name, frequency, date_start, date_end, progress,
number_of_drafts, update):
holiday = dataent.db.sql(
"""SELECT holiday_date FROM `tabHoliday` where holiday_date = CURDATE();"""
)
msg = "<p>Project Name: " + project_name + "</p><p>Frequency: " + " " + frequency + "</p><p>Update Reminder:" + " " + str(
date_start) + "</p><p>Expected Date End:" + " " + str(
date_end) + "</p><p>Percent Progress:" + " " + str(
progress) + "</p><p>Number of Updates:" + " " + str(len(
update)) + "</p>" + "</p><p>Number of drafts:" + " " + str(
number_of_drafts) + "</p>"
msg += """</u></b></p><table class='table table-bordered'><tr>
<th>Project ID</th><th>Date Updated</th><th>Time Updated</th><th>Project Status</th><th>Notes</th>"""
for updates in update:
msg += "<tr><td>" + str(updates[0]) + "</td><td>" + str(
updates[1]) + "</td><td>" + str(updates[2]) + "</td><td>" + str(
updates[3]) + "</td>" + "</td><td>" + str(
updates[4]) + "</td></tr>"
msg += "</table>"
if len(holiday) == 0:
email = dataent.db.sql(
"""SELECT user from `tabProject User` WHERE parent = %s;""",
project_name)
for emails in email:
dataent.sendmail(recipients=emails,
subject=dataent._(project_name + ' ' + 'Summary'),
message=msg)
else:
pass
def _notify(doc,
print_html=None,
print_format=None,
attachments=None,
recipients=None,
cc=None,
bcc=None):
prepare_to_notify(doc, print_html, print_format, attachments)
if doc.outgoing_email_account.send_unsubscribe_message:
unsubscribe_message = _("Leave this conversation")
else:
unsubscribe_message = ""
dataent.sendmail(
recipients=(recipients or []),
cc=(cc or []),
bcc=(bcc or []),
expose_recipients="header",
sender=doc.sender,
reply_to=doc.incoming_email_account,
subject=doc.subject,
content=doc.content,
reference_doctype=doc.reference_doctype,
reference_name=doc.reference_name,
attachments=doc.attachments,
message_id=doc.message_id,
unsubscribe_message=unsubscribe_message,
delayed=True,
communication=doc.name,
read_receipt=doc.read_receipt,
is_notification=True if doc.sent_or_received == "Received" else False,
print_letterhead=dataent.flags.print_letterhead)
def test_cc_footer(self):
#test if sending with cc's makes it into header
dataent.sendmail(recipients=['*****@*****.**'],
cc=['*****@*****.**'],
sender="*****@*****.**",
reference_doctype='User',
reference_name="Administrator",
subject='Testing Email Queue',
message='This is mail is queued!',
unsubscribe_message="Unsubscribe",
expose_recipients="footer",
now=True)
email_queue = dataent.db.sql(
"""select name from `tabEmail Queue` where status='Sent'""",
as_dict=1)
self.assertEqual(len(email_queue), 1)
queue_recipients = [
r.recipient for r in dataent.db.sql(
"""select recipient from `tabEmail Queue Recipient`
where status='Sent'""",
as_dict=1)
]
self.assertTrue('*****@*****.**' in queue_recipients)
self.assertTrue('*****@*****.**' in queue_recipients)
self.assertTrue(
'This email was sent to [email protected] and copied to [email protected]'
in dataent.safe_decode(dataent.flags.sent_mail))
def send_email(self):
"""
Sends the link to backup file located at epaas/backups
"""
from dataent.email import get_system_managers
recipient_list = get_system_managers()
db_backup_url = get_url(
os.path.join('backups', os.path.basename(self.backup_path_db)))
files_backup_url = get_url(
os.path.join('backups', os.path.basename(self.backup_path_files)))
msg = """Hello,
Your backups are ready to be downloaded.
1. [Click here to download the database backup](%(db_backup_url)s)
2. [Click here to download the files backup](%(files_backup_url)s)
This link will be valid for 24 hours. A new backup will be available for
download only after 24 hours.""" % {
"db_backup_url": db_backup_url,
"files_backup_url": files_backup_url
}
datetime_str = datetime.fromtimestamp(
os.stat(self.backup_path_db).st_ctime)
subject = datetime_str.strftime(
"%d/%m/%Y %H:%M:%S") + """ - Backup ready to be downloaded"""
dataent.sendmail(recipients=recipient_list, msg=msg, subject=subject)
return recipient_list
def test_cc_header(self):
#test if sending with cc's makes it into header
dataent.sendmail(recipients=['*****@*****.**'],
cc=['*****@*****.**'],
sender="*****@*****.**",
reference_doctype='User',
reference_name="Administrator",
subject='Testing Email Queue',
message='This is mail is queued!',
unsubscribe_message="Unsubscribe",
expose_recipients="header")
email_queue = dataent.db.sql(
"""select name from `tabEmail Queue` where status='Not Sent'""",
as_dict=1)
self.assertEqual(len(email_queue), 1)
queue_recipients = [
r.recipient for r in dataent.db.sql(
"""select recipient from `tabEmail Queue Recipient`
where status='Not Sent'""",
as_dict=1)
]
self.assertTrue('*****@*****.**' in queue_recipients)
self.assertTrue('*****@*****.**' in queue_recipients)
message = dataent.db.sql("""select message from `tabEmail Queue`
where status='Not Sent'""",
as_dict=1)[0].message
self.assertTrue('To: [email protected]' in message)
self.assertTrue('CC: [email protected]' in message)
def notify_unreplied():
"""Sends email notifications if there are unreplied Communications
and `notify_if_unreplied` is set as true."""
for email_account in dataent.get_all("Email Account", "name", filters={"enable_incoming": 1, "notify_if_unreplied": 1}):
email_account = dataent.get_doc("Email Account", email_account.name)
if email_account.append_to:
# get open communications younger than x mins, for given doctype
for comm in dataent.get_all("Communication", "name", filters=[
{"sent_or_received": "Received"},
{"reference_doctype": email_account.append_to},
{"unread_notification_sent": 0},
{"email_account":email_account.name},
{"creation": ("<", datetime.now() - timedelta(seconds = (email_account.unreplied_for_mins or 30) * 60))},
{"creation": (">", datetime.now() - timedelta(seconds = (email_account.unreplied_for_mins or 30) * 60 * 3))}
]):
comm = dataent.get_doc("Communication", comm.name)
if dataent.db.get_value(comm.reference_doctype, comm.reference_name, "status")=="Open":
# if status is still open
dataent.sendmail(recipients=email_account.get_unreplied_notification_emails(),
content=comm.content, subject=comm.subject, doctype= comm.reference_doctype,
name=comm.reference_name)
# update flag
comm.db_set("unread_notification_sent", 1)
def email_salary_slip(self):
receiver = dataent.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": [
dataent.attach_print(self.doctype,
self.name,
file_name=self.name)
],
"reference_doctype":
self.doctype,
"reference_name":
self.name
}
if not dataent.flags.in_test:
enqueue(method=dataent.sendmail,
queue='short',
timeout=300,
is_async=True,
**email_args)
else:
dataent.sendmail(**email_args)
else:
msgprint(
_("{0}: Employee email not found, hence email not sent").
format(self.employee_name))
def send_login_mail(self, subject, template, add_args, now=None):
"""send mail with login details"""
from dataent.utils.user import get_user_fullname
from dataent.utils import get_url
full_name = get_user_fullname(dataent.session['user'])
if full_name == "Guest":
full_name = "Administrator"
args = {
'first_name': self.first_name or self.last_name or "user",
'user': self.name,
'title': subject,
'login_url': get_url(),
'user_fullname': full_name
}
args.update(add_args)
sender = dataent.session.user not in STANDARD_USERS and get_formatted_email(
dataent.session.user) or None
dataent.sendmail(
recipients=self.email,
sender=sender,
subject=subject,
template=template,
args=args,
header=[subject, "green"],
delayed=(not now) if now != None else self.flags.delay_emails,
retry=3)
def send(self):
# send email only to enabled users
valid_users = [
p[0] for p in dataent.db.sql("""select name from `tabUser`
where enabled=1""")
]
recipients = list(
filter(lambda r: r in valid_users,
self.recipient_list.split("\n")))
original_user = dataent.session.user
if recipients:
for user_id in recipients:
dataent.set_user(user_id)
dataent.set_user_lang(user_id)
msg_for_this_recipient = self.get_msg_html()
if msg_for_this_recipient:
dataent.sendmail(recipients=user_id,
subject=_("{0} Digest").format(
self.frequency),
message=msg_for_this_recipient,
reference_doctype=self.doctype,
reference_name=self.name,
unsubscribe_message=_(
"Unsubscribe from this Email Digest"))
dataent.set_user(original_user)
dataent.set_user_lang(original_user)
def send_email(success, service_name, error_status=None):
if success:
if dataent.db.get_value("Dropbox Settings", None, "send_email_for_successful_backup") == '0':
return
subject = "Backup Upload Successful"
message ="""<h3>Backup Uploaded Successfully</h3><p>Hi there, this is just to inform you
that your backup was successfully uploaded to your %s account. So relax!</p>
""" % service_name
else:
subject = "[Warning] Backup Upload Failed"
message ="""<h3>Backup Upload Failed</h3><p>Oops, your automated backup to %s
failed.</p>
<p>Error message: <br>
<pre><code>%s</code></pre>
</p>
<p>Please contact your system manager for more information.</p>
""" % (service_name, error_status)
if not dataent.db:
dataent.connect()
recipients = split_emails(dataent.db.get_value("Dropbox Settings", None, "send_notifications_to"))
dataent.sendmail(recipients=recipients, subject=subject, message=message)
def send_message(subject="Website Query", message="", sender=""):
if not message:
dataent.response["message"] = 'Please write something'
return
if not sender:
dataent.response["message"] = 'Email Address Required'
return
# guest method, cap max writes per hour
if dataent.db.sql("""select count(*) from `tabCommunication`
where `sent_or_received`="Received"
and TIMEDIFF(%s, modified) < '01:00:00'""", now())[0][0] > max_communications_per_hour:
dataent.response["message"] = "Sorry: we believe we have received an unreasonably high number of requests of this kind. Please try later"
return
# send email
forward_to_email = dataent.db.get_value("Contact Us Settings", None, "forward_to_email")
if forward_to_email:
dataent.sendmail(recipients=forward_to_email, sender=sender, content=message, subject=subject)
# add to to-do ?
dataent.get_doc(dict(
doctype = 'Communication',
sender=sender,
subject= _('New Message from Website Contact Page'),
sent_or_received='Received',
content=message,
status='Open',
)).insert(ignore_permissions=True)
return "okay"
def _notify(args):
from dataent.utils import get_fullname, get_url
args = dataent._dict(args)
contact = args.contact
txt = args.txt
try:
if not isinstance(contact, list):
contact = [
dataent.db.get_value("User", contact, "email") or contact
]
dataent.sendmail(\
recipients=contact,
sender= dataent.db.get_value("User", dataent.session.user, "email"),
subject=_("New message from {0}").format(get_fullname(dataent.session.user)),
template="new_message",
args={
"from": get_fullname(dataent.session.user),
"message": txt,
"link": get_url()
},
header=[_('New Message'), 'orange'])
except dataent.OutgoingEmailError:
pass
def send_project_update_email_to_users(project):
doc = dataent.get_doc('Project', project)
if is_holiday_today(doc.holiday_list) or not doc.users: return
project_update = dataent.get_doc({
"doctype":
"Project Update",
"project":
project,
"sent":
0,
"date":
today(),
"time":
nowtime(),
"naming_series":
"UPDATE-.project.-.YY.MM.DD.-",
}).insert()
subject = "For project %s, update your status" % (project)
incoming_email_account = dataent.db.get_value(
'Email Account', dict(enable_incoming=1, default_incoming=1),
'email_id')
dataent.sendmail(recipients=get_users_email(doc),
message=doc.message,
subject=_(subject),
reference_doctype=project_update.doctype,
reference_name=project_update.name,
reply_to=incoming_email_account)
def test_sendmail(self):
dataent.sendmail(sender="*****@*****.**",
recipients="*****@*****.**",
content="test mail 001",
subject="test-mail-001",
delayed=False)
sent_mail = email.message_from_string(
dataent.safe_decode(dataent.flags.sent_mail))
self.assertTrue("test-mail-001" in sent_mail.get("Subject"))
def notify_customers(delivery_trip):
delivery_trip = dataent.get_doc("Delivery Trip", delivery_trip)
context = delivery_trip.as_dict()
if delivery_trip.driver:
context.update(
dataent.db.get_value("Driver",
delivery_trip.driver,
"cell_number",
as_dict=1))
email_recipients = []
for stop in delivery_trip.delivery_stops:
contact_info = dataent.db.get_value(
"Contact",
stop.contact, ["first_name", "last_name", "email_id"],
as_dict=1)
context.update({"items": []})
if stop.delivery_note:
items = dataent.get_all("Delivery Note Item",
filters={
"parent": stop.delivery_note,
"docstatus": 1
},
fields=["*"])
context.update({"items": items})
if contact_info and contact_info.email_id:
context.update(stop.as_dict())
context.update(contact_info)
dispatch_template_name = dataent.db.get_single_value(
"Delivery Settings", "dispatch_template")
dispatch_template = dataent.get_doc("Email Template",
dispatch_template_name)
dataent.sendmail(recipients=contact_info.email_id,
subject=dispatch_template.subject,
message=dataent.render_template(
dispatch_template.response, context),
attachments=get_attachments(stop))
stop.db_set("email_sent_to", contact_info.email_id)
email_recipients.append(contact_info.email_id)
if email_recipients:
dataent.msgprint(
_("Email sent to {0}").format(", ".join(email_recipients)))
delivery_trip.db_set("email_notification_sent", True)
else:
dataent.msgprint(_("No contacts with email IDs found."))
def backup_files_and_notify_user(user_email=None):
from dataent.utils.backups import backup
backup_files = backup(with_files=True)
get_downloadable_links(backup_files)
subject = _("File backup is ready")
dataent.sendmail(recipients=[user_email],
subject=subject,
template="file_backup_notification",
args=backup_files,
header=[subject, 'green'])
def send_summary(self):
'''Send summary of all replies. Called at midnight'''
args = self.get_message_details()
emails = get_user_emails_from_group(self.daily_work_summary_group)
dataent.sendmail(recipients=emails,
template='daily_work_summary',
args=args,
subject=_(self.daily_work_summary_group),
reference_doctype=self.doctype,
reference_name=self.name)
self.db_set('status', 'Sent')
def add_to_email_queue(context, email_path):
"Add an email to the Email Queue"
site = get_site(context)
if os.path.isdir(email_path):
with dataent.init_site(site):
dataent.connect()
for email in os.listdir(email_path):
with open(os.path.join(email_path, email)) as email_data:
kwargs = json.load(email_data)
kwargs['delayed'] = True
dataent.sendmail(**kwargs)
dataent.db.commit()
def email_setup_wizard_exception(traceback, args):
if not dataent.local.conf.setup_wizard_exception_email:
return
pretty_args = prettify_args(args)
if dataent.local.request:
user_agent = UserAgent(dataent.local.request.headers.get('User-Agent', ''))
else:
user_agent = dataent._dict()
message = """
#### Traceback
<pre>{traceback}</pre>
---
#### Setup Wizard Arguments
<pre>{args}</pre>
---
#### Request Headers
<pre>{headers}</pre>
---
#### Basic Information
- **Site:** {site}
- **User:** {user}
- **Browser:** {user_agent.platform} {user_agent.browser} version: {user_agent.version} language: {user_agent.language}
- **Browser Languages**: `{accept_languages}`""".format(
site=dataent.local.site,
traceback=traceback,
args="\n".join(pretty_args),
user=dataent.session.user,
user_agent=user_agent,
headers=dataent.local.request.headers,
accept_languages=", ".join(dataent.local.request.accept_languages.values()))
dataent.sendmail(recipients=dataent.local.conf.setup_wizard_exception_email,
sender=dataent.session.user,
subject="Setup failed: {}".format(dataent.local.site),
message=message,
delayed=False)
def send_mails(self, dws_group, emails):
'''Send emails to get daily work summary to all users \
in selected daily work summary group'''
incoming_email_account = dataent.db.get_value(
'Email Account', dict(enable_incoming=1, default_incoming=1),
'email_id')
self.db_set('email_sent_to', '\n'.join(emails))
dataent.sendmail(recipients=emails,
message=dws_group.message,
subject=dws_group.subject,
reference_doctype=self.doctype,
reference_name=self.name,
reply_to=incoming_email_account)
def notify_mentions(doc):
if doc.communication_type != "Comment":
return
if doc.reference_doctype and doc.reference_name and doc.content and doc.comment_type == "Comment":
mentions = extract_mentions(doc.content)
if not mentions:
return
sender_fullname = get_fullname(dataent.session.user)
title_field = dataent.get_meta(doc.reference_doctype).get_title_field()
title = doc.reference_name if title_field == "name" else \
dataent.db.get_value(doc.reference_doctype, doc.reference_name, title_field)
if title != doc.reference_name:
parent_doc_label = "{0}: {1} (#{2})".format(
_(doc.reference_doctype), title, doc.reference_name)
else:
parent_doc_label = "{0}: {1}".format(_(doc.reference_doctype),
doc.reference_name)
subject = _("{0} mentioned you in a comment").format(sender_fullname)
recipients = [
dataent.db.get_value("User", {
"enabled": 1,
"name": name,
"user_type": "System User"
}, "email") for name in mentions
]
link = get_link_to_form(doc.reference_doctype,
doc.reference_name,
label=parent_doc_label)
dataent.sendmail(recipients=recipients,
sender=dataent.session.user,
subject=subject,
template="mentioned_in_comment",
args={
"body_content":
_("{0} mentioned you in a comment in {1}").format(
sender_fullname, link),
"comment":
doc,
"link":
link
},
header=[_('New Mention'), 'orange'])
def send_email_notification(mr_list):
""" Notify user about auto creation of indent"""
email_list = dataent.db.sql_list("""select distinct r.parent
from `tabHas Role` r, tabUser p
where p.name = r.parent and p.enabled = 1 and p.docstatus < 2
and r.role in ('Purchase Manager','Stock Manager')
and p.name not in ('Administrator', 'All', 'Guest')""")
msg = dataent.render_template("templates/emails/reorder_item.html", {
"mr_list": mr_list
})
dataent.sendmail(recipients=email_list,
subject=_('Auto Material Requests Generated'), message = msg)
def monthly_updates():
translators = dataent.db.sql_list("""select distinct modified_by from
`tabTranslated Message`""")
message = dataent.get_template(
"/templates/emails/translator_update.md").render({"dataent": dataent})
# refer unsubscribe against the administrator
# document for test
dataent.sendmail(translators,
"EPAAS Translator <*****@*****.**>",
"Montly Update",
message,
bulk=True,
reference_doctype="User",
reference_name="Administrator")
def send_birthday_reminders():
"""Send Employee birthday reminders if no 'Stop Birthday Reminders' is not set."""
if int(
dataent.db.get_single_value("HR Settings",
"stop_birthday_reminders") or 0):
return
birthdays = get_employees_who_are_born_today()
if birthdays:
employee_list = dataent.get_all('Employee',
fields=['name', 'employee_name'],
filters={
'status': 'Active',
'company': birthdays[0]['company']
})
employee_emails = get_employee_emails(employee_list)
birthday_names = [name["employee_name"] for name in birthdays]
birthday_emails = [
email["user_id"] or email["personal_email"]
or email["company_email"] for email in birthdays
]
birthdays.append({
'company_email': '',
'employee_name': '',
'personal_email': '',
'user_id': ''
})
for e in birthdays:
if e['company_email'] or e['personal_email'] or e['user_id']:
if len(birthday_names) == 1:
continue
recipients = e['company_email'] or e['personal_email'] or e[
'user_id']
else:
recipients = list(set(employee_emails) - set(birthday_emails))
dataent.sendmail(
recipients=recipients,
subject=_("Birthday Reminder"),
message=get_birthday_reminder_message(e, birthday_names),
header=['Birthday Reminder', 'green'],
)
def subscribe(email):
url = dataent.utils.get_url("/api/method/dataent.email.doctype.newsletter.newsletter.confirm_subscription") +\
"?" + get_signed_params({"email": email})
messages = (
_("Thank you for your interest in subscribing to our updates"),
_("Please verify your Email Address"),
url,
_("Click here to verify")
)
content = """
<p>{0}. {1}.</p>
<p><a href="{2}">{3}</a></p>
"""
dataent.sendmail(email, subject=_("Confirm Your Email"), content=content.format(*messages))
def send_grant_review_emails(grant_application):
grant = dataent.get_doc("Grant Application", grant_application)
url = get_url('grant-application/{0}'.format(grant_application))
dataent.sendmail(
recipients=grant.assessment_manager,
sender=dataent.session.user,
subject='Grant Application for {0}'.format(grant.applicant_name),
message='<p> Please Review this grant application</p><br>' + url,
reference_doctype=grant.doctype,
reference_name=grant.name)
grant.status = 'In Progress'
grant.email_notification_sent = 1
grant.save()
dataent.db.commit()
dataent.msgprint(_("Review Invitation Sent"))
def send_welcome_email(self):
url = get_url("/project/?name={0}".format(self.name))
messages = (_(
"You have been invited to collaborate on the project: {0}".format(
self.name)), url, _("Join"))
content = """
<p>{0}.</p>
<p><a href="{1}">{2}</a></p>
"""
for user in self.users:
if user.welcome_email_sent == 0:
dataent.sendmail(user.user,
subject=_("Project Collaboration Invitation"),
content=content.format(*messages))
user.welcome_email_sent = 1
def notify_admin_access_to_system_manager(login_manager=None):
if (login_manager and login_manager.user == "Administrator"
and dataent.local.conf.notify_admin_access_to_system_manager):
site = '<a href="{0}" target="_blank">{0}</a>'.format(
dataent.local.request.host_url)
date_and_time = '<b>{0}</b>'.format(
format_datetime(now_datetime(), format_string="medium"))
ip_address = dataent.local.request_ip
access_message = _(
'Administrator accessed {0} on {1} via IP Address {2}.').format(
site, date_and_time, ip_address)
dataent.sendmail(recipients=get_system_managers(),
subject=_("Administrator Logged In"),
template="administrator_logged_in",
args={'access_message': access_message},
header=['Access Notification', 'orange'])
def send_auto_reply(self, communication, email):
"""Send auto reply if set."""
if self.enable_auto_reply:
set_incoming_outgoing_accounts(communication)
if self.send_unsubscribe_message:
unsubscribe_message = _("Leave this conversation")
else:
unsubscribe_message = ""
dataent.sendmail(recipients = [email.from_email],
sender = self.email_id,
reply_to = communication.incoming_email_account,
subject = _("Re: ") + communication.subject,
content = render_template(self.auto_reply_message or "", communication.as_dict()) or \
dataent.get_template("templates/emails/auto_reply.html").render(communication.as_dict()),
reference_doctype = communication.reference_doctype,
reference_name = communication.reference_name,
in_reply_to = email.mail.get("Message-Id"), # send back the Message-Id as In-Reply-To
unsubscribe_message = unsubscribe_message)
def send_email(success, service_name, error_status=None):
if success:
if dataent.db.get_value("S3 Backup Settings", None, "send_email_for_successful_backup") == '0':
return
subject = "Backup Upload Successful"
message = """<h3>Backup Uploaded Successfully! </h3><p>Hi there, this is just to inform you
that your backup was successfully uploaded to your Amazon S3 bucket. So relax!</p> """
else:
subject = "[Warning] Backup Upload Failed"
message = """<h3>Backup Upload Failed! </h3><p>Oops, your automated backup to Amazon S3 failed.
</p> <p>Error message: %s</p> <p>Please contact your system manager
for more information.</p>""" % error_status
if not dataent.db:
dataent.connect()
if dataent.db.get_value("S3 Backup Settings", None, "notification_email"):
recipients = split_emails(dataent.db.get_value("S3 Backup Settings", None, "notification_email"))
dataent.sendmail(recipients=recipients, subject=subject, message=message)
