def setup_subscription(self):
non_profit_settings = frappe.get_doc('Non Profit Settings')
if not non_profit_settings.enable_razorpay_for_memberships:
frappe.throw(
'Please check Enable Razorpay for Memberships in {0} to setup subscription'
).format(
get_link_to_form('Non Profit Settings', 'Non Profit Settings'))
controller = get_payment_gateway_controller("Razorpay")
settings = controller.get_settings({})
plan_id = frappe.get_value("Membership Type", self.membership_type,
"razorpay_plan_id")
if not plan_id:
frappe.throw(_("Please setup Razorpay Plan ID"))
subscription_details = {
"plan_id": plan_id,
"billing_frequency": cint(non_profit_settings.billing_frequency),
"customer_notify": 1
}
args = {'subscription_details': subscription_details}
subscription = controller.setup_subscription(settings, **args)
return subscription
def paypal():
try:
controller = get_payment_gateway_controller("PayPal")
controller().validate_transaction_currency("USD")
payment_details = {
"amount": 600,
"title": "Payment for bill : 111",
"description": "payment via cart",
"reference_doctype": "Payment Request",
"reference_docname": "PR0001",
"payer_email": "*****@*****.**",
"payer_name": "Nuran Verkleij",
"order_id": "111",
"currency": "USD",
"payment_gateway": "Paypal",
"subscription_details": {
"plan_id": "plan_12313", # if Required
"start_date": "2018-08-30",
"billing_period":
"Month", # (Day, Week, SemiMonth, Month, Year),
"billing_frequency": 1,
"customer_notify": 1,
"upfront_amount": 1000
}
}
url = controller().get_payment_url(**payment_details)
print(url)
except Exception as e:
print(frappe.get_traceback())
def setup_subscription(self):
membership_settings = frappe.get_doc("Membership Settings")
if not membership_settings.enable_razorpay:
frappe.throw("Please enable Razorpay to setup subscription")
controller = get_payment_gateway_controller("Razorpay")
settings = controller.get_settings({})
plan_id = frappe.get_value("Membership Type", self.membership_type,
"razorpay_plan_id")
if not plan_id:
frappe.throw(_("Please setup Razorpay Plan ID"))
subscription_details = {
"plan_id": plan_id,
"billing_frequency": cint(membership_settings.billing_frequency),
"customer_notify": 1
}
args = {'subscription_details': subscription_details}
subscription = controller.setup_subscription(settings, **args)
return subscription
def get_payment_url(self):
if self.reference_doctype != "Fees":
data = frappe.db.get_value(self.reference_doctype,
self.reference_name,
["company", "customer_name"],
as_dict=1)
else:
data = frappe.db.get_value(self.reference_doctype,
self.reference_name, ["student_name"],
as_dict=1)
data.update({"company": frappe.defaults.get_defaults().company})
controller = get_payment_gateway_controller(self.payment_gateway)
controller.validate_transaction_currency(self.currency)
if hasattr(controller, 'validate_minimum_transaction_amount'):
controller.validate_minimum_transaction_amount(
self.currency, self.grand_total)
return controller.get_payment_url(
**{
"amount": flt(self.grand_total, self.precision("grand_total")),
"title": data.company.encode("utf-8"),
"description": self.subject.encode("utf-8"),
"reference_doctype": "Payment Request",
"reference_docname": self.name,
"payer_email": self.email_to or frappe.session.user,
"payer_name": frappe.safe_encode(data.customer_name),
"order_id": self.name,
"currency": self.currency
})
def get_gateways(context="{}", is_backend=0):
"""Gets a list of gateways that can be selected and their embedding information"""
context = json.loads(context)
context['is_backend'] = is_backend
gateway_selector = get_payment_gateway_controller("Gateway Selector")
gateways = []
for gateway in gateway_selector.gateways:
if is_gateway_available(gateway.service,
context,
is_backend=is_backend):
payload = {
"name": gateway.service.replace(' ', '_').lower(),
"data": {
key: gateway.get(key)
for key in ['label', 'icon', 'service', 'is_default']
},
"is_embedable": is_gateway_embedable(gateway.service)
}
if payload["is_embedable"]:
payload["embed_form"] = get_gateway_embed_form(gateway.service,
context=context)
gateways.append(payload)
return gateways
def on_submit(self):
if self.payment_request_type == 'Outward':
self.db_set('status', 'Initiated')
return
elif self.payment_request_type == 'Inward':
self.db_set('status', 'Requested')
send_mail = self.payment_gateway_validation(
) if self.payment_gateway else None
ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
if (hasattr(ref_doc, "order_type") and getattr(ref_doc, "order_type") == "Shopping Cart") \
or self.flags.mute_email:
send_mail = False
if send_mail and self.payment_channel != "Phone":
self.set_payment_request_url()
self.send_email()
self.make_communication_entry()
elif self.payment_channel == "Phone":
controller = get_payment_gateway_controller(self.payment_gateway)
payment_record = dict(reference_doctype="Payment Request",
reference_docname=self.name,
payment_reference=self.reference_name,
grand_total=self.grand_total,
sender=self.email_to,
currency=self.currency,
payment_gateway=self.payment_gateway)
controller.validate_transaction_currency(self.currency)
controller.request_for_payment(**payment_record)
def get_payment_gateway_url(self, doc):
if self.accept_payment:
controller = get_payment_gateway_controller(self.payment_gateway)
title = "Payment for {0} {1}".format(doc.doctype, doc.name)
amount = self.amount
if self.amount_based_on_field:
amount = doc.get(self.amount_field)
from decimal import Decimal
if amount is None or Decimal(amount) <= 0:
return frappe.utils.get_url(self.success_url or self.route)
payment_details = {
"amount": amount,
"title": title,
"description": title,
"reference_doctype": doc.doctype,
"reference_docname": doc.name,
"payer_email": frappe.session.user,
"payer_name": frappe.utils.get_fullname(frappe.session.user),
"order_id": doc.name,
"currency": self.currency,
"redirect_to": frappe.utils.get_url(self.success_url or self.route)
}
# Redirect the user to this url
return controller.get_payment_url(**payment_details)
def get_url_from_gateway(gateway, data):
"""Gets the gateway url when deferring gateways that can not be embeded"""
if isinstance(data, unicode) or isinstance(data, str):
data = json.loads(data)
gateway_selector = get_payment_gateway_controller("Gateway Selector")
for g in gateway_selector.gateways:
if g.service.replace(' ', '_').lower() == gateway:
gateway_name = g.service
break
else:
gateway_name = None
controller = get_payment_gateway_controller(gateway_name)
return controller.get_payment_url(**data)
def payment_gateway_validation(self):
try:
controller = get_payment_gateway_controller(self.payment_gateway)
if hasattr(controller, 'on_payment_request_submission'):
return controller.on_payment_request_submission(self)
else:
return True
except Exception:
return False
def payment_gateway_validation(self): try: controller = get_payment_gateway_controller(self.payment_gateway) if hasattr(controller, 'on_payment_request_submission'): return controller.on_payment_request_submission(self) else: return True except Exception: return False
def __init__(self):
self.successful_transaction = []
self.failed_transaction = []
self.plans = get_all_plans()
self.today = getdate()
self.next = add_months(getdate(), 1)
self.enabled = frappe.db.get_single_value("Membership Settings", 'enable_e_mandate_payments')
self.controller = get_payment_gateway_controller("Razorpay")
self.controller.init_client()
if self.controller.client:
self.client = self.controller.client
else:
frappe.throw("Razorpay Not Setup")
def request_phone_payment(self):
controller = get_payment_gateway_controller(self.payment_gateway)
request_amount = self.get_request_amount()
payment_record = dict(reference_doctype="Payment Request",
reference_docname=self.name,
payment_reference=self.reference_name,
request_amount=request_amount,
sender=self.email_to,
currency=self.currency,
payment_gateway=self.payment_gateway)
controller.validate_transaction_currency(self.currency)
controller.request_for_payment(**payment_record)
def get_payment_url(self):
data = frappe.db.get_value(self.reference_doctype, self.reference_name,
["company", "customer_name"], as_dict=1)
controller = get_payment_gateway_controller(self.payment_gateway)
controller.validate_transaction_currency(self.currency)
return controller.get_payment_url(**{
"amount": flt(self.grand_total, self.precision("grand_total")),
"title": data.company.encode("utf-8"),
"description": self.subject.encode("utf-8"),
"reference_doctype": "Payment Request",
"reference_docname": self.name,
"payer_email": self.email_to or frappe.session.user,
"payer_name": data.customer_name,
"order_id": self.name,
"currency": self.currency
})
def get_payment_url(self):
data = frappe.db.get_value(self.reference_doctype, self.reference_name,
["company", "customer_name"], as_dict=1)
controller = get_payment_gateway_controller(self.payment_gateway)
controller.validate_transaction_currency(self.currency)
return controller.get_payment_url(**{
"amount": flt(self.grand_total, self.precision("grand_total")),
"title": data.company,
"description": self.subject,
"reference_doctype": "Payment Request",
"reference_docname": self.name,
"payer_email": self.email_to or frappe.session.user,
"payer_name": data.customer_name,
"order_id": self.name,
"currency": self.currency
})
def get_razorpay_order(self):
controller = get_payment_gateway_controller("Razorpay")
title = "Ticekt Payment for {0}".format(self.name)
payment_details = {
"amount": 300,
"currency": "INR",
"title": title,
"description": title,
"reference_doctype": "Conference Participant",
"reference_docname": self.name,
"payer_email": frappe.session.user,
"payer_name": self.full_name,
"order_id": self.name,
"payment_capture": 1,
"receipt": self.name
}
return controller.create_order(**payment_details)
def register(args):
try:
args = json.loads(args)
users, currency, billing_cycle, coupon, email = args['users'], args['currency'], args['billing_cycle'],args['coupon'],args['email']
price_list = frappe.get_value("Price List", {"currency": currency, "selling": 1, "enabled": 1})
billing_cycle_price = frappe.get_value("Item Price",{"item_code": billing_cycle, "currency":currency, "selling": 1},"price_list_rate")
# add_on_price = 0 if add_ons == "0" else frappe.get_value("Item Price",{"item_code": add_ons, "currency":currency, "selling": 1},"price_list_rate")
total_cost = (billing_cycle_price * cint(users))
discount = 0
if coupon:
total_cost, discount = apply_code(coupon, total_cost, currency)
customer, customer_email = frappe.get_value("Customer", {"email": email }, ["name", "email"])
frappe.db.set_value("Customer", customer, "users", users)
frappe.db.commit()
sales_order = make_sales_order(customer,currency, price_list, discount, users, billing_cycle, coupon)
si = make_sales_invoice(sales_order.name,ignore_permissions=True)
si.insert(ignore_permissions=True)
si.submit()
update_coupon_usage(coupon)
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, submit_doc=True, mute_email=True, payment_gateway= payment_gateway_account[currency])
payment_details = get_payment_details(payment_request ,si, customer,customer_email, currency)
controller = get_payment_gateway_controller(payment_gateway[currency])
url = controller.get_payment_url(**payment_details)
return url
except Exception as e:
print(e)
print(frappe.get_traceback())
def get_payment_gateway_url(self, doc):
if self.accept_payment:
controller = get_payment_gateway_controller(self.payment_gateway)
title = "Payment for {0} {1}".format(doc.doctype, doc.name)
amount = self.amount
if self.amount_based_on_field:
amount = doc.get(self.amount_field)
payment_details = {
"amount": amount,
"title": title,
"description": title,
"reference_doctype": doc.doctype,
"reference_docname": doc.name,
"payer_email": frappe.session.user,
"payer_name": frappe.utils.get_fullname(frappe.session.user),
"order_id": doc.name,
"currency": self.currency,
"redirect_to": frappe.utils.get_url(self.route)
}
# Redirect the user to this url
return controller.get_payment_url(**payment_details)
def get_payment_url(self):
if self.reference_doctype != "Fees":
data = frappe.db.get_value(self.reference_doctype, self.reference_name, ["company", "customer_name"], as_dict=1)
else:
data = frappe.db.get_value(self.reference_doctype, self.reference_name, ["student_name"], as_dict=1)
data.update({"company": frappe.defaults.get_defaults().company})
controller = get_payment_gateway_controller(self.payment_gateway)
controller.validate_transaction_currency(self.currency)
if hasattr(controller, 'validate_minimum_transaction_amount'):
controller.validate_minimum_transaction_amount(self.currency, self.grand_total)
return controller.get_payment_url(**{
"amount": flt(self.grand_total, self.precision("grand_total")),
"title": data.company.encode("utf-8"),
"description": self.subject.encode("utf-8"),
"reference_doctype": "Payment Request",
"reference_docname": self.name,
"payer_email": self.email_to or frappe.session.user,
"payer_name": frappe.safe_encode(data.customer_name),
"order_id": self.name,
"currency": self.currency
})
def get_plans_for_membership(*args, **kwargs):
controller = get_payment_gateway_controller("Razorpay")
plans = controller.get_plans()
return [plan.get("item") for plan in plans.get("items")]
def get_gateway_embed_form(name, context={}):
"""Gets the gateway's embedable form information"""
controller = get_payment_gateway_controller(name)
return controller.get_embed_form(context=context)
def is_gateway_embedable(name):
"""Returns True if the the gateway supports get_embed_form api"""
controller = get_payment_gateway_controller(name)
return hasattr(controller, "is_embedable") and controller.is_embedable
def is_gateway_available(name, context, is_backend=0):
controller = get_payment_gateway_controller(name)
if hasattr(controller, "is_available"):
return controller.is_available(context, is_backend=is_backend)
return True
def get_client():
controller = get_payment_gateway_controller("Razorpay")
controller.init_client()
return controller.client
