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)
