feat(payment request): create payment request as per payment schedules

Author: Jatin3128

erpnext/accounts/doctype/payment_reference/payment_reference.json

@@ -7,8 +7,8 @@
  "engine": "InnoDB",
  "field_order": [
   "payment_term",
-  "manually_selected",
-  "auto_selected",
+  "column_break_lnjp",
+  "payment_schedule",
   "section_break_fjhh",
   "description",
   "section_break_mjlv",
@@ -58,25 +58,23 @@
    "precision": "2"
   },
   {
-   "default": "0",
-   "fieldname": "manually_selected",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Manually Selected"
+   "fieldname": "column_break_lnjp",
+   "fieldtype": "Column Break"
   },
   {
-   "default": "1",
-   "fieldname": "auto_selected",
-   "fieldtype": "Check",
-   "hidden": 1,
-   "label": "Auto Selected"
+   "allow_on_submit": 1,
+   "fieldname": "payment_schedule",
+   "fieldtype": "Link",
+   "label": "Payment Schedule",
+   "options": "Payment Schedule",
+   "read_only": 1
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-12-05 11:26:29.877050",
+ "modified": "2026-01-19 02:21:36.455830",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reference",

erpnext/accounts/doctype/payment_reference/payment_reference.py

@@ -15,13 +15,12 @@ class PaymentReference(Document):
 		from frappe.types import DF
 
 		amount: DF.Currency
-		auto_selected: DF.Check
 		description: DF.SmallText | None
 		due_date: DF.Date | None
-		manually_selected: DF.Check
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
+		payment_schedule: DF.Link | None
 		payment_term: DF.Link | None
 	# end: auto-generated types
 

erpnext/accounts/doctype/payment_request/payment_request.json

@@ -21,7 +21,6 @@
   "reference_name",
   "payment_reference_section",
   "payment_reference",
-  "calculate_total_amount_by_selected_rows",
   "transaction_details",
   "grand_total",
   "currency",
@@ -160,6 +159,7 @@
    "label": "Amount",
    "non_negative": 1,
    "options": "currency",
+   "read_only_depends_on": "eval:doc.payment_reference.length>0",
    "reqd": 1
   },
   {
@@ -465,24 +465,20 @@
    "fieldname": "payment_reference_section",
    "fieldtype": "Section Break"
   },
-  {
-   "fieldname": "calculate_total_amount_by_selected_rows",
-   "fieldtype": "Button",
-   "label": "Calculate Total Amount by Selected Rows"
-  },
   {
    "fieldname": "payment_reference",
    "fieldtype": "Table",
    "label": "Payment Reference",
-   "options": "Payment Reference"
+   "options": "Payment Reference",
+   "read_only": 1
   }
  ],
  "grid_page_length": 50,
  "in_create": 1,
  "index_web_pages_for_search": 1,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-12-05 11:27:51.406257",
+ "modified": "2026-01-13 12:53:00.963274",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Request",

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -111,15 +111,36 @@ def validate(self):
 		if self.get("__islocal"):
 			self.status = "Draft"
 		self.validate_reference_document()
+		self.validate_against_payment_reference()
 		self.validate_payment_request_amount()
 		# self.validate_currency()
 		self.validate_subscription_details()
 
+	def validate_against_payment_reference(self):
+		if not self.payment_reference:
+			return
+
+		expected = sum(flt(r.amount) for r in self.payment_reference)
+		if flt(expected, self.precision("grand_total")) != flt(self.grand_total):
+			frappe.throw(_("Grand Total must match sum of Payment References"))
+
+		seen = set()
+		for r in self.payment_reference:
+			if not r.payment_schedule:
+				continue  # legacy mode → skip
+
+			if r.payment_schedule in seen:
+				frappe.throw(_("Duplicate Payment Schedule selected"))
+
+			seen.add(r.payment_schedule)
+
 	def validate_reference_document(self):
 		if not self.reference_doctype or not self.reference_name:
 			frappe.throw(_("To create a Payment Request reference document is required"))
 
 	def validate_payment_request_amount(self):
+		if self.payment_reference:
+			return
 		if self.grand_total == 0:
 			frappe.throw(
 				_("{0} cannot be zero").format(self.get_label_from_fieldname("grand_total")),
@@ -554,9 +575,63 @@ def make_payment_request(**args):
 	ref_doc = args.ref_doc or frappe.get_doc(args.dt, args.dn)
 	if not args.get("company"):
 		args.company = ref_doc.company
+
 	gateway_account = get_gateway_details(args) or frappe._dict()
 
-	grand_total = get_amount(ref_doc, gateway_account.get("payment_account"))
+	# Schedule-based PRs are allowed only if no Payment Entry exists for this document.
+	# Any existing Payment Entry forces legacy (amount-based) flow.
+	selected_payment_schedules = json.loads(args.get("schedules")) if args.get("schedules") else []
+
+	# Backend guard:
+	# If any Payment Entry exists, schedule-based PRs are not allowed.
+	if selected_payment_schedules and get_existing_payment_entry(ref_doc.name):
+		frappe.throw(
+			_(
+				"Payment Schedule based Payment Requests cannot be created because a Payment Entry already exists for this document."
+			)
+		)
+
+	has_payment_entry = bool(get_existing_payment_entry(ref_doc.name))
+
+	payment_reference = []
+
+	if selected_payment_schedules:
+		existing_payment_references = get_existing_payment_references(ref_doc.name)
+
+		if existing_payment_references:
+			existing_ids = {r["payment_schedule"] for r in existing_payment_references}
+			selected_ids = {r["name"] for r in selected_payment_schedules}
+			duplicate_ids = existing_ids & selected_ids
+
+			if duplicate_ids:
+				duplicate_schedules = []
+				for row in selected_payment_schedules:
+					if row["name"] in duplicate_ids:
+						existing_ref = next(
+							(r for r in existing_payment_references if r["payment_schedule"] == row["name"]),
+							{},
+						)
+						existing_pr = existing_ref.get("parent")
+						duplicate_schedules.append(
+							f"Payment Term: {row.get('payment_term')}, "
+							f"Due Date: {row.get('due_date')}, "
+							f"Amount: {row.get('payment_amount')} "
+							f"(already requested in PR {existing_pr})"
+						)
+				frappe.throw(
+					_("The following payment schedule(s) already exist:\n{0}").format(
+						"\n".join(duplicate_schedules)
+					)
+				)
+
+		payment_reference = set_payment_references(args.get("schedules"))
+
+	# Determine grand_total
+	if selected_payment_schedules and not has_payment_entry:
+		grand_total = sum(row.get("payment_amount") for row in selected_payment_schedules)
+	else:
+		grand_total = get_amount(ref_doc, gateway_account.get("payment_account"))
+
 	if not grand_total:
 		frappe.throw(_("Payment Entry is already created"))
 
@@ -566,7 +641,6 @@ def make_payment_request(**args):
 		loyalty_amount = validate_loyalty_points(ref_doc, int(args.loyalty_points))  # sets fields on ref_doc
 		ref_doc.db_update()
 		grand_total = grand_total - loyalty_amount
-
 	# fetches existing payment request `grand_total` amount
 	existing_payment_request_amount = get_existing_payment_request_amount(ref_doc)
 
@@ -586,21 +660,20 @@ def validate_and_calculate_grand_total(grand_total, existing_payment_request_amo
 			else:
 				# If PR's are processed, cancel all of them.
 				cancel_old_payment_requests(ref_doc.doctype, ref_doc.name)
-		else:
+		elif not selected_payment_schedules:
 			grand_total = validate_and_calculate_grand_total(grand_total, existing_payment_request_amount)
-
 	draft_payment_request = frappe.db.get_value(
 		"Payment Request",
 		{"reference_doctype": ref_doc.doctype, "reference_name": ref_doc.name, "docstatus": 0},
 	)
 
 	if draft_payment_request:
-		frappe.db.set_value(
-			"Payment Request", draft_payment_request, "grand_total", grand_total, update_modified=False
-		)
 		pr = frappe.get_doc("Payment Request", draft_payment_request)
 
-		set_payment_references(pr, ref_doc)
+		if selected_payment_schedules:
+			apply_payment_references(pr, payment_reference)
+			pr.save()
+
 	else:
 		bank_account = (
 			get_party_bank_account(args.get("party_type"), args.get("party"))
@@ -621,8 +694,6 @@ def validate_and_calculate_grand_total(grand_total, existing_payment_request_amo
 			party_account = get_party_account(party_type, ref_doc.get(party_type.lower()), ref_doc.company)
 			party_account_currency = get_account_currency(party_account)
 
-		set_payment_references(pr, ref_doc)
-
 		pr.update(
 			{
 				"payment_gateway_account": gateway_account.get("name"),
@@ -657,7 +728,10 @@ def validate_and_calculate_grand_total(grand_total, existing_payment_request_amo
 			}
 		)
 
-		# Update dimensions
+		if selected_payment_schedules:
+			apply_payment_references(pr, payment_reference)
+
+		# Dimensions
 		pr.update(
 			{
 				"cost_center": ref_doc.get("cost_center"),
@@ -686,6 +760,51 @@ def validate_and_calculate_grand_total(grand_total, existing_payment_request_amo
 	return pr.as_dict()
 
 
+def apply_payment_references(pr, payment_reference):
+	existing_refs = pr.get("payment_reference") or []
+
+	existing_ids = {r.get("payment_schedule") for r in existing_refs if r.get("payment_schedule")}
+	new_refs = [r for r in (payment_reference or []) if r.get("payment_schedule") not in existing_ids]
+	pr.set("payment_reference", existing_refs + new_refs)
+	pr.set("grand_total", sum(flt(r.get("amount")) for r in pr.get("payment_reference")))
+
+
+def set_payment_references(payment_schedules):
+	payment_schedules = json.loads(payment_schedules) if payment_schedules else []
+	payment_reference = []
+
+	for row in payment_schedules:
+		payment_reference.append(
+			{
+				"payment_term": row.get("payment_term"),
+				"payment_schedule": row.get("name"),
+				"description": row.get("description"),
+				"due_date": row.get("due_date"),
+				"amount": row.get("payment_amount"),
+			}
+		)
+
+	return payment_reference
+
+
+def get_existing_payment_entry(ref_docname):
+	pe = frappe.qb.DocType("Payment Entry")
+	per = frappe.qb.DocType("Payment Entry Reference")
+
+	existing_pe = (
+		frappe.qb.from_(pe)
+		.join(per)
+		.on(per.parent == pe.name)
+		.select(pe.name)
+		.where(pe.docstatus < 2)
+		.where(per.reference_name == ref_docname)
+		.limit(1)
+		.run()
+	)
+
+	return existing_pe
+
+
 def get_amount(ref_doc, payment_account=None):
 	"""get amount based on doctype"""
 	grand_total = 0
@@ -1032,36 +1151,20 @@ def get_irequests_of_payment_request(doc: str | None = None) -> list:
 	return res
 
 
-def set_payment_references(payment_request, ref_doc):
-	if not hasattr(ref_doc, "payment_schedule") or not ref_doc.payment_schedule:
-		return
-
-	existing_refs = get_existing_payment_references(ref_doc.name)
-
-	existing_map = {make_key(r.payment_term, r.due_date, r.amount): r for r in existing_refs}
-
-	payment_request.reference = []
-
-	for row in ref_doc.payment_schedule:
-		key = make_key(row.payment_term, row.due_date, row.payment_amount)
+@frappe.whitelist()
+def get_available_payment_schedules(reference_doctype, reference_name):
+	ref_doc = frappe.get_doc(reference_doctype, reference_name)
 
-		existing = existing_map.get(key)
-		if existing and (existing.manually_selected or existing.auto_selected):
-			continue
+	if not hasattr(ref_doc, "payment_schedule") or not ref_doc.payment_schedule:
+		return []
 
-		payment_request.append(
-			"payment_reference",
-			{
-				"payment_term": row.payment_term,
-				"description": row.description,
-				"due_date": row.due_date,
-				"amount": row.payment_amount,
-			},
-		)
+	if get_existing_payment_entry(reference_name):
+		return []
 
+	existing_refs = get_existing_payment_references(reference_name)
+	existing_ids = {r["payment_schedule"] for r in existing_refs if r.get("payment_schedule")}
 
-def make_key(payment_term, due_date, amount):
-	return (payment_term, due_date, flt(amount))
+	return [r for r in ref_doc.payment_schedule if r.name not in existing_ids]
 
 
 def get_existing_payment_references(reference_name):
@@ -1075,14 +1178,15 @@ def get_existing_payment_references(reference_name):
 		.select(
 			PRF.payment_term,
 			PRF.due_date,
-			PRF.amount,
-			PRF.manually_selected,
-			PRF.auto_selected,
+			PRF.amount.as_("payment_amount"),
+			PRF.payment_schedule,
 			PRF.parent,
 		)
 		.where(PR.reference_name == reference_name)
-		.where(PR.docstatus == 1)
-		.where(PR.status.isin(["Initiated", "Partially Paid", "Payment Ordered", "Paid"]))
+		.where(PR.docstatus < 2)
+		.where(
+			PR.status.isin(["Draft", "Requested", "Initiated", "Partially Paid", "Payment Ordered", "Paid"])
+		)
 	).run(as_dict=True)
 
 	return result