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_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_scrub_urls(self): html = ''' <p>You have a new message from: <b>John</b></p> <p>Hey, wassup!</p> <div class="more-info"> <a href="http://test.com">Test link 1</a> <a href="/about">Test link 2</a> <a href="login">Test link 3</a> <img src="/assets/dataent/test.jpg"> </div> <div style="background-image: url('/assets/dataent/bg.jpg')"> Please mail us at <a href="mailto:[email protected]">email</a> </div> ''' html = scrub_urls(html) url = get_url() self.assertTrue('<a href="http://test.com">Test link 1</a>' in html) self.assertTrue( '<a href="{0}/about">Test link 2</a>'.format(url) in html) self.assertTrue( '<a href="{0}/login">Test link 3</a>'.format(url) in html) self.assertTrue( '<img src="{0}/assets/dataent/test.jpg">'.format(url) in html) self.assertTrue( 'style="background-image: url(\'{0}/assets/dataent/bg.jpg\') !important"' .format(url) in html) self.assertTrue('<a href="mailto:[email protected]">email</a>' in html)
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 _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 on_payment_authorized(self, status=None): if not status: return shopping_cart_settings = dataent.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(dataent.local, "session") and dataent.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 test_insert_many(self): if os.environ.get('CI'): return from dataent.dataentclient import DataentClient dataent.db.sql( 'delete from `tabToDo` where description like "Test API%"') dataent.db.commit() server = DataentClient(get_url(), "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( dataent.db.get_value('ToDo', {'description': 'Test API 1'})) self.assertTrue( dataent.db.get_value('ToDo', {'description': 'Test API 2'})) self.assertTrue( dataent.db.get_value('ToDo', {'description': 'Test API 3'}))
def reset_password(self, send_email=False): from dataent.utils import random_string, get_url key = random_string(32) self.db_set("reset_password_key", key) link = get_url("/update-password?key=" + key) if send_email: self.password_reset_mail(link) return link
def get_confirm_workflow_action_url(doc, action, user): confirm_action_method = "/api/method/dataent.workflow.doctype.workflow_action.workflow_action.confirm_action" params = { "action": action, "doctype": doc.get('doctype'), "docname": doc.get('name'), "user": user } return get_url(confirm_action_method + "?" + get_signed_params(params))
def is_valid_url(url): is_valid = False if url.startswith("/files") or url.startswith("/private/files"): url = get_url(url) try: r = requests.get(url) is_valid = True if r.status_code == 200 else False except Exception: pass return is_valid
def get_workflow_action_url(action, doc, user): apply_action_method = "/api/method/dataent.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 execute_set_express_checkout(self, **kwargs): params, url = self.get_paypal_params_and_url() params.update({ "METHOD": "SetExpressCheckout", "returnUrl": get_url("{0}.get_express_checkout_details".format(api_path)), "cancelUrl": get_url("/payment-cancel"), "PAYMENTREQUEST_0_PAYMENTACTION": "SALE", "PAYMENTREQUEST_0_AMT": kwargs['amount'], "PAYMENTREQUEST_0_CURRENCYCODE": kwargs['currency'].upper() }) if kwargs.get('subscription_details'): self.configure_recurring_payments(params, kwargs) params = urlencode(params) response = make_post_request(url, data=params.encode("utf-8")) if response.get("ACK")[0] != "Success": dataent.throw(_("Looks like something is wrong with this site's Paypal configuration.")) return response
def get_link_for_qrcode(user, totp_uri): '''Get link to temporary page showing QRCode.''' key = dataent.generate_hash(length=20) key_user = "******".format(key) key_uri = "{}_uri".format(key) lifespan = int( dataent.db.get_value('System Settings', 'System Settings', 'lifespan_qrcode_image')) if lifespan <= 0: lifespan = 240 dataent.cache().set_value(key_uri, totp_uri, expires_in_sec=lifespan) dataent.cache().set_value(key_user, user, expires_in_sec=lifespan) return get_url('/qrcode?k={}'.format(key))
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 dataent.local.flags.signed_query_string = query_string return get_url(unsubscribe_method + "?" + get_signed_params(params))
def check_mandate(data, reference_doctype, reference_docname): data = json.loads(data) client = gocardless_initialization(reference_docname) payer = dataent.get_doc("Customer", data["payer_name"]) if payer.customer_type == "Individual" and payer.customer_primary_contact is not None: primary_contact = dataent.get_doc("Contact", payer.customer_primary_contact) prefilled_customer = { "company_name": payer.name, "given_name": primary_contact.first_name, } if primary_contact.last_name is not None: prefilled_customer.update( {"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": dataent.session.user}) else: prefilled_customer = { "company_name": payer.name, "email": dataent.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": dataent.session.user, "success_redirect_url": success_url, "prefilled_customer": prefilled_customer }) return {"redirect_to": redirect_flow.redirect_url} except Exception as e: dataent.log_error(e, "GoCardless Payment Error") return {"redirect_to": '/integrations/payment-failed'}
def get_attach_link(doc, print_format): """Returns public link for the attachment via `templates/emails/print_link.html`.""" return dataent.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_redirect_url(): if not dataent.conf.dropbox_broker_site: dataent.conf.dropbox_broker_site = 'https://dropbox.epaas.xyz' url = "{0}/api/method/dropbox_epaas_broker.www.setup_dropbox.get_authotize_url".format(dataent.conf.dropbox_broker_site) try: response = make_post_request(url, data={"site": get_url()}) if response.get("message"): return response["message"] except Exception: dataent.log_error() dataent.throw( _("Something went wrong while generating dropbox access token. Please check error log for more details.") )
def get_error_report(from_date=None, to_date=None, limit=10): from dataent.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 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: dataent.local.response["type"] = "redirect" dataent.local.response["location"] = get_url(redirect_url)
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 make(self): """build into msg_root""" headers = { "Subject": strip(self.subject), "From": self.sender, "To": ', '.join(self.recipients) if self.expose_recipients=="header" else "<!--recipient-->", "Date": email.utils.formatdate(), "Reply-To": self.reply_to if self.reply_to else None, "CC": ', '.join(self.cc) if self.cc and self.expose_recipients=="header" else None, 'X-Dataent-Site': get_url(), } # reset headers as values may be changed. for key, val in iteritems(headers): self.set_header(key, val) # call hook to enable apps to modify msg_root before sending for hook in dataent.get_hooks("make_email_body_message"): dataent.get_attr(hook)(self)
def test_site_expiry(self): user = dataent.get_doc('User', '*****@*****.**') user.enabled = 1 user.new_password = '******' user.save() update_limits({'expiry': add_to_date(today(), days=-1), 'support_email': '*****@*****.**'}) dataent.local.conf = _dict(dataent.get_site_config()) dataent.db.commit() res = requests.post(get_url(), params={'cmd': 'login', 'usr': '******', 'pwd': 'Eastern_43A1W', 'device': 'desktop'}) # While site is expired status code returned is 417 Failed Expectation self.assertEqual(res.status_code, 417) clear_limit("expiry") dataent.local.conf = _dict(dataent.get_site_config())
def set_redirect(razorpay_express_payment): """ EPAAS related redirects. You need to set Razorpay Payment.flags.redirect_to on status change. Called via RazorpayPayment.on_update """ if "epaas" not in dataent.get_installed_apps(): return if not razorpay_express_payment.flags.status_changed_to: return reference_doctype = razorpay_express_payment.reference_doctype reference_docname = razorpay_express_payment.reference_docname if not (reference_doctype and reference_docname): return reference_doc = dataent.get_doc(reference_doctype, reference_docname) shopping_cart_settings = dataent.get_doc("Shopping Cart Settings") if razorpay_express_payment.flags.status_changed_to == "Authorized": reference_doc.run_method("set_as_paid") # if shopping cart enabled and in session if (shopping_cart_settings.enabled and hasattr(dataent.local, "session") and dataent.local.session.user != "Guest"): success_url = shopping_cart_settings.payment_success_url if success_url: razorpay_express_payment.flags.redirect_to = ({ "Orders": "orders", "Invoices": "invoices", "My Account": "me" }).get(success_url, "me") else: razorpay_express_payment.flags.redirect_to = get_url( "/orders/{0}".format(reference_doc.reference_name))
def send_welcome_mail_to_user(self): from dataent.utils import get_url link = self.reset_password() subject = None method = dataent.get_hooks("welcome_email") if method: subject = dataent.get_attr(method[-1])() if not subject: site_name = dataent.db.get_default( 'site_name') or dataent.get_conf().get("site_name") if site_name: subject = _("Welcome to {0}".format(site_name)) else: subject = _("Complete Registration") self.send_login_mail(subject, "new_user", dict( link=link, site_url=get_url(), ))
def qrcode_as_png(user, totp_uri): '''Save temporary Qrcode to server.''' from dataent.utils.file_manager import save_file folder = create_barcode_folder() png_file_name = '{}.png'.format(dataent.generate_hash(length=20)) file_obj = save_file(png_file_name, png_file_name, 'User', user, folder=folder) dataent.db.commit() file_url = get_url(file_obj.file_url) file_path = os.path.join(dataent.get_site_path('public', 'files'), file_obj.file_name) url = qrcreate(totp_uri) with open(file_path, 'w') as png_file: url.png(png_file, scale=8, module_color=[0, 0, 0, 180], background=[0xff, 0xff, 0xcc]) return file_url
def get_feedback_request_url(reference_doctype, reference_name, recipients, trigger="Manual"): """ prepare the feedback request url """ is_manual = 1 if trigger == "Manual" else 0 feedback_request = dataent.get_doc({ "is_manual": is_manual, "feedback_trigger": trigger, "doctype": "Feedback Request", "reference_name": reference_name, "reference_doctype": reference_doctype, }).insert(ignore_permissions=True) feedback_url = "{base_url}/feedback?reference_doctype={doctype}&reference_name={docname}&email={email_id}&key={nonce}".format( base_url=get_url(), doctype=reference_doctype, docname=reference_name, email_id=recipients, nonce=feedback_request.key) return [feedback_request.name, feedback_url]
def _send_gstin_reminder(party_type, party, default_email_id=None, sent_to=None): '''Send GST Reminder email''' email_id = dataent.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: dataent.throw(_('Email not found in default contact'), exc=EmailMissing) if sent_to and email_id in sent_to: return dataent.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://epaas.xyz">https://epaas.xyz</a> <br> EPAAS is a free and open source ERP system. </p> '''.format(os.path.join(get_url(), '/regional/india/update-gstin'), party)) return email_id
def get_payment_url(self, **kwargs): return get_url("./integrations/braintree_checkout?{0}".format( urlencode(kwargs)))
def get_checkout_url(**kwargs): missing_keys = set(expected_keys) - set(kwargs.keys()) if missing_keys: dataent.throw(_('Missing keys to build checkout URL: {0}').format(", ".join(list(missing_keys)))) return get_url('/razorpay_checkout?{0}'.format(urllib.urlencode(kwargs)))