def validate(self):
self._prev = frappe._dict(
{
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date")
if (not cint(self.get("__islocal")))
else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by")
if (not cint(self.get("__islocal")))
else None,
}
)
self.set_status()
self.check_email_id_is_unique()
if self.source == "Campaign" and not self.campaign_name and session["user"] != "Guest":
frappe.throw(_("Campaign Name is required"))
if self.email_id:
if not self.flags.ignore_email_validation:
validate_email_add(self.email_id, True)
if self.email_id == self.lead_owner:
# Lead Owner cannot be same as the Lead
self.lead_owner = None
self.image = has_gravatar(self.email_id)
def validate(self):
"""Validate email id and check POP3 and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if self.enable_incoming and not self.append_to:
frappe.throw(_("Append To is mandatory for incoming mails"))
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
if self.enable_incoming:
self.get_pop3()
if self.enable_outgoing:
self.check_smtp()
if self.notify_if_unreplied:
if not self.send_notification_to:
frappe.throw(_("{0} is mandatory").format(self.meta.get_label("send_notification_to")))
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
if self.enable_incoming and self.append_to:
valid_doctypes = [d[0] for d in get_append_to()]
if self.append_to not in valid_doctypes:
frappe.throw(_("Append To can be one of {0}").format(comma_or(valid_doctypes)))
def validate(self):
"""Validate email id and check POP3 and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if self.enable_incoming and not self.append_to:
frappe.throw(_("Append To is mandatory for incoming mails"))
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
if self.enable_incoming:
self.get_pop3()
if self.enable_outgoing:
self.check_smtp()
if self.notify_if_unreplied:
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
def validate(self):
self.set_lead_name()
self._prev = frappe._dict({
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
self.check_email_id_is_unique()
if self.email_id:
if not self.flags.ignore_email_validation:
validate_email_add(self.email_id, True)
if self.email_id == self.lead_owner:
frappe.throw(_("Lead Owner cannot be same as the Lead"))
if self.email_id == self.contact_by:
frappe.throw(_("Next Contact By cannot be same as the Lead Email Address"))
if self.is_new() or not self.image:
self.image = has_gravatar(self.email_id)
if self.contact_date and getdate(self.contact_date) < getdate(nowdate()):
frappe.throw(_("Next Contact Date cannot be in the past"))
def validate(self):
self._prev = frappe._dict({
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
self.check_email_id_is_unique()
if self.email_id:
if not self.flags.ignore_email_validation:
validate_email_add(self.email_id, True)
if self.email_id == self.lead_owner:
frappe.throw(_("Lead Owner cannot be same as the Lead"))
if self.email_id == self.contact_by:
frappe.throw(_("Next Contact By cannot be same as the Lead Email Address"))
if self.is_new() or not self.image:
self.image = has_gravatar(self.email_id)
if self.contact_date and getdate(self.contact_date) < getdate(nowdate()):
frappe.throw(_("Next Contact Date cannot be in the past"))
def validate(self):
self.check_email_id_is_unique()
validate_email_add(self.email_id, True)
if not self.applicant_name and self.email_id:
guess = self.email_id.split('@')[0]
self.applicant_name = ' '.join([p.capitalize() for p in guess.split('.')])
def validate(self):
"""Validate email id and check POP3 and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if self.enable_incoming and not self.append_to:
frappe.throw(_("Append To is mandatory for incoming mails"))
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
if self.enable_incoming:
self.get_pop3()
if self.enable_outgoing:
self.check_smtp()
if self.notify_if_unreplied:
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
def validate(self):
"""Validate email id and check POP3/IMAP and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if self.enable_incoming and not self.append_to:
frappe.throw(_("Append To is mandatory for incoming mails"))
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
if self.enable_incoming:
self.get_pop3()
if self.enable_outgoing:
self.check_smtp()
if self.notify_if_unreplied:
if not self.send_notification_to:
frappe.throw(_("{0} is mandatory").format(self.meta.get_label("send_notification_to")))
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
if self.enable_incoming and self.append_to:
valid_doctypes = [d[0] for d in get_append_to()]
if self.append_to not in valid_doctypes:
frappe.throw(_("Append To can be one of {0}").format(comma_or(valid_doctypes)))
def add_subscribers(name, email_list):
if not isinstance(email_list, (list, tuple)):
email_list = email_list.replace(",", "\n").split("\n")
count = 0
for email in email_list:
email = email.strip()
validate_email_add(email, True)
if email:
if not frappe.db.get_value("Newsletter List Subscriber", {
"newsletter_list": name,
"email": email
}):
frappe.get_doc({
"doctype": "Newsletter List Subscriber",
"newsletter_list": name,
"email": email
}).insert(ignore_permissions=frappe.flags.ignore_permissions)
count += 1
else:
pass
frappe.msgprint(_("{0} subscribers added").format(count))
return frappe.get_doc("Newsletter List", name).update_total_subscribers()
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = frappe.db.get_value(
"User", "Administrator", "full_name")
self.sender = frappe.db.get_value("User", "Administrator",
"email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
if self.sent_or_received == 'Sent':
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parseaddr(self.sender)
if not sender_name:
sender_name = get_fullname(sender_email)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or get_fullname(
frappe.session.user
) if frappe.session.user != 'Administrator' else None
def validate(self):
self.check_email_id_is_unique()
validate_email_add(self.email_id, True)
if not self.applicant_name and self.email_id:
guess = self.email_id.split('@')[0]
self.applicant_name = ' '.join([p.capitalize() for p in guess.split('.')])
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = frappe.db.get_value(
"User", "Administrator", "full_name")
self.sender = frappe.db.get_value("User", "Administrator",
"email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
if self.sent_or_received == 'Sent':
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parse_addr(self.sender)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name
if not self.sender_full_name:
self.sender_full_name = frappe.db.get_value(
'User', self.sender, 'full_name')
if not self.sender_full_name:
first_name, last_name = frappe.db.get_value(
'Contact',
filters={'email_id': sender_email},
fieldname=['first_name', 'last_name']) or [None, None]
self.sender_full_name = (first_name or '') + (last_name
or '')
if not self.sender_full_name:
self.sender_full_name = sender_email
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = self.sender
self.sender = frappe.db.get_value("User", "Administrator", "email")
else:
validate_email_add(self.sender, throw=True)
self.sender_full_name = get_fullname(self.sender)
def validate(self): validate_email_add(self.email_address.strip(), True) if self.residential_tel: validate_mobile(self.residential_tel) if self.office_tel: validate_mobile(self.office_tel) if self.mobile: validate_mobile(self.mobile)
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = self.sender
self.sender = frappe.db.get_value("User", "Administrator",
"email")
else:
validate_email_add(self.sender, throw=True)
self.sender_full_name = get_fullname(self.sender)
def validate(self):
"""Validate Email Address and check POP3/IMAP and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
duplicate_email_account = frappe.get_all("Email Account",
filters={
"email_id": self.email_id,
"name": ("!=", self.name)
})
if duplicate_email_account:
frappe.throw(
_("Email ID must be unique, Email Account already exists \
for {0}".format(frappe.bold(self.email_id))))
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
#if self.enable_incoming and not self.append_to:
# frappe.throw(_("Append To is mandatory for incoming mails"))
if (not self.awaiting_password and not frappe.local.flags.in_install
and not frappe.local.flags.in_patch):
if self.password or self.smtp_server in ('127.0.0.1', 'localhost'):
if self.enable_incoming:
self.get_incoming_server()
self.no_failed = 0
if self.enable_outgoing:
self.check_smtp()
else:
if self.enable_incoming or (self.enable_outgoing and
not self.no_smtp_authentication):
frappe.throw(
_("Password is required or select Awaiting Password"))
if self.notify_if_unreplied:
if not self.send_notification_to:
frappe.throw(
_("{0} is mandatory").format(
self.meta.get_label("send_notification_to")))
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
if self.enable_incoming and self.append_to:
valid_doctypes = [d[0] for d in get_append_to()]
if self.append_to not in valid_doctypes:
frappe.throw(
_("Append To can be one of {0}").format(
comma_or(valid_doctypes)))
def validate_email(doc): """Validate Email Addresses of Recipients and CC""" if not (doc.communication_type=="Communication" and doc.communication_medium == "Email"): return # validate recipients for email in split_emails(doc.recipients): validate_email_add(email, throw=True) # validate CC for email in split_emails(doc.cc): validate_email_add(email, throw=True)
def validate_emails(self):
'''Cleanup list of emails'''
if ',' in self.email_to:
self.email_to.replace(',', '\n')
valid = []
for email in self.email_to.split():
if email:
validate_email_add(email, True)
valid.append(email)
self.email_to = '\n'.join(valid)
def validate_emails(self):
'''Cleanup list of emails'''
if ',' in self.email_to:
self.email_to.replace(',', '\n')
valid = []
for email in self.email_to.split():
if email:
validate_email_add(email, True)
valid.append(email)
self.email_to = '\n'.join(valid)
def check_for_duplicate_email_id(user):
email_ids = user.split(',')
email_ids = [email for email in email_ids if email]
if email_ids:
email_count = Counter(email_ids)
for email_id, count in email_count.items():
validate_email_add(email_id, True)
if count > 1:
frappe.throw("Email Id {0} has been added {1} times".format(email_id, count))
return email_ids
else:
frappe.throw("Email Id is mandatory field")
def validate(self):
self.check_email_id_is_unique()
self.check_identity_is_unique()
if not self.company:
self.company = frappe.defaults.get_global_default("company")
if self.email_id:
validate_email_add(self.email_id, True)
if not self.applicant_name and self.email_id:
guess = self.email_id.split('@')[0]
self.applicant_name = ' '.join(
[p.capitalize() for p in guess.split('.')])
def validate_email(doc): """Validate Email Addresses of Recipients and CC""" if not (doc.communication_type=="Communication" and doc.communication_medium == "Email") or doc.flags.in_receive: return # validate recipients for email in split_emails(doc.recipients): validate_email_add(email, throw=True) # validate CC for email in split_emails(doc.cc): validate_email_add(email, throw=True)
def check_for_duplicate_email_id(user):
email_ids = user.split(',')
email_ids = [email for email in email_ids if email]
if email_ids:
email_count = Counter(email_ids)
for email_id, count in email_count.items():
validate_email_add(email_id, True)
if count > 1:
frappe.throw("Email Id {0} has been added {1} times".format(
email_id, count))
return email_ids
else:
frappe.throw("Email Id is mandatory field")
def validate(self):
self.check_email_id_is_unique()
if self.email_id:
validate_email_add(self.email_id, True)
if not self.applicant_name and self.email_id:
guess = self.email_id.split('@')[0]
self.applicant_name = ' '.join(
[p.capitalize() for p in guess.split('.')])
try:
datetime.datetime.strptime(self.birth_date, '%Y-%m-%d')
except ValueError:
frappe.throw("Date must be in format: dd-mm-yyyy")
def validate(self):
if self.get("__islocal"):
if self.reference_doctype and self.reference_name:
self.status = "Linked"
else:
self.status = "Open"
# validate recipients
for email in split_emails(self.recipients):
validate_email_add(email, throw=True)
# validate CC
for email in split_emails(self.cc):
validate_email_add(email, throw=True)
def validate(self):
if self.get("__islocal"):
if self.reference_doctype and self.reference_name:
self.status = "Linked"
else:
self.status = "Open"
# validate recipients
for email in split_emails(self.recipients):
validate_email_add(email, throw=True)
# validate CC
for email in split_emails(self.cc):
validate_email_add(email, throw=True)
def validate(self):
"""Validate Email Address and check POP3/IMAP and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if self.login_id_is_different:
if not self.login_id:
frappe.throw(_("Login Id is required"))
else:
self.login_id = None
duplicate_email_account = frappe.get_all("Email Account", filters={
"email_id": self.email_id,
"name": ("!=", self.name)
})
if duplicate_email_account:
frappe.throw(_("Email id must be unique, Email Account is already exist \
for {0}".format(frappe.bold(self.email_id))))
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
#if self.enable_incoming and not self.append_to:
# frappe.throw(_("Append To is mandatory for incoming mails"))
if (not self.awaiting_password and not frappe.local.flags.in_install
and not frappe.local.flags.in_patch):
if self.password or self.smtp_server in ('127.0.0.1', 'localhost'):
if self.enable_incoming:
self.get_incoming_server()
self.no_failed = 0
if self.enable_outgoing:
self.check_smtp()
else:
if self.enable_incoming or self.enable_outgoing:
frappe.throw(_("Password is required or select Awaiting Password"))
if self.notify_if_unreplied:
if not self.send_notification_to:
frappe.throw(_("{0} is mandatory").format(self.meta.get_label("send_notification_to")))
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
if self.enable_incoming and self.append_to:
valid_doctypes = [d[0] for d in get_append_to()]
if self.append_to not in valid_doctypes:
frappe.throw(_("Append To can be one of {0}").format(comma_or(valid_doctypes)))
def validate(self): """validate the email ids""" from frappe.utils import validate_email_add if not self.sender: self.sender = self.get_default_sender() validate_email_add(strip(self.sender), True) self.reply_to = validate_email_add(strip(self.reply_to) or self.sender, True) self.recipients = [strip(r) for r in self.recipients] self.cc = [strip(r) for r in self.cc] for e in self.recipients + (self.cc or []): validate_email_add(e, True)
def validate(self): """ Validations: 1.validate proper email 2.Same email id should not be entered by same user 3.Currently check that only users having trufil domain allowed(Remaining) 4.Check SMTP and POP """ if self.email_id: validate_email_add(self.email_id, True) self.validate_duplicate_emailid_config() if self.enabled: self.get_pop3() self.check_smtp()
def validate(self):
"""validate the email ids"""
from frappe.utils import validate_email_add
if not self.sender:
self.sender = self.get_default_sender()
validate_email_add(strip(self.sender), True)
self.reply_to = validate_email_add(strip(self.reply_to) or self.sender, True)
self.recipients = [strip(r) for r in self.recipients]
self.cc = [strip(r) for r in self.cc]
for e in self.recipients + (self.cc or []):
validate_email_add(e, True)
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if not (self.lead or
self.customer) and self.contact_email and validate_email_add(
self.contact_email):
lead_name = frappe.db.get_value("Lead",
{"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
if not sender_name and ('@' in self.contact_email):
email_name = self.contact_email.split('@')[0]
email_split = email_name.split('.')
sender_name = ''
for s in email_split:
sender_name += s.capitalize() + ' '
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name
})
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.enquiry_from = "Lead"
self.lead = lead_name
def make_new_lead_if_required(self):
"""Set lead against new opportunity"""
if not (self.lead or self.customer) and self.contact_email and validate_email_add(self.contact_email):
lead_name = frappe.db.get_value("Lead", {"email_id": self.contact_email})
if not lead_name:
sender_name = get_fullname(self.contact_email)
if sender_name == self.contact_email:
sender_name = None
if not sender_name and ('@' in self.contact_email):
email_name = self.contact_email.split('@')[0]
email_split = email_name.split('.')
sender_name = ''
for s in email_split:
sender_name += s.capitalize() + ' '
lead = frappe.get_doc({
"doctype": "Lead",
"email_id": self.contact_email,
"lead_name": sender_name
})
lead.insert(ignore_permissions=True)
lead_name = lead.name
self.enquiry_from = "Lead"
self.lead = lead_name
def validate(self):
self._prev = frappe._dict({
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
if self.source == 'Campaign' and not self.campaign_name and session['user'] != 'Guest':
frappe.throw(_("Campaign Name is required"))
if self.email_id:
if not validate_email_add(self.email_id):
frappe.throw(_('{0} is not a valid email id').format(self.email_id))
if self.email_id == self.lead_owner:
# Lead Owner cannot be same as the Lead
self.lead_owner = None
from frappe.utils import get_url, cstr
if self.get("__islocal") and get_url()=='http://tailorpad.com':
frappe.errprint("creating site from lead")
frappe.get_doc({
"doctype": "Site Master",
"client_name": self.company_name,
"site_name": self.company_name,
"email_id__if_administrator": self.email_id,
"country": self.country
}).insert()
def validate(self):
self._prev = frappe._dict({
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
if self.source == 'Campaign' and not self.campaign_name and session[
'user'] != 'Guest':
frappe.throw(_("Campaign Name is required"))
if self.email_id:
if not validate_email_add(self.email_id):
frappe.throw(
_('{0} is not a valid email id').format(self.email_id))
if self.email_id == self.lead_owner:
# Lead Owner cannot be same as the Lead
self.lead_owner = None
from frappe.utils import get_url, cstr
if self.get("__islocal") and get_url() == 'http://tailorpad.com':
frappe.errprint("creating site from lead")
frappe.get_doc({
"doctype": "Site Master",
"client_name": self.company_name,
"site_name": self.company_name,
"email_id__if_administrator": self.email_id,
"country": self.country
}).insert()
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = frappe.db.get_value("User", "Administrator", "full_name")
self.sender = frappe.db.get_value("User", "Administrator", "email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
if self.sent_or_received=='Sent':
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parse_addr(self.sender)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or frappe.db.exists("Contact", {"email_id": sender_email}) or sender_email
def evaluate_alert(doc, alert, event):
if isinstance(alert, basestring):
alert = frappe.get_doc("Email Alert", alert)
if alert.condition:
if not eval(alert.condition, {"doc": doc}):
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.email_alert_recipients:
recipients = []
if recipient.condition:
if not eval(recipient.condition, {"doc": doc}):
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
template = alert.message + footer
# send alert
frappe.sendmail(recipients=recipients, subject=alert.subject,
message= frappe.render_template(template, {"doc": doc, "alert":alert}),
bulk=True, ref_doctype = doc.doctype, ref_docname = doc.name)
def add_subscribers(name, email_list):
if not isinstance(email_list, (list, tuple)):
email_list = email_list.replace(",", "\n").split("\n")
count = 0
for email in email_list:
email = email.strip()
parsed_email = validate_email_add(email, False)
if parsed_email:
if not frappe.db.get_value("Email Group Member",
{"email_group": name, "email": parsed_email}):
frappe.get_doc({
"doctype": "Email Group Member",
"email_group": name,
"email": parsed_email
}).insert(ignore_permissions = frappe.flags.ignore_permissions)
count += 1
else:
pass
else:
frappe.msgprint(_("{0} is not a valid Email Address").format(email))
frappe.msgprint(_("{0} subscribers added").format(count))
return frappe.get_doc("Email Group", name).update_total_subscribers()
def validate(self): """ Validations: 1.validate proper email 2.Same email id should not be entered by same user 3.Currently check that only users having trufil domain allowed(Remaining) 4.Check SMTP and POP """ if self.email_id: validate_email_add(self.email_id, True) self.valid_trufil_id() self.validate_duplicate_emailid_config() if self.enabled: self.get_imap() self.check_smtp()
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = frappe.db.get_value("User", "Administrator", "full_name")
self.sender = frappe.db.get_value("User", "Administrator", "email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
if self.sent_or_received=='Sent':
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parse_addr(self.sender)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or get_fullname(frappe.session.user) if frappe.session.user!='Administrator' else None
def add_subscribers(name, email_list):
if not isinstance(email_list, (list, tuple)):
email_list = email_list.replace(",", "\n").split("\n")
count = 0
for email in email_list:
email = email.strip()
valid = validate_email_add(email, False)
if valid:
if not frappe.db.get_value("Newsletter List Subscriber",
{"newsletter_list": name, "email": email}):
frappe.get_doc({
"doctype": "Newsletter List Subscriber",
"newsletter_list": name,
"email": email
}).insert(ignore_permissions = frappe.flags.ignore_permissions)
count += 1
else:
pass
else:
frappe.msgprint(_("{0} is not a valid email id").format(email))
frappe.msgprint(_("{0} subscribers added").format(count))
return frappe.get_doc("Newsletter List", name).update_total_subscribers()
def add_subscribers(name, email_list):
if not isinstance(email_list, (list, tuple)):
email_list = email_list.replace(",", "\n").split("\n")
count = 0
for email in email_list:
email = email.strip()
parsed_email = validate_email_add(email, False)
if parsed_email:
if not frappe.db.get_value("Email Group Member", {
"email_group": name,
"email": parsed_email
}):
frappe.get_doc({
"doctype": "Email Group Member",
"email_group": name,
"email": parsed_email
}).insert(ignore_permissions=frappe.flags.ignore_permissions)
count += 1
else:
pass
else:
frappe.msgprint(
_("{0} is not a valid Email Address").format(email))
frappe.msgprint(_("{0} subscribers added").format(count))
return frappe.get_doc("Email Group", name).update_total_subscribers()
def get_list_of_recipients(self, doc, context):
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:
email_ids_value = doc.get(recipient.email_by_document_field)
if validate_email_add(email_ids_value):
email_ids = email_ids_value.replace(",", "\n")
recipients = recipients + email_ids.split("\n")
# else:
# print "invalid email"
if recipient.cc and "{" in recipient.cc:
recipient.cc = frappe.render_template(recipient.cc, context)
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
return list(set(recipients))
def _validate(email):
"""validate an email field"""
if email and not validate_email_add(email):
throw(
_("{0} is not a valid email id").format(email),
frappe.InvalidEmailAddressError)
return email
def validate(self): """validate the Email Addresses""" from frappe.utils import validate_email_add if not self.sender: self.sender = self.email_account.default_sender validate_email_add(strip(self.sender), True) self.reply_to = validate_email_add(strip(self.reply_to) or self.sender, True) self.replace_sender() self.recipients = [strip(r) for r in self.recipients] self.cc = [strip(r) for r in self.cc] for e in self.recipients + (self.cc or []): validate_email_add(e, True)
def validate_cc_and_bcc(mailbox_doc,return_dic):
for recipients in [get_recipients(mailbox_doc['cc']),get_recipients(mailbox_doc['bcc'])]:
for recipient in recipients:
if recipient and not validate_email_add(recipient):
return_dic.update({"not_valid":"'%s' not valid Email Address"%recipient})
return False
return True
def validate(self): """validate the Email Addresses""" from frappe.utils import validate_email_add if not self.sender: self.sender = self.email_account.default_sender validate_email_add(strip(self.sender), True) self.reply_to = validate_email_add(strip(self.reply_to) or self.sender, True) self.replace_sender() self.recipients = [strip(r) for r in self.recipients] self.cc = [strip(r) for r in self.cc] for e in self.recipients + (self.cc or []): validate_email_add(e, True)
def _validate(email):
"""validate an email field"""
if email and not validate_email_add(email):
throw(
"{email} {msg}".format(**{
"email": email,
"msg": _("is not a valid email id")
}))
return email
def validate(self):
"""Validate email id and check POP3 and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
if self.enable_incoming:
self.get_pop3()
if self.enable_outgoing:
self.check_smtp()
if self.notify_if_unreplied:
for e in self.get_unreplied_notification_emails():
validate_email_add(e, True)
def validate_email_type(self, email):
from frappe.utils import validate_email_add
email = email.strip()
if not validate_email_add(email):
throw("{email} {msg}".format(**{
"email": email,
"msg": _("is not a valid email id")
}))
def validate(self):
self.set_status()
if self.doc.source == 'Campaign' and not self.doc.campaign_name and session['user'] != 'Guest':
frappe.throw("Please specify campaign name")
if self.doc.email_id:
if not validate_email_add(self.doc.email_id):
frappe.throw('Please enter valid email id.')
def validate(self): """Validate email id and check POP3 and SMTP connections is enabled.""" if self.email_id: validate_email_add(self.email_id, True) if frappe.local.flags.in_patch or frappe.local.flags.in_test: return if not frappe.local.flags.in_install and not frappe.local.flags.in_patch: if self.enable_incoming: self.get_pop3() if self.enable_outgoing: self.check_smtp() if self.notify_if_unreplied: for e in self.get_unreplied_notification_emails(): validate_email_add(e, True)
def validate(self):
"""Validate email id and check POP3/IMAP and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
try:
if self.use_imap:
if self.use_ssl:
test = imaplib.IMAP4_SSL(self.email_server)
else:
test = imaplib.IMAP4(self.email_server)
else:
if self.use_ssl:
test = poplib.POP3_SSL(self.email_server)
else:
test = poplib.POP3(self.email_server)
except Exception:
frappe.throw("Incoming email account not correct")
return None
finally:
try:
if self.use_imap:
test.logout()
else:
test.quit()
except Exception:
pass
try:
if self.use_tls and not self.smtp_port:
self.port = 587
sess = smtplib.SMTP((self.smtp_server or "").encode('utf-8'),
cint(self.smtp_port) or None)
sess.quit()
except Exception as e:
frappe.throw("Outgoing email account not correct")
return None
return
def validate(self):
"""Validate email id and check POP3/IMAP and SMTP connections is enabled."""
if self.email_id:
validate_email_add(self.email_id, True)
if frappe.local.flags.in_patch or frappe.local.flags.in_test:
return
if not frappe.local.flags.in_install and not frappe.local.flags.in_patch:
try:
if self.use_imap:
if self.use_ssl:
test = imaplib.IMAP4_SSL(self.email_server)
else:
test = imaplib.IMAP4(self.email_server)
else:
if self.use_ssl:
test = poplib.POP3_SSL(self.email_server)
else:
test = poplib.POP3(self.email_server)
except Exception:
frappe.throw(_("Incoming email account not correct"))
return None
finally:
try:
if self.use_imap:
test.logout()
else:
test.quit()
except Exception:
pass
try:
if self.use_tls and not self.smtp_port:
self.smtp_port = 587
sess = smtplib.SMTP((self.smtp_server or "").encode('utf-8'), cint(self.smtp_port) or None)
sess.quit()
except Exception:
frappe.throw(_("Outgoing email account not correct"))
return None
return
def set_sender_full_name(self):
if not self.sender_full_name and self.sender:
if self.sender == "Administrator":
self.sender_full_name = self.sender
self.sender = frappe.db.get_value("User", "Administrator", "email")
elif self.sender == "Guest":
self.sender_full_name = self.sender
self.sender = None
else:
validate_email_add(self.sender, throw=True)
sender_name, sender_email = parseaddr(self.sender)
if not sender_name:
sender_name = get_fullname(sender_email)
if sender_name == sender_email:
sender_name = None
self.sender = sender_email
self.sender_full_name = sender_name or get_fullname(frappe.session.user)
def validate(self):
self._prev = frappe._dict({
"contact_date": frappe.db.get_value("Lead", self.name, "contact_date") if \
(not cint(self.get("__islocal"))) else None,
"contact_by": frappe.db.get_value("Lead", self.name, "contact_by") if \
(not cint(self.get("__islocal"))) else None,
})
self.set_status()
self.check_email_id_is_unique()
if self.source == 'Campaign' and not self.campaign_name and session['user'] != 'Guest':
frappe.throw(_("Campaign Name is required"))
if self.email_id:
validate_email_add(self.email_id, True)
if self.email_id == self.lead_owner:
# Lead Owner cannot be same as the Lead
self.lead_owner = None
def validate_email_id(self):
if self.notify_by_email:
if self.recipients:
email_list = split_emails(self.recipients.replace("\n", ""))
from frappe.utils import validate_email_add
for email in email_list:
if not validate_email_add(email):
frappe.throw(_("{0} is an invalid email address in 'Recipients'").format(email))
else:
frappe.throw(_("'Recipients' not specified"))
def validate(self):
if self.date_of_birth and self.date_of_visit and getdate(self.date_of_birth) >= getdate(self.date_of_visit):
frappe.throw(_("Date of First Visit '{0}' must be greater than Date of Birth '{1}'").format(self.date_of_visit, self.date_of_birth))
# if self.baptisum_status=='Yes':
# if not self.baptism_when or not self.baptism_where :
# frappe.throw(_("When and Where is Mandatory if 'Baptisum Status' is 'Yes'..!"))
if self.email_id:
if not validate_email_add(self.email_id):
frappe.throw(_('{0} is not a valid email id').format(self.email_id))
def validate_notification_email_id(self):
if self.notification_email_address:
email_list = filter(None, [cstr(email).strip() for email in
self.notification_email_address.replace("\n", "").split(",")])
from frappe.utils import validate_email_add
for email in email_list:
if not validate_email_add(email):
throw(_("{0} is an invalid email address in 'Notification Email Address'").format(email))
else:
throw(_("'Notification Email Addresses' not specified for recurring invoice"))
def validate_birth(doc,method):
#frappe.errprint("in date of birth ")
if doc.date_of_birth and doc.date_of_join and getdate(doc.date_of_birth) >= getdate(doc.date_of_join):
frappe.throw(_("Date of Joining '{0}' must be greater than Date of Birth '{1}'").format(doc.date_of_join, doc.date_of_birth))
# if doc.baptisum_status=='Yes':
# if not doc.baptism_when or not doc.baptism_where :
# frappe.throw(_("When and Where is Mandatory if 'Baptisum Status' is 'Yes'..!"))
if doc.email_id:
if not validate_email_add(doc.email_id):
frappe.throw(_('{0} is not a valid email id').format(doc.email_id))
def validate(self): if self.email_address: validate_email_add(self.email_address.strip(), True) if self.residential_tel: validate_mobile(self.residential_tel) if self.office_tel: validate_mobile(self.office_tel) if self.mobile: validate_mobile(self.mobile) if self.is_directory: if self.s_email_address: validate_email_add(self.s_email_address.strip(), True) if self.s_residential_number: validate_mobile(self.s_residential_number) if self.s_office_number: validate_mobile(self.s_office_number) if self.s_mobile_number: validate_mobile(self.s_mobile_number) for d in self.bod: if d.email_address: validate_email_add(d.email_address.strip(), True) if d.mobile_number: validate_mobile(d.mobile_number)
