def get_credit_card_info(user): customer = cstr(frappe.db.get_value("User", {"email": user}, "first_name")) customer_id = cstr( frappe.db.get_value("Customer", {"customer_name": customer}, "name")) return { "customer": customer, "name": cstr( get_decrypted_password('Customer', customer_id, 'name_on_card', False)), "card_number": cstr( get_decrypted_password('Customer', customer_id, 'credit_card_number', False)), "ex_month": cstr( get_decrypted_password('Customer', customer_id, 'expiry_month', False)), "ex_year": cstr( get_decrypted_password('Customer', customer_id, 'expiry_year', False)) }
def sendSMS(msisdn, msg): data = frappe.get_doc("MTN Services Settings") data.sms_password = get_decrypted_password('MTN Services Settings', 'MTN Services Settings', 'sms_password', False) responseMeg = "<usareq NODE='" + data.sms_node + "' TRANSFORM='SUBMIT_SM' USERNAME='******' PASSWORD='******'><command><submit_sm><a_number>" + data.sms_a_number + "</a_number><b_number>" + msisdn + "</b_number><service_type></service_type><message>"+ msg +"</message><registered_delivery></registered_delivery></submit_sm></command></usareq>" r = requests.post(data.message_url, data = {'command': responseMeg} ) return r
def get_nmb_token(company): username = frappe.get_value("Company",company,"nmb_username") if not username: frappe.throw(_("Please set NMB User Name in Company {0}".format(company))) password = get_decrypted_password("Company",company,"nmb_password") if not password: frappe.throw(_("Please set NMB Password in Company {0}".format(company))) url = frappe.get_value("Company",company,"nmb_url") if not url: frappe.throw(_("Please set NMB URL in Company {0}".format(company))) url = url + str("auth") data = { "username": username, "password": password, } for i in range(3): try: r = requests.post(url, data=json.dumps(data), timeout=5) r.raise_for_status() frappe.logger().debug({"get_nmb_token webhook_success": r.text}) # print_out(r.text) if json.loads(r.text)["status"] == 1: return json.loads(r.text)["token"] else: frappe.throw(json.loads(r.text)) except Exception as e: frappe.logger().debug({"get_nmb_token webhook_error": e, "try": i + 1}) sleep(3 * i + 1) if i != 2: continue else: raise e
def get_app_settings(app_details): parameters = {} doctype = docname = app_details["doctype"] app_settings = get_parameters(app_details) if app_settings: settings = app_settings["settings"] frappe.reload_doc( "integrations", "doctype", "{0}_settings".format(app_details["service_name"].lower())) controller = frappe.get_meta("{0} Settings".format( app_details["service_name"])) for d in controller.fields: if settings.get(d.fieldname): if ''.join(set(cstr(settings.get(d.fieldname)))) == '*': setattr( settings, d.fieldname, get_decrypted_password(doctype, docname, d.fieldname, raise_exception=True)) parameters.update({d.fieldname: settings.get(d.fieldname)}) return parameters
def create_droplet(self): if frappe.db.count( "Deployer Instance") + 1 > self.deployer_config.max_instances: self.set_pull_request_status( "Maximum number of concurrently active instances reached", "error") self.destroy_instance(error=True) return self.instance_name = '-'.join([ self.application_being_tested, "PR", str(self.pull_request_number), self.instance_requested_by ]) self.get_manager() self.droplet = digitalocean.Droplet( token=get_decrypted_password("Deployer Config", self.deployer_config.name, "do_token"), name=self.instance_name, size=self.parameters.get('droplet_size'), region="blr1", ssh_keys=self.manager.get_all_sshkeys(), image=self.deployer_config.snapshot_id) self.droplet.create() while True: action = self.droplet.get_actions()[0] if (action.type, action.status) == ('create', 'completed'): break sleep(10) self.droplet = self.manager.get_droplet(self.droplet.id) self.instance_url = self.droplet.ip_address self.droplet_id = self.droplet.id self.is_active = True self.instance_created_at = frappe.utils.now() self.save(ignore_permissions=True) return True
def send_whatsapp_message(sender, receiver_list, message): twilio_settings = frappe.get_doc("Twilio Settings") if not twilio_settings.enabled: frappe.throw( _("Please enable twilio settings before sending WhatsApp messages") ) if isinstance(receiver_list, string_types): receiver_list = loads(receiver_list) if not isinstance(receiver_list, list): receiver_list = [receiver_list] auth_token = get_decrypted_password("Twilio Settings", "Twilio Settings", 'auth_token') client = Client(twilio_settings.account_sid, auth_token) args = {"from_": 'whatsapp:+{}'.format(sender), "body": message} failed_delivery = [] for rec in receiver_list: args.update({"to": 'whatsapp:{}'.format(rec)}) resp = _send_whatsapp(args, client) if not resp or resp.error_message: failed_delivery.append(rec) if failed_delivery: frappe.log_error( _("The message wasn't correctly delivered to: {}".format( ", ".join(failed_delivery))), _('Delivery Failed'))
def after_insert(self): password = get_decrypted_password("Driver", self.name) roles_to_apply = [{"role": "Driver"}] gg = frappe.get_doc({ "doctype": "User", "email": self.email, "first_name": self.nama, "send_welcome_email": 0, "new_password": password, "send_password_update_notification": 0, "roles": roles_to_apply }) gg.insert(ignore_permissions=True) #_update_password(self.email,password) perm = frappe.get_doc({ "doctype": "User Permission", "user": self.email, "allow": "Vendor", "for_value": self.vendor, "apply_for_all_roles": 1 }) perm.insert(ignore_permissions=True) perm = frappe.get_doc({ "doctype": "User Permission", "user": self.email, "allow": "Driver", "for_value": self.name, "apply_for_all_roles": 1 }) perm.insert(ignore_permissions=True)
def get_payment_link(currency, refno, amount, verify=True): settings = frappe.get_doc("Datatrans Settings", "Datatrans Settings") payload = { "currency": currency, "refno": refno, "amount": float(amount), "paymentMethods": settings.get_payment_method_list(), "redirect": { "successUrl": settings.success_url or get_url(), "errorUrl": settings.error_url or get_url(), "cancelUrl": settings.cancel_url or get_url() } } auth = HTTPBasicAuth( settings.username, get_decrypted_password("Datatrans Settings", "Datatrans Settings", "password", False)) r = requests.post("{0}/transactions".format(settings.endpoint), verify=verify, auth=auth, json=payload) return {'success': 1, 'status': r.status_code, 'result': r.text}
def get_context(context): redirect_to = frappe.local.request.args.get("redirect-to") if frappe.session.user != "Guest": if not redirect_to: redirect_to = "/" if frappe.session.data.user_type == "Website User" else "/desk" frappe.local.flags.redirect_location = redirect_to raise frappe.Redirect # get settings from site config context.no_header = True context.for_test = 'login.html' context["title"] = "Login" context["provider_logins"] = [] context["disable_signup"] = frappe.utils.cint( frappe.db.get_value("Website Settings", "Website Settings", "disable_signup")) providers = [ i.name for i in frappe.get_all("Social Login Key", filters={"enable_social_login": 1}) ] for provider in providers: client_id, base_url = frappe.get_value("Social Login Key", provider, ["client_id", "base_url"]) client_secret = get_decrypted_password("Social Login Key", provider, "client_secret") icon = get_icon_html(frappe.get_value("Social Login Key", provider, "icon"), small=True) if (get_oauth_keys(provider) and client_secret and client_id and base_url): context.provider_logins.append({ "name": provider, "provider_name": frappe.get_value("Social Login Key", provider, "provider_name"), "auth_url": get_oauth2_authorize_url(provider, redirect_to), "icon": icon }) context["social_login"] = True ldap_settings = LDAPSettings.get_ldap_client_settings() context["ldap_settings"] = ldap_settings login_name_placeholder = [_("Email address")] if frappe.utils.cint( frappe.get_system_settings("allow_login_using_mobile_number")): login_name_placeholder.append(_("Mobile number")) if frappe.utils.cint( frappe.get_system_settings("allow_login_using_user_name")): login_name_placeholder.append(_("Username")) context['login_name_placeholder'] = ' {0} '.format( _('or')).join(login_name_placeholder) return context
def get_repository(self): if not self.deployer_config: self.deployer_config = frappe.get_single("Deployer Config") g = Github( self.deployer_config.bot_username, get_decrypted_password("Deployer Config", self.deployer_config.name, "access_token")) self.repository = g.get_repo(self.repository_fullname)
def set_new_password(self, old_password, new_password): if get_decrypted_password(self.doctype, self.name, 'password', raise_exception=True) == old_password: set_encrypted_password(self.doctype, self.name, new_password, 'password') self.reload() return True else: frappe.msgprint(_("Old Password is not valid, please fill correct Old Password to Set New Password.!!")) return False
def get_context(context): redirect_to = frappe.local.request.args.get("redirect-to") if frappe.session.user != "Guest": if not redirect_to: if frappe.session.data.user_type=="Website User": redirect_to = get_home_page() else: redirect_to = "/app" if redirect_to != 'login': frappe.local.flags.redirect_location = redirect_to raise frappe.Redirect # get settings from site config context.no_header = True context.for_test = 'login.html' context["title"] = "Login" context["provider_logins"] = [] context["disable_signup"] = frappe.utils.cint(frappe.db.get_value("Website Settings", "Website Settings", "disable_signup")) context["logo"] = frappe.get_hooks("app_logo_url")[-1] context["app_name"] = frappe.get_system_settings("app_name") or _("Frappe") providers = [i.name for i in frappe.get_all("Social Login Key", filters={"enable_social_login":1}, order_by="name")] for provider in providers: client_id, base_url = frappe.get_value("Social Login Key", provider, ["client_id", "base_url"]) client_secret = get_decrypted_password("Social Login Key", provider, "client_secret") provider_name = frappe.get_value("Social Login Key", provider, "provider_name") icon = None icon_url = frappe.get_value("Social Login Key", provider, "icon") if icon_url: if provider_name != "Custom": icon = "<img src='{0}' alt={1}>".format(icon_url, provider_name) else: icon = get_icon_html(icon_url, small=True) if (get_oauth_keys(provider) and client_secret and client_id and base_url): context.provider_logins.append({ "name": provider, "provider_name": provider_name, "auth_url": get_oauth2_authorize_url(provider, redirect_to), "icon": icon }) context["social_login"] = True ldap_settings = LDAPSettings.get_ldap_client_settings() context["ldap_settings"] = ldap_settings login_label = [_("Email")] if frappe.utils.cint(frappe.get_system_settings("allow_login_using_mobile_number")): login_label.append(_("Mobile")) if frappe.utils.cint(frappe.get_system_settings("allow_login_using_user_name")): login_label.append(_("Username")) context['login_label'] = ' {0} '.format(_('or')).join(login_label) return context
def get_password(self, fieldname='password', raise_exception=True): if self.get(fieldname) and not self.is_dummy_password( self.get(fieldname)): return self.get(fieldname) return get_decrypted_password(self.doctype, self.name, fieldname, raise_exception=raise_exception)
def get_twilio_client(self): twilio_settings = frappe.get_doc("Twilio Settings") if not twilio_settings.enabled: frappe.throw(_("Please enable twilio settings before sending WhatsApp messages")) auth_token = get_decrypted_password("Twilio Settings", "Twilio Settings", 'auth_token') client = TwilioClient(twilio_settings.account_sid, auth_token) return client
def validate_twilio_credentials(self): try: auth_token = get_decrypted_password("Twilio Settings", "Twilio Settings", 'auth_token') client = Client(self.account_sid, auth_token) client.api.accounts(self.account_sid).fetch() except Exception: frappe.throw(_("Invalid Account SID or Auth Token."))
def get_password(self, fieldname="password", raise_exception=True): from frappe.utils.password import get_decrypted_password if self.get(fieldname) and not self.is_dummy_password(self.get(fieldname)): return self.get(fieldname) return get_decrypted_password( self.doctype, self.name, fieldname, raise_exception=raise_exception )
def get_request(content): # get settings settings = frappe.get_doc("MS Direct Settings") password = get_decrypted_password("MS Direct Settings", "MS Direct Settings", 'password') # prepare connection auth = HTTPBasicAuth(settings.user, password) url = settings.endpoint # send request response = requests.get(url=url, auth=auth, data=content.encode('utf-8')) return response
def get_claimsservice_token(company): setting_doc = frappe.get_doc("Company NHIF Settings", company) if (setting_doc.claimsserver_expiry and setting_doc.claimsserver_expiry > now_datetime()): return setting_doc.claimsserver_token username = setting_doc.username password = get_decrypted_password("Company NHIF Settings", company, "password") payload = "grant_type=password&username={0}&password={1}".format( username, password) headers = {"Content-Type": "application/x-www-form-urlencoded"} url = str(setting_doc.claimsserver_url) + "/claimsserver/Token" for i in range(3): try: r = requests.request("GET", url, headers=headers, data=payload, timeout=5) r.raise_for_status() frappe.logger().debug({"webhook_success": r.text}) if json.loads(r.text): add_log( request_type="token", request_url=url, request_header=headers, request_body=payload, response_data=json.loads(r.text), ) if json.loads(r.text)["token_type"] == "bearer": token = json.loads(r.text)["access_token"] expired = json.loads(r.text)["expires_in"] expiry_date = add_to_date(now(), seconds=(expired - 1000)) setting_doc.claimsserver_token = token setting_doc.claimsserver_expiry = expiry_date setting_doc.db_update() frappe.db.commit() return token else: add_log( request_type="token", request_url=url, request_header=headers, request_body=payload, ) frappe.throw(json.loads(r.text)) except Exception as e: frappe.logger().debug({"webhook_error": e, "try": i + 1}) sleep(3 * i + 1) if i != 2: continue else: raise e
def get_user_password(username=False, is_admin=False): password = None if is_admin: username = frappe.db.get_single_value("Metabase Setting", "admin") if not frappe.db.get_value("Metabase User", username): create_user(username) return get_decrypted_password("Metabase User", username, "password", raise_exception=False)
def get_directions(self, route, optimize): """ Retrieve map directions for a given route and departure time. If optimize is `True`, Google Maps will return an optimized order for the intermediate waypoints. NOTE: Google's API does take an additional `departure_time` key, but it only works for routes without any waypoints. Args: route (list of str): Route addresses (origin -> waypoint(s), if any -> destination) optimize (bool): `True` if route needs to be optimized, else `False` Returns: (dict): Route legs and, if `optimize` is `True`, optimized waypoint order """ if not get_decrypted_password("Google Settings", "Google Settings", "api_key"): frappe.throw(_("Enter API key in Google Settings.")) import googlemaps try: maps_client = googlemaps.Client(key=get_decrypted_password( "Google Settings", "Google Settings", "api_key")) except Exception as e: frappe.throw(e) directions_data = { "origin": route[0], "destination": route[-1], "waypoints": route[1:-1], "optimize_waypoints": optimize } try: directions = maps_client.directions(**directions_data) except Exception as e: frappe.throw(_(str(e))) return directions[0] if directions else False
def send_otp(mobile_number, generated_otp): settings = frappe.get_single('CD User Management Settings') template_id = settings.msg91_template_id authkey = get_decrypted_password('CD User Management Settings', 'CD User Management Settings', fieldname='msg91_auth_key', raise_exception=False) mobile_number = '91' + mobile_number url = f"https://api.msg91.com/api/v5/otp/?otp={generated_otp}&authkey={authkey}&mobile={mobile_number}&template_id={template_id}" headers = {"Content-Type": "application/json"} response = requests.request("GET", url, headers=headers) return response
def __init__(self): self.api_key = get_decrypted_password('Packlink', 'Packlink', 'api_key', raise_exception=False) self.enabled = frappe.db.get_single_value('Packlink', 'enabled') if not self.enabled: link = frappe.utils.get_link_to_form( 'Packlink', 'Packlink', frappe.bold('Packlink Settings')) frappe.throw(_( 'Please enable Packlink Integration in {0}'.format(link)), title=_('Mandatory'))
def verify_varmani_customer_pin(msisdn, pin): # print str(pin) try: data = frappe.get_doc("Varmani Network", {'msisdn': msisdn}) # return data.name password = get_decrypted_password('Varmani Network', data.name, 'pin', False) # return password if str(password) == str(pin): return True else: return False except: return 'error' + str(sys.exc_info()[0])
def __init__(self): self.api_password = get_decrypted_password('LetMeShip', 'LetMeShip', 'api_password', raise_exception=False) self.api_id, self.enabled = frappe.db.get_value( 'LetMeShip', 'LetMeShip', ['api_id', 'enabled']) if not self.enabled: link = frappe.utils.get_link_to_form( 'LetMeShip', 'LetMeShip', frappe.bold('LetMeShip Settings')) frappe.throw(_( 'Please enable LetMeShip Integration in {0}'.format(link)), title=_('Mandatory'))
def __init__(self): self.api_secret = get_decrypted_password('SendCloud', 'SendCloud', 'api_secret', raise_exception=False) self.api_key, self.enabled = frappe.db.get_value( 'SendCloud', 'SendCloud', ['api_key', 'enabled']) if not self.enabled: link = frappe.utils.get_link_to_form( 'SendCloud', 'SendCloud', frappe.bold('SendCloud Settings')) frappe.throw(_( 'Please enable SendCloud Integration in {0}'.format(link)), title=_('Mandatory'))
def authorize(self): """Authenticate the token and return asana_settings client""" if self.enable: if not self.personal_access_token: frappe.throw( _("Personal Access Token is mandatory if Asana Integration is enabled." )) try: client = asana.Client.access_token( get_decrypted_password("Asana Settings", "Asana Settings", "personal_access_token")) return client except Exception: frappe.throw(_("Error while connecting to Asana Client."))
def compare_customers_pin(customers_pin, wallet_data, data): try: password = get_decrypted_password("Wallet", wallet_data[0].name, "customer_pin") if customers_pin == password: return {"message": "Please scan attendant card", "failed": False} else: create_error_log("Failed Checking Customers Pin", 'Customers Pin Check', data) return {"message": "Failed Checking Customers Pin", "failed": True} except: create_error_log("Failed Checking Customers Pin", 'Customers Pin Check', data) return {"message": "Failed Checking Customers Pin", "failed": True}
def execute(): publishable_key = frappe.db.sql("select value from tabSingles where doctype='Stripe Settings' and field='publishable_key'") if publishable_key: secret_key = get_decrypted_password('Stripe Settings', 'Stripe Settings', fieldname='secret_key', raise_exception=False) if secret_key: frappe.reload_doc('integrations', 'doctype', 'stripe_settings') frappe.db.commit() settings = frappe.new_doc("Stripe Settings") settings.gateway_name = frappe.db.get_value("Global Defaults", None, "default_company") or "Stripe Settings" settings.publishable_key = publishable_key settings.secret_key = secret_key settings.save(ignore_permissions=True) frappe.db.sql("""DELETE FROM tabSingles WHERE doctype='Stripe Settings'""")
def execute(): publishable_key = frappe.db.sql("select value from tabSingles where doctype='Stripe Settings' and field='publishable_key'") if publishable_key: secret_key = get_decrypted_password('Stripe Settings', 'Stripe Settings', fieldname='secret_key', raise_exception=False) if secret_key: frappe.reload_doc('integrations', 'doctype', 'stripe_settings') frappe.db.commit() settings = frappe.new_doc("Stripe Settings") settings.gateway_name = frappe.db.get_value("Global Defaults", None, "default_company") or "Stripe Settings" settings.publishable_key = publishable_key settings.secret_key = secret_key settings.save(ignore_permissions=True) frappe.db.sql("""DELETE FROM tabSingles WHERE doctype='Stripe Settings'""")
def __init__(self): if frappe.db.get_value("HDFC UPI Settings", "HDFC UPI Settings", "test_mode") == "1": self.mcc = "6012" self.merchant_id = "HDFC000005853569" self.merchant_key = "d87822929aa83119f76cf6b762b87b0e" self.vpa = "capitalvia@hdfcbank" else: settings = frappe.get_doc("HDFC UPI Settings", "HDFC UPI Settings") if settings.mcc and settings.merchant_id: self.mcc = settings.mcc self.merchant_id = settings.merchant_id self.merchant_key = get_decrypted_password( "HDFC UPI Settings", "HDFC UPI Settings", "merchant_key") self.vpa = "capitalviaia@hdfcbank" else: frappe.throw("Connection details are missing")
def get_fedex_config(): fedex_server_doc_type = _get_configuration() if fedex_server_doc_type['use_test_server']: _test_server = True else: _test_server = False return FedexConfig(key=fedex_server_doc_type['fedex_key'], password=get_decrypted_password('DTI Fedex Configuration', PRIMARY_FEDEX_DOC_NAME, fieldname='password', raise_exception=True), account_number=fedex_server_doc_type['account_number'], meter_number=fedex_server_doc_type['meter_number'], freight_account_number=fedex_server_doc_type['freight_account_number'], use_test_server=_test_server)
def query_successful_authnet_transaction(request): merchantAuth = request.merchant_auth or None order_ref = request.reference_doc.name amount = request.amount if merchantAuth is None: merchantAuth = apicontractsv1.merchantAuthenticationType() merchantAuth.name = frappe.db.get_single_value("Authorizenet Settings", "api_login_id") merchantAuth.transactionKey = get_decrypted_password('Authorizenet Settings', 'Authorizenet Settings', fieldname='api_transaction_key', raise_exception=False) # set sorting parameters sorting = apicontractsv1.TransactionListSorting() sorting.orderBy = apicontractsv1.TransactionListOrderFieldEnum.id sorting.orderDescending = True # set paging and offset parameters paging = apicontractsv1.Paging() # Paging limit can be up to 1000 for this request paging.limit = 20 paging.offset = 1 transactionListRequest = apicontractsv1.getTransactionListRequest() transactionListRequest.merchantAuthentication = merchantAuth transactionListRequest.refId = order_ref transactionListRequest.sorting = sorting transactionListRequest.paging = paging unsettledTransactionListController = getUnsettledTransactionListController(transactionListRequest) if not frappe.db.get_single_value("Authorizenet Settings", "sandbox_mode"): unsettledTransactionListController.setenvironment(constants.PRODUCTION) unsettledTransactionListController.execute() # Work on the response response = unsettledTransactionListController.getresponse() if response is not None and \ response.messages.resultCode == apicontractsv1.messageTypeEnum.Ok and \ hasattr(response, 'transactions'): for transaction in response.transactions.transaction: if (transaction.transactionStatus == "capturedPendingSettlement" or \ transaction.transactionStatus == "authorizedPendingCapture") and \ transaction.invoiceNumber == order_ref and transaction.amount == amount: return transaction return False
def resend_otp(otp_auth_attempt_name): settings = frappe.get_single('CD User Management Settings') frappe.set_user(settings.default_user) default_limit = settings.resend_otp_limit mobile_number = '91' + frappe.db.get_value('CD OTP Auth Attempt', {'name': otp_auth_attempt_name}, 'mobile_number') authkey = get_decrypted_password('CD User Management Settings', 'CD User Management Settings', fieldname='msg91_auth_key', raise_exception=False) otp_auth_attempt_doc = frappe.get_doc('CD OTP Auth Attempt', otp_auth_attempt_name) otp_auth_attempt_doc.resend_count += 1 otp_auth_attempt_doc.save() resend_count = otp_auth_attempt_doc.resend_count if resend_count <= default_limit: if resend_count == default_limit: url = f"https://api.msg91.com/api/v5/otp/retry?mobile={mobile_number}&authkey={authkey}" elif resend_count < default_limit: url = f"https://api.msg91.com/api/v5/otp/retry?mobile={mobile_number}&authkey={authkey}&retrytype=text" headers = {"Content-Type": "application/json"} response = requests.request("GET", url, headers=headers) json_res = response.json() if response.status_code == 200: if json_res['type'] == 'error': frappe.log_error( "otp auth attempt name: " + otp_auth_attempt_name + " | error message: " + json_res['message'], "Resend OTP Error") frappe.local.response.http_status_code = 500 frappe.local.response["message"] = "Resend OTP Failed" if json_res['type'] == 'success': frappe.local.response["message"] = "OTP Sent Successfully" else: frappe.log_error( "otp auth attempt name: " + otp_auth_attempt_name + " | code: " + str(response.status_code) + " | response: " + response.text, "Resend OTP Error") frappe.local.response.http_status_code = 500 frappe.local.response["message"] = "Resend OTP Failed" else: frappe.local.response.http_status_code = 429 frappe.local.response["message"] = "Maximum Limit Reached"
def get_app_settings(app_details): parameters = {} doctype = docname = app_details["doctype"] app_settings = get_parameters(app_details) if app_settings: settings = app_settings["settings"] frappe.reload_doc("integrations", "doctype", "{0}_settings".format(app_details["service_name"].lower())) controller = frappe.get_meta("{0} Settings".format(app_details["service_name"])) for d in controller.fields: if settings.get(d.fieldname): if ''.join(set(cstr(settings.get(d.fieldname)))) == '*': setattr(settings, d.fieldname, get_decrypted_password(doctype, docname, d.fieldname, raise_exception=True)) parameters.update({d.fieldname : settings.get(d.fieldname)}) return parameters
def get_oauth_keys(provider): """get client_id and client_secret from database or conf""" # try conf keys = frappe.conf.get("{provider}_login".format(provider=provider)) if not keys: # try database client_id, client_secret = frappe.get_value("Social Login Key", provider, ["client_id", "client_secret"]) client_secret = get_decrypted_password("Social Login Key", provider, "client_secret") keys = { "client_id": client_id, "client_secret": client_secret } return keys else: return { "client_id": keys["client_id"], "client_secret": keys["client_secret"] }
def get_context(context): if frappe.session.user != "Guest": frappe.local.flags.redirect_location = "/" if frappe.session.data.user_type=="Website User" else "/desk" raise frappe.Redirect # get settings from site config context.no_header = True context.for_test = 'login.html' context["title"] = "Login" context["provider_logins"] = [] context["disable_signup"] = frappe.utils.cint(frappe.db.get_value("Website Settings", "Website Settings", "disable_signup")) providers = [i.name for i in frappe.get_all("Social Login Key", filters={"enable_social_login":1})] for provider in providers: client_id, base_url = frappe.get_value("Social Login Key", provider, ["client_id", "base_url"]) client_secret = get_decrypted_password("Social Login Key", provider, "client_secret") icon = get_icon_html(frappe.get_value("Social Login Key", provider, "icon"), small=True) if (get_oauth_keys(provider) and client_secret and client_id and base_url): context.provider_logins.append({ "name": provider, "provider_name": frappe.get_value("Social Login Key", provider, "provider_name"), "auth_url": get_oauth2_authorize_url(provider), "icon": icon }) context["social_login"] = True ldap_settings = get_ldap_settings() context["ldap_settings"] = ldap_settings login_name_placeholder = [_("Email address")] if frappe.utils.cint(frappe.get_system_settings("allow_login_using_mobile_number")): login_name_placeholder.append(_("Mobile number")) if frappe.utils.cint(frappe.get_system_settings("allow_login_using_user_name")): login_name_placeholder.append(_("Username")) context['login_name_placeholder'] = ' {0} '.format(_('or')).join(login_name_placeholder) return context
def referral(id,referrer,serial='',customer_fullname='', customer_msisdn='', pin='', via_ussd=True): if via_ussd==True: if is_this_a_varmani_sim(serial): if is_this_sim_sold(serial): return { 'message' : 'Sim already used for another customer, please use a new Varmani Sim to refer other customers.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command' : 'ERROR' } else: exists = is_this_customer_refered(id) if exists: if exists.full_name != None: return { 'message': exists.full_name + ' already referred by ' + exists.ref_full_name + ' therefore cannot be referred by you.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: return { 'message': exists.identity_number+ ' already referred by ' + exists.ref_full_name + ' therefore cannot be referred by you.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: if validate_id(id): new_varmani_network = frappe.new_doc('Varmani Network') #new_varmani_network.customer = id new_varmani_network.parent_varmani_network = referrer new_varmani_network.old_parent = referrer new_varmani_network.identity_number = id new_varmani_network.insert() new_rica = frappe.new_doc('RICA Submission') new_rica.customer = new_varmani_network.name sim = frappe.new_doc('Sims To Rica') sim.serial_no = serial new_rica.append('sims_to_rica',sim) new_rica.insert() frappe.db.commit() #print new_customer.name print new_varmani_network.name return { 'message': id + ' referred and linked.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'REFERRED' } else: return { 'message': 'ID Number:%s provide is not valid, please check the number and try again.' % id, 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: return { 'message' : 'You have not used a Varmani Sim, please use a Varmani Sim to refer other customers.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command' : 'ERROR' } else: exists = is_this_customer_refered(id) if exists: if exists.full_name != None: return { 'message': exists.full_name + ' already referred by ' + exists.ref_full_name + ' therefore cannot be referred by you.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: return { 'message': exists.identity_number + ' already referred by ' + exists.ref_full_name + ' therefore cannot be referred by you.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: if validate_id(id): exists = frappe.db.exists('Varmani Network',{'identity_number': referrer}) if exists: referrer = frappe.get_doc('Varmani Network', exists) if pin==get_decrypted_password('Varmani Network', referrer.name, 'pin', False): if not frappe.db.exists('Customer',{'fullname':customer_fullname}): new_customer = frappe.new_doc('Customer') new_customer.customer_type = 'Individual' new_customer.customer_name = customer_fullname new_customer.territory = 'South Africa' new_customer.customer_group = 'Individual' new_customer.insert(ignore_permissions=True) else: new_customer = frappe.get_doc('Customer', customer_fullname) new_varmani_network = frappe.new_doc('Varmani Network') new_varmani_network.customer = new_customer.name new_varmani_network.parent_varmani_network = referrer.name new_varmani_network.old_parent = referrer.name new_varmani_network.identity_number = id new_varmani_network.msisdn = customer_msisdn new_varmani_network.insert(ignore_permissions=True) new_rica = frappe.new_doc('RICA Submission') new_rica.customer = new_varmani_network.name fullnames = customer_fullname.split(' ') new_rica.first_names = customer_fullname[0:len(fullnames[0])] new_rica.last_names = customer_fullname[len(fullnames[0])+1:] #sim = frappe.new_doc('Sims To Rica') #sim.serial_no = serial #new_rica.append('sims_to_rica', sim) new_rica.insert(ignore_permissions=True) try: sendSMS(new_varmani_network.msisdn, 'Hello ' + customer_fullname + ', you have been refered to join NewCo. Please dial *130*826*01*' + id + ' to confirm.') except: pass frappe.db.commit() # print new_customer.name # print new_varmani_network.name return { 'message': 'Customer: ' + new_customer.name + ' with ID: ' + id + ' has been referred and linked to you.', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'REFERRED' } else: return { 'message': 'You have entered an incorrect pin', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: return { 'message': 'You are not a valid customer of NewCo so you cannot refer customers', 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' } else: return { 'message': 'ID Number:%s provide is not valid, please check the number and try again.' % id, 'message_type': 'PULL_REQ_CONFIRM', 'next_command': 'ERROR' }
def get_password(self, fieldname='password', raise_exception=True): if self.get(fieldname) and not self.is_dummy_password(self.get(fieldname)): return self.get(fieldname) return get_decrypted_password(self.doctype, self.name, fieldname, raise_exception=raise_exception)
def getMTNServiceSettings(): data =frappe.get_doc("MTN Services Settings") data.ussd_password = get_decrypted_password('MTN Services Settings', 'MTN Services Settings', 'ussd_password', False) data.sms_password = get_decrypted_password('MTN Services Settings', 'MTN Services Settings', 'sms_password', False) data.rica_password = get_decrypted_password('MTN Services Settings', 'MTN Services Settings', 'rica_password', False) return data
def get_password(self): return get_decrypted_password('Data Migration Connector', self.connector.name)