def confirm_payment(token):
paypal_express_payment = frappe.get_doc("Paypal Express Payment", token)
params = get_paypal_params()
params.update({
"METHOD": "DoExpressCheckoutPayment",
"PAYERID": paypal_express_payment.payerid,
"TOKEN": paypal_express_payment.token,
"PAYMENTREQUEST_0_PAYMENTACTION": "SALE",
"PAYMENTREQUEST_0_AMT": paypal_express_payment.amount,
"PAYMENTREQUEST_0_CURRENCYCODE": paypal_express_payment.currency
})
try:
get_api_response(params)
paypal_express_payment = frappe.get_doc("Paypal Express Payment", token)
paypal_express_payment.status = "Completed"
paypal_express_payment.save(ignore_permissions=True)
if paypal_express_payment.reference_doctype and paypal_express_payment.reference_docname:
frappe.get_doc(paypal_express_payment.reference_doctype,
paypal_express_payment.reference_docname).run_method("set_paid")
frappe.db.commit()
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url("/paypal-express-success")
except PaypalException:
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url("/paypal-express-cancel")
def get_activities():
from frappe.utils import get_url, cstr
frappe.errprint(get_url())
frappe.errprint("in activities")
if get_url()=='http://tailorpad.com':
frappe.errprint("in the get_activities")
dbname=frappe.db.sql("""select site_name from `tabSubAdmin Info` where active=1""",as_dict=1)
frappe.errprint("dbname")
lst=[]
qry_srt='select feed_type,subject,site_name,creation from('
for key in dbname:
frappe.errprint("key")
temp =key['site_name']
if temp.find('.')!= -1:
temp1=temp.split('.')[0][:16]
else:
temp1=temp[:16]
qry="SELECT subject,creation,feed_type,'%s' as site_name FROM "%(temp)
if temp :
qry+=temp1+'.tabFeed'
lst.append(qry)
fin_qry=' UNION '.join(lst)
frappe.errprint("fin qry")
qry=qry_srt+fin_qry+" where doc_name='Administrator')foo ORDER BY creation desc limit 10"
frappe.errprint(qry)
act_details=frappe.db.sql(fin_qry,as_dict=1)
frappe.errprint(act_details)
if act_details:
frappe.errprint(act_details)
return act_details
else:
return ' '
def get_activities():
from frappe.utils import get_url, cstr
frappe.errprint(get_url())
frappe.errprint("in activities")
if get_url()=='http://stich1.tailorpad.com':
frappe.errprint("in the get_activities")
dbname=frappe.db.sql("""select site_name from `tabSubAdmin Info` where active=1""",as_dict=1)
frappe.errprint("dbname")
lst=[]
#qry_srt='select feed_type,subject,site_name,creation from('
qry_srt="""SELECT CASE WHEN feed_type='Login' THEN concat('Administrator logged in at ', substring(creation,1,19),' in site "',site_name,'"') ELSE concat('Administrator updated the form "',doc_type,'" name "',doc_name,'" at ' , substring(creation,1,19),' in site "',site_name,'"') END as `ss` from("""
for key in dbname:
frappe.errprint("key")
temp =key['site_name']
if temp.find('.')!= -1:
temp1=temp.split('.')[0][:16]
else:
temp1=temp[:16]
#qry="SELECT subject,creation,feed_type,'%s' as site_name FROM "%(temp)
qry="SELECT doc_name,doc_type,creation,feed_type,'%s' as site_name FROM "%(temp)
if temp :
qry+=temp1+'.tabFeed'
lst.append(qry)
fin_qry=' UNION '.join(lst)
frappe.errprint("fin qry")
qry=qry_srt+fin_qry+" where doc_name='Administrator')foo ORDER BY creation desc limit 10"
frappe.errprint(qry)
act_details=frappe.db.sql(qry,as_dict=1)
frappe.errprint(act_details)
if act_details:
frappe.errprint(act_details)
return act_details
else:
return ' '
def send_email(self):
"""
Sends the link to backup file located at erpnext/backups
"""
from frappe.email import sendmail, 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"""
sendmail(recipients=recipient_list, msg=msg, subject=subject)
return recipient_list
def get_redirect_uri(doc, token, payerid):
data = json.loads(doc.data)
if data.get("subscription_details") or data.get("subscription_id"):
return get_url("{0}.create_recurring_profile?token={1}&payerid={2}".format(api_path, token, payerid))
else:
return get_url("{0}.confirm_payment?token={1}".format(api_path, token))
def send_welcome_mail_to_user(self):
from frappe.utils import random_string, get_url
key = random_string(32)
self.db_set("reset_password_key", key)
link = get_url("/update-password?key=" + key)
self.send_login_mail(_("Verify Your Account"), "templates/emails/new_user.html",
{"link": link, "site_url": get_url()})
def send_welcome_mail(self):
from frappe.utils import random_string, get_url
key = random_string(32)
self.db_set("reset_password_key", key)
link = get_url("/update-password?key=" + key)
from frappe.utils import get_url, cstr
frappe.errprint(get_url())
if get_url()=='http://tailorpad.com':
self.send_login_mail2("Verify Your Account",link)
else:
self.send_login_mail("Verify Your Account", "templates/emails/new_user.html", {"link": link})
def getEmergencyDetails(data):
data = json.loads(data)
from templates.pages.dashboard import get_user_details
user_details = get_user_details(data.get('profile_id'))
if user_details.get('error'):
return user_details
user_details['barcode'] = get_url() + user_details['barcode']
if 'files' in user_details['user_image']:
user_details['user_image'] = get_url() + user_details['user_image']
return user_details
def execute_set_express_checkout(amount, currency):
params = get_paypal_params()
params.update({
"METHOD": "SetExpressCheckout",
"PAYMENTREQUEST_0_PAYMENTACTION": "SALE",
"PAYMENTREQUEST_0_AMT": amount,
"PAYMENTREQUEST_0_CURRENCYCODE": currency
})
return_url = get_url("/api/method/paypal_integration.express_checkout.get_express_checkout_details")
params = urlencode(params) + \
"&returnUrl={0}&cancelUrl={1}".format(return_url, get_url("/paypal-express-cancel"))
return get_api_response(params.encode("utf-8"))
def trigger_ref_doc(paypal_express_payment, method):
if paypal_express_payment.reference_doctype and paypal_express_payment.reference_docname:
ref_doc = frappe.get_doc(paypal_express_payment.reference_doctype,
paypal_express_payment.reference_docname)
ref_doc.run_method(method)
if method != "set_as_cancelled":
frappe.local.response["type"] = "redirect"
if ref_doc.make_sales_invoice:
success_url = ref_doc.get_payment_success_url()
if success_url:
frappe.local.response["location"] = get_url("/{0}".format(success_url))
else:
frappe.local.response["location"] = get_url("/order/{0}".format(ref_doc.reference_name))
else:
frappe.local.response["location"] = get_url("/paypal-express-success")
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 test_insert_many(self):
from frappe.frappeclient import FrappeClient
frappe.db.sql('delete from `tabToDo` where description like "Test API%"')
frappe.db.commit()
host = get_url()
if not host.startswith('http'):
host = 'http://' + host
if not host.endswith(':8000'):
host = host + ':8000'
server = FrappeClient(host, "Administrator", "admin", verify=False)
server.insert_many([
{"doctype": "ToDo", "description": "Test API 1"},
{"doctype": "ToDo", "description": "Test API 2"},
{"doctype": "ToDo", "description": "Test API 3"},
])
self.assertTrue(frappe.db.get_value('ToDo', {'description': 'Test API 1'}))
self.assertTrue(frappe.db.get_value('ToDo', {'description': 'Test API 2'}))
self.assertTrue(frappe.db.get_value('ToDo', {'description': 'Test API 3'}))
def on_payment_authorized(self, status=None):
if not status:
return
shopping_cart_settings = frappe.get_doc("Shopping Cart Settings")
if status in ["Authorized", "Completed"]:
redirect_to = None
self.run_method("set_as_paid")
# if shopping cart enabled and in session
if (shopping_cart_settings.enabled and hasattr(frappe.local, "session")
and frappe.local.session.user != "Guest"):
success_url = shopping_cart_settings.payment_success_url
if success_url:
redirect_to = ({
"Orders": "orders",
"Invoices": "invoices",
"My Account": "me"
}).get(success_url, "me")
else:
redirect_to = get_url("/orders/{0}".format(self.reference_name))
return redirect_to
def _send_gstin_reminder(party_type, party, default_email_id=None, sent_to=None):
'''Send GST Reminder email'''
email_id = frappe.db.get_value('Contact', get_default_contact(party_type, party), 'email_id')
if not email_id:
# get email from address
email_id = default_email_id
if not email_id:
frappe.throw('Email not found in default contact', exc=EmailMissing)
if sent_to and email_id in sent_to:
return
frappe.sendmail(
subject='Please update your GSTIN',
recipients=email_id,
message='''
<p>Hello,</p>
<p>Please help us send you GST Ready Invoices.</p>
<p>
<a href="{0}?party={1}">
Click here to update your GSTIN Number in our system
</a>
</p>
<p style="color: #aaa; font-size: 11px; margin-top: 30px;">
Get your GST Ready ERP system at <a href="https://erpnext.com">https://erpnext.com</a>
<br>
ERPNext is a free and open source ERP system.
</p>
'''.format(os.path.join(get_url(), '/regional/india/update-gstin'), party)
)
return email_id
def send_login_mail(self, subject, template, add_args):
"""send mail with login details"""
from frappe.utils.user import get_user_fullname
from frappe.utils import get_url
mail_titles = frappe.get_hooks().get("login_mail_title", [])
title = frappe.db.get_default('company') or (mail_titles and mail_titles[0]) or ""
full_name = get_user_fullname(frappe.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': title,
'login_url': get_url(),
'user_fullname': full_name
}
args.update(add_args)
sender = frappe.session.user not in STANDARD_USERS and frappe.session.user or None
frappe.sendmail(recipients=self.email, sender=sender, subject=subject,
message=frappe.get_template(template).render(args), as_bulk=self.flags.delay_emails)
def send_welcome_mail(password,profile_id,args, send_sms=True, is_provider=False):
from frappe.utils import random_string, get_url
key = random_string(32)
db_set(args,"reset_password_key", key)
link = get_url("/verify_email?id="+profile_id+"&key=" + key)
mob_code = get_mob_code()
update_verification_details(args,password,key,mob_code,link,profile_id, is_provider)
mail_response = send_login_mail(args,"Verify Your Account", "templates/emails/new_user.html", {"link": link,"password":password,"verify_sms":send_sms})
if send_sms:
mob_already_v = frappe.db.get_value("Mobile Verification",{"mobile_no":args["mobile"],"mflag":1},"name")
if not mob_already_v:
from phr.templates.pages.profile import make_mobile_verification_entry
if not frappe.db.get_value("Mobile Verification",{"mobile_no":args["mobile"]},"name"):
make_mobile_verification_entry(args["mobile"],profile_id,mob_code)
else:
pass
from phr.templates.pages.utils import get_sms_template
sms = get_sms_template("registration",{ "mobile_code": mob_code })
rec_list = []
rec_list.append(args["mobile"])
from erpnext.setup.doctype.sms_settings.sms_settings import send_sms
send_sms(rec_list,sms)
elif mob_already_v:
vd = frappe.get_doc("Verification Details",profile_id)
vd.mflag = 1
vd.save(ignore_permissions=True)
return mail_response
def send_login_mail(self, subject, template, add_args, now=None):
"""send mail with login details"""
from frappe.utils.user import get_user_fullname
from frappe.utils import get_url
mail_titles = frappe.get_hooks().get("login_mail_title", [])
title = frappe.db.get_default('company') or (mail_titles and mail_titles[0]) or ""
full_name = get_user_fullname(frappe.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': title,
'login_url': get_url(),
'user_fullname': full_name
}
args.update(add_args)
sender = frappe.session.user not in STANDARD_USERS and get_formatted_email(frappe.session.user) or None
frappe.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 get_express_checkout_details(token):
params = get_paypal_params()
params.update({
"METHOD": "GetExpressCheckoutDetails",
"TOKEN": token
})
response = get_api_response(params)
if not response["success"]:
paypal_log(response, params)
frappe.db.commit()
frappe.respond_as_web_page(_("Something went wrong"),
_("Looks like something went wrong during the transaction. Since we haven't confirmed the payment, Paypal will automatically refund you this amount. If it doesn't, please send us an email and mention the Correlation ID: {0}.").format(response.get("CORRELATIONID", [None])[0]),
success=False,
http_status_code=frappe.ValidationError.http_status_code)
return
paypal_express_payment = frappe.get_doc("Paypal Express Payment", token)
paypal_express_payment.payerid = response.get("PAYERID")[0]
paypal_express_payment.payer_email = response.get("EMAIL")[0]
paypal_express_payment.status = "Verified"
paypal_express_payment.save(ignore_permissions=True)
frappe.db.commit()
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url( \
"/api/method/paypal_integration.express_checkout.confirm_payment?token="+paypal_express_payment.token)
def send_welcome_mail_to_user(self):
from frappe.utils import get_url
link = self.reset_password()
self.send_login_mail(_("Verify Your Account"), "templates/emails/new_user.html",
{"link": link, "site_url": get_url()})
def get_express_checkout_details(token):
try:
doc = frappe.get_doc("PayPal Settings")
doc.setup_sandbox_env(token)
params, url = doc.get_paypal_params_and_url()
params.update({
"METHOD": "GetExpressCheckoutDetails",
"TOKEN": token
})
response = make_post_request(url, data=params)
if response.get("ACK")[0] != "Success":
frappe.respond_as_web_page(_("Something went wrong"),
_("Looks like something went wrong during the transaction. Since we haven't confirmed the payment, Paypal will automatically refund you this amount. If it doesn't, please send us an email and mention the Correlation ID: {0}.").format(response.get("CORRELATIONID", [None])[0]),
indicator_color='red',
http_status_code=frappe.ValidationError.http_status_code)
return
update_integration_request_status(token, {
"payerid": response.get("PAYERID")[0],
"payer_email": response.get("EMAIL")[0]
}, "Authorized")
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url( \
"/api/method/frappe.integrations.doctype.paypal_settings.paypal_settings.confirm_payment?token={0}".format(token))
except Exception:
frappe.log_error(frappe.get_traceback())
def get_values(data,entityid=None):
if entityid:
url=get_url(data)
args=get_args(entityid)
values=get_data(url,args)
return values
return {}
def send_login_mail(self, subject, template, add_args, now=None):
"""send mail with login details"""
from frappe.utils.user import get_user_fullname
from frappe.utils import get_url
mail_titles = frappe.get_hooks().get("login_mail_title", [])
title = frappe.db.get_default("company") or (mail_titles and mail_titles[0]) or ""
full_name = get_user_fullname(frappe.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": title,
"login_url": get_url(),
"user_fullname": full_name,
}
args.update(add_args)
sender = frappe.session.user not in STANDARD_USERS and get_formatted_email(frappe.session.user) or None
frappe.sendmail(
recipients=self.email,
sender=sender,
subject=subject,
message=frappe.get_template(template).render(args),
delayed=(not now) if now != None else self.flags.delay_emails,
)
def get_ticket_details(self):
# return frappe.get_doc('Support Ticket', self.name)
response = requests.get("""%(url)s/api/resource/Support Ticket/SUP-00001"""%{'url':get_url()})
# frappe.errprint(["""%(url)s/api/resource/Support Ticket/%(name)s"""%{'url':get_url(), 'name':self.name}])
frappe.errprint(response.text)
return eval(response.text).get('data')
def assing_future(name, assign_in_future,raised_by,assign_to):
frappe.errprint("in assign future")
from frappe.utils import get_url, cstr
if get_url()=='http://tailorpad.com':
check_entry = frappe.db.sql("""select assign_to from `tabAssing Master` where name = %s """, raised_by)
frappe.errprint("in assign")
if check_entry :
frappe.errprint("chk")
if assign_in_future=='No':
frappe.errprint("no")
frappe.db.sql("""delete from `tabAssing Master` where name = %s """, raised_by)
else :
frappe.errprint("Yes")
frappe.db.sql("""update `tabAssing Master` set assign_to=%s where name = %s """,(assign_to,raised_by))
else :
frappe.errprint("not chk")
if assign_in_future=='Yes':
frappe.errprint("Yes")
am = frappe.new_doc("Assing Master")
am.update({
"name": raised_by,
"assign_to": assign_to,
"raised_by":raised_by
})
am.insert()
def confirm_payment(token):
paypal_express_payment = frappe.get_doc("Paypal Express Payment", token)
params = get_paypal_params()
params.update({
"METHOD": "DoExpressCheckoutPayment",
"PAYERID": paypal_express_payment.payerid,
"TOKEN": paypal_express_payment.token,
"PAYMENTREQUEST_0_PAYMENTACTION": "SALE",
"PAYMENTREQUEST_0_AMT": paypal_express_payment.amount,
"PAYMENTREQUEST_0_CURRENCYCODE": paypal_express_payment.currency
})
try:
response = get_api_response(params)
except PaypalException, e:
frappe.db.rollback()
frappe.get_doc({
"doctype": "Paypal Log",
"error": "{e}\n\n{traceback}".format(e=e, traceback=frappe.get_traceback()),
"params": frappe.as_json(params)
}).insert(ignore_permissions=True)
frappe.db.commit()
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url("/paypal-express-failed")
def get_bootinfo():
"""build and return boot info"""
frappe.set_user_lang(frappe.session.user)
bootinfo = frappe._dict()
hooks = frappe.get_hooks()
doclist = []
# user
get_user(bootinfo)
# system info
bootinfo['sysdefaults'] = frappe.defaults.get_defaults()
bootinfo['server_date'] = frappe.utils.nowdate()
if frappe.session['user'] != 'Guest':
bootinfo['user_info'] = get_fullnames()
bootinfo['sid'] = frappe.session['sid'];
# home page
bootinfo.modules = {}
for app in frappe.get_installed_apps():
try:
bootinfo.modules.update(frappe.get_attr(app + ".config.desktop.get_data")() or {})
except ImportError:
pass
except AttributeError:
pass
bootinfo.module_app = frappe.local.module_app
bootinfo.hidden_modules = frappe.db.get_global("hidden_modules")
bootinfo.doctype_icons = dict(frappe.db.sql("""select name, icon from
tabDocType where ifnull(icon,'')!=''"""))
bootinfo.single_types = frappe.db.sql_list("""select name from tabDocType where ifnull(issingle,0)=1""")
add_home_page(bootinfo, doclist)
bootinfo.page_info = get_allowed_pages()
load_translations(bootinfo)
add_timezone_info(bootinfo)
load_conf_settings(bootinfo)
load_print(bootinfo, doclist)
doclist.extend(get_meta_bundle("Page"))
# ipinfo
if frappe.session['data'].get('ipinfo'):
bootinfo['ipinfo'] = frappe.session['data']['ipinfo']
# add docs
bootinfo['docs'] = doclist
for method in hooks.boot_session or []:
frappe.get_attr(method)(bootinfo)
if bootinfo.lang:
bootinfo.lang = unicode(bootinfo.lang)
bootinfo['versions'] = {k: v['version'] for k, v in get_versions().items()}
bootinfo.error_report_email = frappe.get_hooks("error_report_email")
bootinfo.default_background_image = get_url("/assets/frappe/images/ui/into-the-dawn.jpg")
return bootinfo
def send_to_supplier(self):
link = get_url("/rfq/" + self.name)
for rfq_supplier in self.suppliers:
if rfq_supplier.email_id and rfq_supplier.send_email_to_supplier:
# make new user if required
update_password_link = self.create_supplier_user(rfq_supplier, link)
self.supplier_rfq_mail(rfq_supplier, update_password_link, link)
def send_payment_request(self):
self.payment_url = get_url(
"/api/method/erpnext.accounts.doctype.payment_request.payment_request.generate_payment_request?name={0}".format(
self.name
)
)
if self.payment_url:
frappe.db.set_value(self.doctype, self.name, "payment_url", self.payment_url)
frappe.db.set_value(self.doctype, self.name, "status", "Initiated")
def get_attach_link(self, print_format):
"""Returns public link for the attachment via `templates/emails/print_link.html`."""
return frappe.get_template("templates/emails/print_link.html").render({
"url": get_url(),
"doctype": self.reference_doctype,
"name": self.reference_name,
"print_format": print_format,
"key": self.get_parent_doc().get_signature()
})
def execute_set_express_checkout(self, amount, currency):
params, url = self.get_paypal_params_and_url()
params.update({
"METHOD": "SetExpressCheckout",
"PAYMENTREQUEST_0_PAYMENTACTION": "SALE",
"PAYMENTREQUEST_0_AMT": amount,
"PAYMENTREQUEST_0_CURRENCYCODE": currency.upper(),
"returnUrl": get_url("/api/method/frappe.integrations.doctype.paypal_settings.paypal_settings.get_express_checkout_details"),
"cancelUrl": get_url("/payment-cancel")
})
params = urlencode(params)
response = make_post_request(url, data=params.encode("utf-8"))
if response.get("ACK")[0] != "Success":
frappe.throw(_("Looks like something is wrong with this site's Paypal configuration."))
return response
def get_redirect_url():
url = "{0}/api/method/dropbox_erpnext_broker.www.setup_dropbox.get_authotize_url".format(
frappe.conf.dropbox_broker_site)
try:
response = make_post_request(url, data={"site": get_url()})
if response.get("message"):
return response["message"]
except Exception as e:
frappe.log_error()
frappe.throw(
_("Something went wrong while generating dropbox access token. Please check error log for more details."
))
def set_portal_link(sent_via, comm):
"""set portal link in footer"""
footer = ""
if is_signup_enabled():
is_valid_recipient = cstr(sent_via.get("email") or sent_via.get("email_id") or
sent_via.get("contact_email")) in comm.recipients
if is_valid_recipient:
url = "%s/%s/%s" % (get_url(), urllib.quote(sent_via.doctype), urllib.quote(sent_via.name))
footer = """<!-- Portal Link -->
<p><a href="%s" target="_blank">View this on our website</a></p>""" % url
return footer
def get_attach_link(doc, print_format):
"""Returns public link for the attachment via `templates/emails/print_link.html`."""
return frappe.get_template("templates/emails/print_link.html").render({
"url":
get_url(),
"doctype":
doc.reference_doctype,
"name":
doc.reference_name,
"print_format":
print_format,
"key":
get_parent_doc(doc).get_signature()
})
def get_document_links(doctype, docs):
docs = json.loads(docs)
print_format = "print_format"
links = []
for doc in docs:
link = frappe.get_template("templates/emails/print_link.html").render({
"url": get_url(),
"doctype": doctype,
"name": doc.get("name"),
"print_format": print_format,
"key": frappe.get_doc(doctype, doc.get("name")).get_signature()
})
links.append(link)
return links
def on_update(self):
self.send_email()
frappe.errprint("in the update")
from frappe.utils import get_url, cstr
frappe.errprint(get_url())
if get_url() == 'http://stich1.tailorpad.com':
pass
else:
pr2 = frappe.db.sql("""select name from `tabSupport Ticket`""")
frappe.errprint(pr2)
frappe.errprint("is feed back saved")
if pr2:
# self.login()
frappe.errprint("in if for creation support ticket")
test = {}
support_ticket = self.get_ticket_details()
self.call_del_keys(support_ticket)
#test['communications'] = []
#self.call_del_keys(support_ticket.get('communications'), test)
self.login()
frappe.errprint("support_ticket")
frappe.errprint(support_ticket)
self.tenent_based_ticket_creation(support_ticket)
def test_site_expiry(self):
update_limits({'expiry': add_to_date(today(), days=-1)})
frappe.local.conf = _dict(frappe.get_site_config())
frappe.db.commit()
res = requests.post(get_url(), params={'cmd': 'login', 'usr': '******', 'pwd': 'testpassword',
'device': 'desktop'})
# While site is expired status code returned is 417 Failed Expectation
self.assertEqual(res.status_code, 417)
clear_limit("expiry")
frappe.local.conf = _dict(frappe.get_site_config())
def send_welcome_mail(self,password):
from frappe.utils import random_string, get_url
key = random_string(32)
mob_code=self.get_mob_code()
self.db_set("reset_password_key", key)
link = get_url("/verify_email?id="+self.profile_id+"&key=" + key)
self.update_verification_details(password,key,mob_code,link)
self.send_login_mail(_("Verify Your Account"), "templates/emails/new_user.html", {"link": link,"password":password})
sms='Your Code for PHR:'+cstr(mob_code)
rec_list=[]
rec_list.append(self.contact)
from erpnext.setup.doctype.sms_settings.sms_settings import send_sms
send_sms(rec_list,sms)
def get_formatted_html(subject,
message,
footer=None,
print_html=None,
email_account=None,
header=None,
unsubscribe_link=None,
sender=None,
with_container=False):
email_account = email_account or EmailAccount.find_outgoing(
match_by_email=sender)
signature = None
if "<!-- signature-included -->" not in message:
signature = get_signature(email_account)
rendered_email = frappe.get_template(
"templates/emails/standard.html").render({
"brand_logo":
get_brand_logo(email_account)
if with_container or header else None,
"with_container":
with_container,
"site_url":
get_url(),
"header":
get_header(header),
"content":
message,
"signature":
signature,
"footer":
get_footer(email_account, footer),
"title":
subject,
"print_html":
print_html,
"subject":
subject
})
html = scrub_urls(rendered_email)
if unsubscribe_link:
html = html.replace("<!--unsubscribe link here-->",
unsubscribe_link.html)
html = inline_style_in_html(html)
return html
def get_activities():
from frappe.utils import get_url, cstr
frappe.errprint(get_url())
frappe.errprint("in activities")
if get_url() == 'http://stich1.tailorpad.com':
frappe.errprint("in the get_activities")
dbname = frappe.db.sql(
"""select site_name from `tabSubAdmin Info` where active=1""",
as_dict=1)
frappe.errprint("dbname")
lst = []
#qry_srt='select feed_type,subject,site_name,creation from('
qry_srt = """SELECT CASE WHEN feed_type='Login' THEN concat('Administrator logged in at ', substring(creation,1,19),' in site "',site_name,'"') ELSE concat('Administrator updated the form "',doc_type,'" name "',doc_name,'" at ' , substring(creation,1,19),' in site "',site_name,'"') END as `ss` from("""
for key in dbname:
frappe.errprint("key")
temp = key['site_name']
if temp.find('.') != -1:
temp1 = temp.split('.')[0][:16]
else:
temp1 = temp[:16]
#qry="SELECT subject,creation,feed_type,'%s' as site_name FROM "%(temp)
qry = "SELECT doc_name,doc_type,creation,feed_type,'%s' as site_name FROM " % (
temp)
if temp:
qry += temp1 + '.tabFeed'
lst.append(qry)
fin_qry = ' UNION '.join(lst)
frappe.errprint("fin qry")
qry = qry_srt + fin_qry + " where doc_name='Administrator')foo ORDER BY creation desc limit 10"
frappe.errprint(qry)
act_details = frappe.db.sql(qry, as_dict=1)
frappe.errprint(act_details)
if act_details:
frappe.errprint(act_details)
return act_details
else:
return ' '
def reset_password(self, send_email=False, password_expired=False):
from frappe.utils import random_string, get_url
key = random_string(32)
self.db_set("reset_password_key", key)
url = "/update-password?key=" + key
if password_expired:
url = "/update-password?key=" + key + '&password_expired=true'
link = get_url(url)
if send_email:
self.password_reset_mail(link)
return link
def get_express_checkout_details(token):
params = get_paypal_params()
params.update({"METHOD": "GetExpressCheckoutDetails", "TOKEN": token})
response = get_api_response(params)
paypal_express_payment = frappe.get_doc("Paypal Express Payment", token)
paypal_express_payment.payerid = response.get("PAYERID")[0]
paypal_express_payment.status = "Verified"
paypal_express_payment.save(ignore_permissions=True)
frappe.db.commit()
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url("/paypal-express-confirm?token=" \
+ paypal_express_payment.token)
def start_checkout(amount, currency="USD", date=None):
log("Are we still using this method?\n{0}".format(get_trace()))
validate_transaction_currency(currency)
if not isinstance(data, basestring):
date = frappe.as_json(data or "{}")
jdata = json.loads(data)
if jdata.get("doctype") and jdata.get("docname"):
reference_doctype = jdata.get("doctype")
reference_docname = jdata.get("docname")
reference_doc = frappe.get_doc(reference_doctype, reference_docname)
if reference_doctype == "Payment Request":
if reference_doc.status not in ["Draft", "Initiated"]:
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url(
"/orders/{0}".format(reference_doc.reference_name))
return
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url("/gateway?name={0}&source={1}".format(reference_docname, reference_doctype))
def check_if_enabled(self, user):
"""raise exception if user not enabled"""
from frappe.utils import cint
if user == 'Administrator' or user == 'administrator': return
if not cint(frappe.db.get_value('User', user, 'enabled')):
self.fail('User disabled or missing')
from frappe.utils import get_url, cstr
if get_url() != 'http://stich1.tailorpad.com':
user = frappe.db.sql(
"""select `name` from tabUser where validity_start_date <= CURDATE() and validity_end_date >= CURDATE() and name=%s """,
(user))
if user:
pass
else:
self.fail('vaildity end please contact administrator')
def get_workflow_action_url(action, doc, user):
apply_action_method = (
"/api/method/frappe.workflow.doctype.workflow_action.workflow_action.apply_action"
)
params = {
"doctype": doc.get("doctype"),
"docname": doc.get("name"),
"action": action,
"current_state": get_doc_workflow_state(doc),
"user": user,
"last_modified": doc.get("modified"),
}
return get_url(apply_action_method + "?" + get_signed_params(params))
def create_supplier_user(self, supplier_data, link):
from frappe.utils import random_string, get_url
update_password_link = ''
if not supplier_data.user_id:
user = self.create_user(supplier_data)
key = random_string(32)
user.reset_password_key = key
user.redirect_url = link
user.save(ignore_permissions=True)
update_password_link = get_url("/update-password?key=" + key)
frappe.get_doc('Contact', supplier_data.contact_person).save()
return update_password_link
def get_error_report(from_date=None, to_date=None, limit=10):
from frappe.utils import get_url, now_datetime, add_days
if not from_date:
from_date = add_days(now_datetime().date(), -1)
if not to_date:
to_date = add_days(now_datetime().date(), -1)
errors = get_errors(from_date, to_date, limit)
if errors:
return 1, _("""<h4>Scheduler Failed Events (max {limit}):</h4> <p>URL: <a href="{url}" target="_blank">{url}</a></p><hr>{errors}""").format(
limit=limit, url=get_url(), errors="<hr>".join(errors))
else:
return 0, _("<p>Scheduler didn't encounter any problems.</p>")
def send_to_supplier(self):
link = get_url("/rfq/" + self.name)
for rfq_supplier in self.suppliers:
if rfq_supplier.email_id:
# make new user if required
update_password_link = self.create_supplier_user(
rfq_supplier, link)
self.supplier_rfq_mail(rfq_supplier, update_password_link,
link)
else:
frappe.throw(
_("For supplier {0} email id is required to send email").
format(rfq_supplier.supplier))
def check_mandate(data, reference_doctype, reference_docname):
data = json.loads(data)
client = gocardless_initialization(reference_docname)
payer = frappe.get_doc("Customer", data["payer_name"])
if payer.customer_type == "Individual" and payer.customer_primary_contact is not None:
primary_contact = frappe.get_doc("Contact",
payer.customer_primary_contact)
prefilled_customer = {
"company_name": payer.name,
"given_name": primary_contact.first_name,
"family_name": primary_contact.last_name,
}
if primary_contact.email_id is not None:
prefilled_customer.update({"email": primary_contact.email_id})
else:
prefilled_customer.update({"email": frappe.session.user})
else:
prefilled_customer = {
"company_name": payer.name,
"email": frappe.session.user
}
success_url = get_url(
"./integrations/gocardless_confirmation?reference_doctype=" +
reference_doctype + "&reference_docname=" + reference_docname)
try:
redirect_flow = client.redirect_flows.create(
params={
"description":
_("Pay {0} {1}".format(data['amount'], data['currency'])),
"session_token":
frappe.session.user,
"success_redirect_url":
success_url,
"prefilled_customer":
prefilled_customer
})
return {"redirect_to": redirect_flow.redirect_url}
except Exception as e:
frappe.log_error(e, "GoCardless Payment Error")
return {"redirect_to": '/integrations/payment-failed'}
def get_pdf(profile_id, options=None):
import pdfkit, os, frappe
from frappe.utils import scrub_urls
if not options:
options = {}
options.update({
"print-media-type": None,
"background": None,
"images": None,
'margin-top': '15mm',
'margin-right': '15mm',
'margin-bottom': '15mm',
'margin-left': '15mm',
'encoding': "UTF-8",
'no-outline': None
})
user = get_user_details(profile_id)
html = """<div style='border:1px solid black;width:400px;height:238px;align:center'>
<div width=100%% ><tr width=100%% >
<td width=30%% >Logo</td>
<td width=70%% >Name of Application</td></tr><table><hr>
</div><table width=100%% ><tr width=100%% ><td width=20%% >
<img class='user-picture' src='%(user_image)s' style='min-width:25px;max-width: 70px; min-width:25px; max-height: 70px; border-radius: 4px;margin-top:0%%;margin-left:20%%'/></td>
<td width=60%% >Name:%(name)s
</br>Blood Group: %(blood_group)s
</br>Contact No: %(contact)s
</br>Emer Contact:%(emergency_contact)s
<br><img src="%(barcode)s">
</td></tr></table></div></div>""" % user
if not options.get("page-size"):
options['page-size'] = "A4"
html = scrub_urls(html)
#fname=os.path.join(os.getcwd(), get_site_path().replace('.',"").replace('/', ""), 'public', 'files', profile_id, profile_id +"ed"+ ".pdf")
# pdfkit.from_string(html, fname, options=options or {})
fname = os.path.join(get_files_path(), profile_id,
profile_id + "ed" + ".pdf")
print fname
pdfkit.from_string(html, fname, options=options or {})
li = fname.split('/')
print li
url = get_url() + "/".join(["", li[-3], li[-2], li[-1]])
print url
return url
def setup_redirect(data, redirect_url, custom_redirect_to=None, redirect=True):
redirect_to = data.get('redirect_to') or None
redirect_message = data.get('redirect_message') or None
if custom_redirect_to:
redirect_to = custom_redirect_to
if redirect_to:
redirect_url += '&' + urlencode({'redirect_to': redirect_to})
if redirect_message:
redirect_url += '&' + urlencode({'redirect_message': redirect_message})
# this is done so that functions called via hooks can update flags.redirect_to
if redirect:
frappe.local.response["type"] = "redirect"
frappe.local.response["location"] = get_url(redirect_url)
def send_welcome_mail_to_user(self):
from frappe.utils import get_url
link = self.reset_password()
app_title = [t for t in frappe.get_hooks('app_title') if t != 'Frappe Framework']
if app_title:
subject = _("Welcome to {0}").format(app_title[0])
else:
subject = _("Complete Registration")
self.send_login_mail(subject, "templates/emails/new_user.html",
dict(
link=link,
site_url=get_url(),
))
def make(self):
"""build into msg_root"""
self.msg_root['Subject'] = self.subject.encode("utf-8")
self.msg_root['From'] = self.sender.encode("utf-8")
self.msg_root['To'] = ', '.join([r.strip() for r in self.recipients
]).encode("utf-8")
self.msg_root['Date'] = email.utils.formatdate()
if not self.reply_to:
self.reply_to = self.sender
self.msg_root['Reply-To'] = self.reply_to.encode("utf-8")
if self.cc:
self.msg_root['CC'] = ', '.join([r.strip()
for r in self.cc]).encode("utf-8")
# add frappe site header
self.msg_root.add_header(b'X-Frappe-Site', get_url().encode('utf-8'))
def notify(arg=None):
from frappe.utils import cstr, get_fullname, get_url
try:
frappe.sendmail(\
recipients=[frappe.db.get_value("User", arg["contact"], "email") or arg["contact"]],
sender= frappe.db.get_value("User", frappe.session.user, "email"),
subject="New Message from " + get_fullname(frappe.user.name),
message=frappe.get_template("templates/emails/new_message.html").render({
"from": get_fullname(frappe.user.name),
"message": arg['txt'],
"link": get_url()
})
)
except frappe.OutgoingEmailError, e:
pass
def send_alert_email():
try:
url = get_url("Form/Finger Print Device Control Panel")
#messages = (_("Your Finger Print Device have a connection problem,reset it Plz "),url,_("Visit"))
#frappe.sendmail("*****@*****.**", subject=_("Can not reach Finger Print Device!"),content=content.format(*messages))
frappe.sendmail(
recipients="*****@*****.**",
sender="*****@*****.**",
subject=_("Can not reach Finger Print Device!"),
message=
_("Your Finger Print Device have a connection problem. Plz, reset it"
))
return _("Email sent")
except frappe.OutgoingEmailError:
pass
def get_error_report(from_date=None, to_date=None, limit=10):
from frappe.utils import get_url, now_datetime, add_days
if not from_date:
from_date = add_days(now_datetime().date(), -1)
if not to_date:
to_date = add_days(now_datetime().date(), -1)
errors = get_errors(from_date, to_date, limit)
if errors:
return 1, """<h4>Error Logs (max {limit}):</h4>
<p>URL: <a href="{url}" target="_blank">{url}</a></p><hr>{errors}""".format(
limit=limit, url=get_url(), errors="<hr>".join(errors))
else:
return 0, "<p>No error logs</p>"
def set_portal_link(sent_via, comm): """set portal link in footer""" footer = None if is_signup_enabled() and hasattr(sent_via, "get_portal_page"): portal_page = sent_via.get_portal_page() if portal_page: is_valid_recipient = cstr(sent_via.doc.email or sent_via.doc.email_id or sent_via.doc.contact_email) in comm.recipients if is_valid_recipient: url = "%s/%s?name=%s" % (get_url(), portal_page, urllib.quote(sent_via.doc.name)) footer = """<!-- Portal Link --><hr> <a href="%s" target="_blank">View this on our website</a>""" % url return footer
def get_unsubcribed_url(reference_doctype, reference_name, email,
unsubscribe_method, unsubscribe_params):
params = {
"email": email.encode("utf-8"),
"doctype": reference_doctype.encode("utf-8"),
"name": reference_name.encode("utf-8")
}
if unsubscribe_params:
params.update(unsubscribe_params)
query_string = get_signed_params(params)
# for test
frappe.local.flags.signed_query_string = query_string
return get_url(unsubscribe_method + "?" + get_signed_params(params))
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:
frappe.sendmail(user.user,
subject=_("Project Collaboration Invitation"),
content=content.format(*messages))
user.welcome_email_sent = 1
def send_login_mail(self,
subject,
template,
add_args,
now=None,
email_template=None):
"""send mail with login details"""
from frappe.utils.user import get_user_fullname
from frappe.utils import get_url
content = None
full_name = get_user_fullname(frappe.session['user'])
if full_name == "Guest":
full_name = "Administrator"
args = {
'first_name': self.first_name or self.last_name or _("user"),
'last_name': self.last_name,
'user': self.name,
'title': subject,
'login_url': get_url(),
'user_fullname': full_name
}
args.update(add_args)
if email_template:
template = None
subject = frappe.render_template(subject, args)
content = frappe.render_template(
frappe.db.get_value("Email Template", email_template,
"response"), args)
sender = frappe.session.user not in STANDARD_USERS and get_formatted_email(
frappe.session.user) or None
frappe.sendmail(
recipients=self.email,
sender=sender,
subject=subject,
template=template,
args=args,
content=content,
header=[subject, "green"],
delayed=(not now) if now != None else self.flags.delay_emails,
retry=3)
def make(self):
"""build into msg_root"""
headers = {
"Subject": strip(self.subject).encode("utf-8"),
"From": self.sender.encode("utf-8"),
"To": ', '.join(self.recipients).encode("utf-8"),
"Date": email.utils.formatdate(),
"Reply-To": self.reply_to.encode("utf-8") if self.reply_to else None,
"CC": ', '.join(self.cc).encode("utf-8") if self.cc else None,
b'X-Frappe-Site': get_url().encode('utf-8')
}
# reset headers as values may be changed.
for key, val in headers.iteritems():
if self.msg_root.has_key(key):
del self.msg_root[key]
self.msg_root[key] = val
