390 lines
14 KiB
Python
390 lines
14 KiB
Python
import frappe
|
|
import requests
|
|
import urllib.parse
|
|
import json
|
|
|
|
from frappe import generate_hash
|
|
from frappe.utils import nowdate
|
|
|
|
|
|
@frappe.whitelist()
|
|
def check_autopay(customer):
|
|
cust = frappe.get_doc("Customer", customer)
|
|
return {
|
|
"autopay_enabled": bool(cust.custom_auto_pay_status),
|
|
"autopay_id": cust.custom_auto_pay_id if cust.custom_auto_pay_status else None
|
|
}
|
|
|
|
|
|
# ── NEW: fetch all unpaid invoices for a customer ────────────────────────────
|
|
|
|
@frappe.whitelist()
|
|
def get_unpaid_invoices(customer):
|
|
"""Return all submitted, unpaid Sales Invoices for this customer."""
|
|
invoices = frappe.get_all(
|
|
"Sales Invoice",
|
|
filters={
|
|
"customer": customer,
|
|
"docstatus": 1,
|
|
"outstanding_amount": [">", 0]
|
|
},
|
|
fields=["name", "posting_date", "customer_name", "outstanding_amount"],
|
|
order_by="posting_date asc"
|
|
)
|
|
return invoices
|
|
|
|
|
|
# ── AutoPay (unchanged) ───────────────────────────────────────────────────────
|
|
|
|
@frappe.whitelist()
|
|
def run_autopay_payment(invoice):
|
|
inv = frappe.get_doc("Sales Invoice", invoice)
|
|
if inv.outstanding_amount <= 0:
|
|
frappe.throw("Invoice is already fully paid")
|
|
|
|
cust = frappe.get_doc("Customer", inv.customer)
|
|
if not cust.custom_auto_pay_status or not cust.custom_auto_pay_id:
|
|
frappe.throw("Customer does not have AutoPay enabled")
|
|
|
|
payload = {
|
|
"autopay_id": cust.custom_auto_pay_id,
|
|
"amount": float(inv.outstanding_amount),
|
|
"invoice": inv.name
|
|
}
|
|
|
|
response = call_payment_api(payload)
|
|
if not response.get("success"):
|
|
frappe.throw(response.get("error", "Payment failed"))
|
|
|
|
return {
|
|
"success": True,
|
|
"message": "AutoPay payment successful",
|
|
"transaction_id": response.get("transaction_id")
|
|
}
|
|
|
|
|
|
# ── Token payment — now accepts invoice_names list ───────────────────────────
|
|
|
|
@frappe.whitelist()
|
|
def run_token_payment(
|
|
invoice,
|
|
token,
|
|
invoice_names=None,
|
|
first_name=None,
|
|
last_name=None,
|
|
company=None,
|
|
billing_zip=None,
|
|
save_autopay=0
|
|
):
|
|
if not token:
|
|
return {"success": False, "error": "Missing payment token"}
|
|
|
|
# invoice_names arrives as a JSON string from frappe.call args
|
|
if isinstance(invoice_names, str):
|
|
try:
|
|
invoice_names = json.loads(invoice_names)
|
|
except Exception:
|
|
invoice_names = [invoice]
|
|
|
|
if not invoice_names:
|
|
invoice_names = [invoice]
|
|
|
|
if not frappe.conf.get("enable_autopay_signup"):
|
|
save_autopay = 0
|
|
save_autopay = int(save_autopay or 0)
|
|
|
|
# Load all selected invoices and validate
|
|
invoices = []
|
|
total_amount = 0
|
|
|
|
for inv_name in invoice_names:
|
|
inv = frappe.get_doc("Sales Invoice", inv_name)
|
|
if inv.docstatus != 1:
|
|
frappe.throw(f"Invoice {inv_name} is not submitted")
|
|
if inv.outstanding_amount <= 0:
|
|
frappe.throw(f"Invoice {inv_name} is already fully paid")
|
|
invoices.append(inv)
|
|
total_amount += inv.outstanding_amount
|
|
|
|
# Use customer from the primary invoice
|
|
primary_inv = frappe.get_doc("Sales Invoice", invoice)
|
|
customer = frappe.get_doc("Customer", primary_inv.customer)
|
|
|
|
first_name = (first_name or customer.customer_name or "Customer").strip()
|
|
last_name = (last_name or ".").strip()
|
|
company = (company or "").strip()
|
|
billing_zip = (billing_zip or customer.get("billing_zip") or customer.get("pincode") or "")
|
|
|
|
# Use a combined order ID referencing all invoices
|
|
inv_label = invoice if len(invoices) == 1 else f"{invoice}+{len(invoices)-1}more"
|
|
order_id = f"{inv_label}-{generate_hash(length=6)}"
|
|
|
|
url = "https://secure.nmi.com/api/transact.php"
|
|
|
|
sale_data = {
|
|
"security_key": frappe.conf.get("nmi_security_key"),
|
|
"type": "sale",
|
|
"payment_token": token,
|
|
"amount": total_amount,
|
|
"orderid": order_id,
|
|
"first_name": first_name,
|
|
"last_name": last_name,
|
|
"company": company,
|
|
"email": primary_inv.contact_email or "",
|
|
"zip": billing_zip,
|
|
}
|
|
|
|
if save_autopay:
|
|
sale_data["customer_vault"] = "add_customer"
|
|
sale_data["customer_vault_id"] = customer.name.upper()
|
|
|
|
frappe.log_error(
|
|
f"invoice_names={invoice_names}\ntotal={total_amount}\norder_id={order_id}\nsave_autopay={save_autopay}",
|
|
"PAYMENT DEBUG - SALE REQUEST"
|
|
)
|
|
|
|
try:
|
|
sale_response = requests.post(url, data=sale_data, timeout=30)
|
|
sale_result = urllib.parse.parse_qs(sale_response.text)
|
|
frappe.log_error(sale_response.text[:120], "PAYMENT DEBUG - SALE RESPONSE")
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "PAYMENT DEBUG - SALE EXCEPTION")
|
|
return {"success": False, "error": "Payment request failed"}
|
|
|
|
success = sale_result.get("response", ["0"])[0]
|
|
transaction_id = sale_result.get("transactionid", [""])[0]
|
|
vault_id = sale_result.get("customer_vault_id", [""])[0]
|
|
|
|
if success != "1":
|
|
frappe.log_error(sale_response.text[:120], "PAYMENT DEBUG - SALE FAILED")
|
|
return {
|
|
"success": False,
|
|
"error": sale_result.get("responsetext", ["Error"])[0]
|
|
}
|
|
|
|
frappe.log_error(
|
|
f"transaction_id={transaction_id}\ntotal={total_amount}\ninvoices={invoice_names}",
|
|
"PAYMENT SUCCESS"
|
|
)
|
|
|
|
# Duplicate check on transaction ID
|
|
if frappe.db.exists("Payment Entry", {"reference_no": transaction_id}):
|
|
return {"success": True, "transaction_id": transaction_id, "duplicate": True}
|
|
|
|
try:
|
|
create_payment_entry(
|
|
invoices=invoices,
|
|
transaction_id=transaction_id,
|
|
mode_of_payment="Credit Card"
|
|
)
|
|
frappe.db.commit()
|
|
except Exception:
|
|
frappe.log_error(
|
|
frappe.get_traceback(),
|
|
"PAYMENT ENTRY FAILURE AFTER SUCCESSFUL CHARGE"
|
|
)
|
|
|
|
# Save AutoPay info
|
|
if save_autopay and vault_id:
|
|
try:
|
|
customer.custom_auto_pay_id = vault_id
|
|
customer.custom_auto_pay_status = 1
|
|
customer.custom_auto_pay_first_name = first_name
|
|
customer.custom_auto_pay_last_name = last_name
|
|
customer.custom_auto_pay_company = company
|
|
customer.custom_auto_pay_zip = billing_zip
|
|
customer.save(ignore_permissions=True)
|
|
frappe.db.commit()
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "AUTOPAY CUSTOMER SAVE FAILED")
|
|
|
|
return {"success": True, "transaction_id": transaction_id, "vault_id": vault_id}
|
|
|
|
|
|
# ── Payment Entry — now takes a list of invoices ─────────────────────────────
|
|
|
|
def create_payment_entry(invoices, transaction_id=None, mode_of_payment=None):
|
|
"""
|
|
Create a single Payment Entry covering one or more invoices.
|
|
`invoices` is a list of Sales Invoice document objects.
|
|
"""
|
|
if not invoices:
|
|
return
|
|
|
|
if transaction_id and frappe.db.exists("Payment Entry", {"reference_no": transaction_id}):
|
|
return
|
|
|
|
primary_inv = invoices[0]
|
|
total_amount = sum(inv.outstanding_amount for inv in invoices)
|
|
|
|
paid_to = (
|
|
"ENB Bank Account - NIL"
|
|
if mode_of_payment in ["ACH", "Credit Card"]
|
|
else frappe.db.get_value("Company", primary_inv.company, "default_cash_account")
|
|
)
|
|
|
|
if not paid_to:
|
|
frappe.throw("No receiving account configured")
|
|
|
|
pe = frappe.new_doc("Payment Entry")
|
|
pe.payment_type = "Receive"
|
|
pe.party_type = "Customer"
|
|
pe.party = primary_inv.customer
|
|
pe.posting_date = nowdate()
|
|
pe.mode_of_payment = mode_of_payment or "Credit Card"
|
|
pe.paid_amount = total_amount
|
|
pe.received_amount = total_amount
|
|
pe.paid_to = paid_to
|
|
pe.reference_no = transaction_id
|
|
pe.reference_date = nowdate()
|
|
|
|
for inv in invoices:
|
|
pe.append("references", {
|
|
"reference_doctype": "Sales Invoice",
|
|
"reference_name": inv.name,
|
|
"allocated_amount": inv.outstanding_amount
|
|
})
|
|
|
|
pe.insert(ignore_permissions=True)
|
|
pe.submit()
|
|
|
|
|
|
# ── AutoPay via vault (unchanged) ────────────────────────────────────────────
|
|
|
|
def call_payment_api(payload):
|
|
url = "https://secure.nmi.com/api/transact.php"
|
|
security_key = frappe.conf.get("nmi_security_key")
|
|
|
|
if not security_key:
|
|
frappe.throw("Payment gateway credentials not configured")
|
|
|
|
invoice = payload["invoice"]
|
|
order_id = f"{invoice}-{generate_hash(length=6)}"
|
|
|
|
data = {
|
|
"security_key": security_key,
|
|
"type": "sale",
|
|
"customer_vault_id": payload["autopay_id"],
|
|
"amount": payload["amount"],
|
|
"orderid": order_id
|
|
}
|
|
|
|
try:
|
|
response = requests.post(url, data=data, timeout=30)
|
|
frappe.logger("payments").info(
|
|
f"NMI AUTOPAY | Invoice: {invoice} | Order: {order_id} | {response.text[:120]}"
|
|
)
|
|
if not response.text:
|
|
frappe.throw("Payment processor returned empty response")
|
|
|
|
result = urllib.parse.parse_qs(response.text)
|
|
success = result.get("response", ["0"])[0]
|
|
transaction_id = result.get("transactionid", [""])[0]
|
|
message = result.get("responsetext", ["Payment failed"])[0]
|
|
payment_type = result.get("type", [""])[0]
|
|
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "NMI Payment API Error")
|
|
frappe.throw("Payment processor unreachable")
|
|
|
|
if success == "1":
|
|
mode_of_payment = "ACH" if payment_type == "check" else "Credit Card"
|
|
|
|
if frappe.db.exists("Payment Entry", {"reference_no": transaction_id}):
|
|
return {"success": True, "transaction_id": transaction_id, "duplicate": True}
|
|
|
|
try:
|
|
inv = frappe.get_doc("Sales Invoice", invoice)
|
|
create_payment_entry(
|
|
invoices=[inv],
|
|
transaction_id=transaction_id,
|
|
mode_of_payment=mode_of_payment
|
|
)
|
|
frappe.db.commit()
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "PAYMENT ENTRY FAILURE AFTER SUCCESSFUL CHARGE")
|
|
|
|
return {"success": True, "transaction_id": transaction_id}
|
|
|
|
return {"success": False, "error": message}
|
|
|
|
|
|
# ── Webhook (unchanged except uses new create_payment_entry signature) ────────
|
|
|
|
@frappe.whitelist(allow_guest=True)
|
|
def crystalclear_webhook():
|
|
data = frappe.local.form_dict
|
|
if data.get("response") != "1":
|
|
return "ignored"
|
|
|
|
invoice = data.get("orderid")
|
|
amount = data.get("amount")
|
|
transaction_id = data.get("transactionid")
|
|
payment_type = data.get("type")
|
|
mode_of_payment = "ACH" if payment_type == "check" else "Credit Card"
|
|
|
|
try:
|
|
inv = frappe.get_doc("Sales Invoice", invoice)
|
|
create_payment_entry(
|
|
invoices=[inv],
|
|
transaction_id=transaction_id,
|
|
mode_of_payment=mode_of_payment
|
|
)
|
|
frappe.db.commit()
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "WEBHOOK PAYMENT ENTRY FAILURE")
|
|
|
|
return "ok"
|
|
|
|
|
|
# ── save_to_autopay (unchanged) ───────────────────────────────────────────────
|
|
|
|
@frappe.whitelist()
|
|
def save_to_autopay(customer, token, first_name=None, last_name=None, company=None, billing_zip=None):
|
|
if not token:
|
|
return {"success": False, "error": "Missing payment token"}
|
|
|
|
cust = frappe.get_doc("Customer", customer)
|
|
first_name = (first_name or cust.customer_name or "Customer").strip()
|
|
last_name = (last_name or ".").strip()
|
|
company = (company or "").strip()
|
|
billing_zip = (billing_zip or cust.get("billing_zip") or cust.get("pincode") or "")
|
|
|
|
data = {
|
|
"security_key": frappe.conf.get("nmi_security_key"),
|
|
"type": "add_customer",
|
|
"payment_token": token,
|
|
"customer_vault": "add_customer",
|
|
"customer_vault_id": cust.name.upper(),
|
|
"first_name": first_name,
|
|
"last_name": last_name,
|
|
"company": company,
|
|
"zip": billing_zip,
|
|
}
|
|
|
|
try:
|
|
response = requests.post("https://secure.nmi.com/api/transact.php", data=data, timeout=30)
|
|
result = urllib.parse.parse_qs(response.text)
|
|
success = result.get("response", ["0"])[0]
|
|
returned_vault_id = result.get("customer_vault_id", [cust.name.upper()])[0]
|
|
message = result.get("responsetext", ["Failed"])[0]
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "NMI Vault Error")
|
|
return {"success": False, "error": "Vault request failed"}
|
|
|
|
if success == "1" or "duplicate" in message.lower():
|
|
try:
|
|
cust.custom_auto_pay_id = returned_vault_id
|
|
cust.custom_auto_pay_status = 1
|
|
cust.custom_auto_pay_first_name = first_name
|
|
cust.custom_auto_pay_last_name = last_name
|
|
cust.custom_auto_pay_company = company
|
|
cust.custom_auto_pay_zip = billing_zip
|
|
cust.save(ignore_permissions=True)
|
|
frappe.db.commit()
|
|
except Exception:
|
|
frappe.log_error(frappe.get_traceback(), "AUTOPAY CUSTOMER SAVE FAILED")
|
|
|
|
return {"success": True, "vault_id": returned_vault_id}
|
|
|
|
return {"success": False, "error": message} |