chore(release): Bumped to Version 15.55.3

## [15.55.3](https://github.com/frappe/erpnext/compare/v15.55.2...v15.55.3) (2025-03-29)

### Bug Fixes

* incorrect condition ([0721816](0721816763))

.github/release.yml

@@ -0,0 +1,4 @@
+changelog:
+  exclude:
+    labels:
+      - skip-release-notes

.github/workflows/label-base-on-title.yml

@@ -0,0 +1,30 @@
+name: "Auto-label PRs based on title"
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+jobs:
+  add-label-if-prefix-matches:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check PR title and add label if it matches prefixes
+        uses: actions/github-script@v7
+        continue-on-error: true
+        with:
+          script: |
+            const title = context.payload.pull_request.title.toLowerCase();
+            const prefixes = ['chore', 'ci', 'style', 'test', 'refactor'];
+            
+            // Check if the PR title starts with any of the prefixes
+            if (prefixes.some(prefix => title.startsWith(prefix))) {
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.pull_request.number,
+                labels: ['skip-release-notes']
+              });
+            }

.github/workflows/patch.yml

@@ -57,7 +57,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -66,7 +66,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         env:
           cache-name: cache-node-modules
         with:
@@ -81,7 +81,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v2
+      - uses: actions/cache@v4
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

.github/workflows/server-tests-mariadb.yml

@@ -76,7 +76,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -85,7 +85,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         env:
           cache-name: cache-node-modules
         with:
@@ -100,7 +100,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v2
+      - uses: actions/cache@v4
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

.github/workflows/server-tests-postgres.yml

@@ -66,7 +66,7 @@ jobs:
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
       - name: Cache pip
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: ~/.cache/pip
           key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
@@ -75,7 +75,7 @@ jobs:
             ${{ runner.os }}-
 
       - name: Cache node modules
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         env:
           cache-name: cache-node-modules
         with:
@@ -90,7 +90,7 @@ jobs:
         id: yarn-cache-dir-path
         run: echo "::set-output name=dir::$(yarn cache dir)"
 
-      - uses: actions/cache@v2
+      - uses: actions/cache@v4
         id: yarn-cache
         with:
           path: ${{ steps.yarn-cache-dir-path.outputs.dir }}

erpnext/__init__.py

@@ -4,7 +4,7 @@ import inspect
 import frappe
 from frappe.utils.user import is_website_user
 
-__version__ = "15.49.2"
+__version__ = "15.55.3"
 
 
 def get_default_company(user=None):

erpnext/accounts/doctype/account/account.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import _, throw
-from frappe.utils import cint, cstr
+from frappe.utils import add_to_date, cint, cstr, pretty_date
 from frappe.utils.nestedset import NestedSet, get_ancestors_of, get_descendants_of
 
 import erpnext
@@ -481,6 +481,7 @@ def get_account_autoname(account_number, account_name, company):
 
 @frappe.whitelist()
 def update_account_number(name, account_name, account_number=None, from_descendant=False):
+	_ensure_idle_system()
 	account = frappe.get_cached_doc("Account", name)
 	if not account:
 		return
@@ -501,7 +502,7 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 				"name",
 			)
 
-			if old_name:
+			if old_name and not from_descendant:
 				# same account in parent company exists
 				allow_child_account_creation = _("Allow Account Creation Against Child Company")
 
@@ -542,6 +543,7 @@ def update_account_number(name, account_name, account_number=None, from_descenda
 
 @frappe.whitelist()
 def merge_account(old, new):
+	_ensure_idle_system()
 	# Validate properties before merging
 	new_account = frappe.get_cached_doc("Account", new)
 	old_account = frappe.get_cached_doc("Account", old)
@@ -595,3 +597,31 @@ def sync_update_account_number_in_child(
 
 	for d in frappe.db.get_values("Account", filters=filters, fieldname=["company", "name"], as_dict=True):
 		update_account_number(d["name"], account_name, account_number, from_descendant=True)
+
+
+def _ensure_idle_system():
+	# Don't allow renaming if accounting entries are actively being updated, there are two main reasons:
+	# 1. Correctness: It's next to impossible to ensure that renamed account is not being used *right now*.
+	# 2. Performance: Renaming requires locking out many tables entirely and severely degrades performance.
+
+	if frappe.flags.in_test:
+		return
+
+	last_gl_update = None
+	try:
+		# We also lock inserts to GL entry table with for_update here.
+		last_gl_update = frappe.db.get_value("GL Entry", {}, "modified", for_update=True, wait=False)
+	except frappe.QueryTimeoutError:
+		# wait=False fails immediately if there's an active transaction.
+		last_gl_update = add_to_date(None, seconds=-1)
+
+	if not last_gl_update:
+		return
+
+	if last_gl_update > add_to_date(None, minutes=-5):
+		frappe.throw(
+			_(
+				"Last GL Entry update was done {}. This operation is not allowed while system is actively being used. Please wait for 5 minutes before retrying."
+			).format(pretty_date(last_gl_update)),
+			title=_("System In Use"),
+		)

erpnext/accounts/doctype/account/chart_of_accounts/chart_of_accounts.py

@@ -116,6 +116,7 @@ def identify_is_group(child):
 	return is_group
 
 
+@frappe.whitelist()
 def get_chart(chart_template, existing_company=None):
 	chart = {}
 	if existing_company:

erpnext/accounts/doctype/account/chart_of_accounts/verified/ch_240812_schulkontenrahmen_veb_de.json

@@ -0,0 +1,532 @@
+{
+	"country_code": "ch",
+	"name": "240812 Schulkontenrahmen VEB - DE",    
+    "tree": {
+        "Aktiven": {
+            "account_number": "1",
+            "is_group": 1,
+            "root_type": "Asset",
+            "Umlaufvermögen": {
+                "account_number": "10",
+                "is_group": 1,
+                "Flüssige Mittel": {
+                    "account_number": "100",
+                    "is_group": 1,
+                    "Kasse": {
+                        "account_number": "1000",
+                        "account_type": "Cash"
+                    },
+                    "Bankguthaben": {
+                        "account_number": "1020",
+                        "account_type": "Bank"
+                    }
+                },
+                "Kurzfristig gehaltene Aktiven mit Börsenkurs": {
+                    "account_number": "106",
+                    "is_group": 1,
+                    "Wertschriften": {
+                        "account_number": "1060"
+                    },
+                    "Wertberichtigungen Wertschriften": {
+                        "account_number": "1069"
+                    }
+                },
+                "Forderungen aus Lieferungen und Leistungen": {
+                    "account_number": "110",
+                    "is_group": 1,
+                    "Forderungen aus Lieferungen und Leistungen (Debitoren)": {
+                        "account_number": "1100"
+                    },
+                    "Delkredere": {
+                        "account_number": "1109"
+                    }
+                },
+                "Übrige kurzfristige Forderungen": {
+                    "account_number": "114",
+                    "is_group": 1,
+                    "Vorschüsse und Darlehen": {
+                        "account_number": "1140"
+                    },
+                    "Wertberichtigungen Vorschüsse und Darlehen": {
+                        "account_number": "1149"
+                    },
+                    "Vorsteuer MWST Material, Waren, Dienstleistungen, Energie": {
+                        "account_number": "1170"
+                    },
+                    "Vorsteuer MWST Investitionen, übriger Betriebsaufwand": {
+                        "account_number": "1171"
+                    },
+                    "Verrechnungssteuer": {
+                        "account_number": "1176"
+                    },
+                    "Forderungen gegenüber Sozialversicherungen und Vorsorgeeinrichtungen": {
+                        "account_number": "1180"
+                    },
+                    "Quellensteuer": {
+                        "account_number": "1189"
+                    },
+                    "Sonstige kurzfristige Forderungen": {
+                        "account_number": "1190"
+                    },
+                    "Wertberichtigungen sonstige kurzfristige Forderungen": {
+                        "account_number": "1199"
+                    }
+                },
+                "Vorräte und nicht fakturierte Dienstleistungen": {
+                    "account_number": "120",
+                    "is_group": 1,
+                    "Handelswaren": {
+                        "account_number": "1200"
+                    },
+                    "Rohstoffe": {
+                        "account_number": "1210"
+                    },
+                    "Werkstoffe": {
+                        "account_number": "1220"
+                    },
+                    "Hilfs- und Verbrauchsmaterial": {
+                        "account_number": "1230"
+                    },
+                    "Handelswaren in Konsignation": {
+                        "account_number": "1250"
+                    },
+                    "Fertige Erzeugnisse": {
+                        "account_number": "1260"
+                    },
+                    "Unfertige Erzeugnisse": {
+                        "account_number": "1270"
+                    },
+                    "Nicht fakturierte Dienstleistungen": {
+                        "account_number": "1280"
+                    }
+                },
+                "Aktive Rechnungsabgrenzungen": {
+                    "account_number": "130",
+                    "is_group": 1,
+                    "Bezahlter Aufwand des Folgejahres": {
+                        "account_number": "1300"
+                    },
+                    "Noch nicht erhaltener Ertrag": {
+                        "account_number": "1301"
+                    }
+                }
+            },
+            "Anlagevermögen": {
+                "account_number": "14",
+                "is_group": 1,
+                "Finanzanlagen": {
+                    "account_number": "140",
+                    "is_group": 1,
+                    "Wertschriften": {
+                        "account_number": "1400"
+                    },
+                    "Wertberichtigungen Wertschriften": {
+                        "account_number": "1409"
+                    },
+                    "Darlehen": {
+                        "account_number": "1440"
+                    },
+                    "Hypotheken": {
+                        "account_number": "1441"
+                    },
+                    "Wertberichtigungen langfristige Forderungen": {
+                        "account_number": "1449"
+                    }
+                },
+                "Beteiligungen": {
+                    "account_number": "148",
+                    "is_group": 1,
+                    "Beteiligungen": {
+                        "account_number": "1480"
+                    },
+                    "Wertberichtigungen Beteiligungen": {
+                        "account_number": "1489"
+                    }
+                },
+                "Mobile Sachanlagen": {
+                    "account_number": "150",
+                    "is_group": 1,
+                    "Maschinen und Apparate": {
+                        "account_number": "1500"
+                    },
+                    "Wertberichtigungen Maschinen und Apparate": {
+                        "account_number": "1509"
+                    },
+                    "Mobiliar und Einrichtungen": {
+                        "account_number": "1510"
+                    },
+                    "Wertberichtigungen Mobiliar und Einrichtungen": {
+                        "account_number": "1519"
+                    },
+                    "Büromaschinen, Informatik, Kommunikationstechnologie": {
+                        "account_number": "1520"
+                    },
+                    "Wertberichtigungen Büromaschinen, Informatik, Kommunikationstechnologie": {
+                        "account_number": "1529"
+                    },
+                    "Fahrzeuge": {
+                        "account_number": "1530"
+                    },
+                    "Wertberichtigungen Fahrzeuge": {
+                        "account_number": "1539"
+                    },
+                    "Werkzeuge und Geräte": {
+                        "account_number": "1540"
+                    },
+                    "Wertberichtigungen Werkzeuge und Geräte": {
+                        "account_number": "1549"
+                    }
+                },
+                "Immobile Sachanlagen": {
+                    "account_number": "160",
+                    "is_group": 1,
+                    "Geschäftsliegenschaften": {
+                        "account_number": "1600"
+                    },
+                    "Wertberichtigungen Geschäftsliegenschaften": {
+                        "account_number": "1609"
+                    }
+                },
+                "Immaterielle Werte": {
+                    "account_number": "170",
+                    "is_group": 1,
+                    "Patente, Know-how, Lizenzen, Rechte, Entwicklungen": {
+                        "account_number": "1700"
+                    },
+                    "Wertberichtigungen Patente, Know-how, Lizenzen, Rechte, Entwicklungen": {
+                        "account_number": "1709"
+                    },
+                    "Goodwill": {
+                        "account_number": "1770"
+                    },
+                    "Wertberichtigungen Goodwill": {
+                        "account_number": "1779"
+                    }
+                },
+                "Nicht einbezahltes Grund-, Gesellschafter- oder Stiftungskapital": {
+                    "account_number": "180",
+                    "is_group": 1,
+                    "Nicht einbezahltes Aktien-, Stamm-, Anteilschein- oder Stiftungskapital": {
+                        "account_number": "1850"
+                    }
+                }
+            }
+        },
+        "Passiven": {
+        "account_number": "2",
+        "is_group": 1,
+        "root_type": "Liability",
+            "Kurzfristiges Fremdkapital": {
+                "account_number": "20",
+                "is_group": 1,
+                "Verbindlichkeiten aus Lieferungen und Leistungen": {
+                    "account_number": "200",
+                    "is_group": 1,
+                    "Verbindlichkeiten aus Lieferungen und Leistungen (Kreditoren)": {
+                        "account_number": "2000"
+                    },
+                    "Erhaltene Anzahlungen": {
+                        "account_number": "2030"
+                    }
+                },
+                "Kurzfristige verzinsliche Verbindlichkeiten": {
+                    "account_number": "210",
+                    "is_group": 1,
+                    "Bankverbindlichkeiten": {
+                        "account_number": "2100"
+                    },
+                    "Verbindlichkeiten aus Finanzierungsleasing": {
+                        "account_number": "2120"
+                    },
+                    "Übrige verzinsliche Verbindlichkeiten": {
+                        "account_number": "2140"
+                    }
+                },
+                "Übrige kurzfristige Verbindlichkeiten": {
+                    "account_number": "220",
+                    "is_group": 1,
+                    "Geschuldete MWST (Umsatzsteuer)": {
+                        "account_number": "2200"
+                    },
+                    "Abrechnungskonto MWST": {
+                        "account_number": "2201"
+                    },
+                    "Verrechnungssteuer": {
+                        "account_number": "2206"
+                    },
+                    "Direkte Steuern": {
+                        "account_number": "2208"
+                    },
+                    "Sonstige kurzfristige Verbindlichkeiten": {
+                        "account_number": "2210"
+                    },
+                    "Beschlossene Ausschüttungen": {
+                        "account_number": "2261"
+                    },
+                    "Sozialversicherungen und Vorsorgeeinrichtungen": {
+                        "account_number": "2270"
+                    },
+                    "Quellensteuer": {
+                        "account_number": "2279"
+                    }
+                },
+                "Passive Rechnungsabgrenzungen und kurzfristige Rückstellungen": {
+                    "account_number": "230",
+                    "is_group": 1,
+                    "Noch nicht bezahlter Aufwand": {
+                        "account_number": "2300"
+                    },
+                    "Erhaltener Ertrag des Folgejahres": {
+                        "account_number": "2301"
+                    },
+                    "Kurzfristige Rückstellungen": {
+                        "account_number": "2330"
+                    }
+                }
+            },
+            "Langfristiges Fremdkapital": {
+                "account_number": "24",
+                "is_group": 1,
+                "Langfristige verzinsliche Verbindlichkeiten": {
+                    "account_number": "240",
+                    "is_group": 1,
+                    "Bankverbindlichkeiten": {
+                        "account_number": "2400"
+                    },
+                    "Verbindlichkeiten aus Finanzierungsleasing": {
+                        "account_number": "2420"
+                    },
+                    "Obligationenanleihen": {
+                        "account_number": "2430"
+                    },
+                    "Darlehen": {
+                        "account_number": "2450"
+                    },
+                    "Hypotheken": {
+                        "account_number": "2451"
+                    }
+                },
+                "Übrige langfristige Verbindlichkeiten": {
+                    "account_number": "250",
+                    "is_group": 1,
+                    "Übrige langfristige Verbindlichkeiten (unverzinslich)": {
+                        "account_number": "2500"
+                    }
+                },
+                "Rückstellungen sowie vom Gesetz vorgesehene ähnliche Positionen": {
+                    "account_number": "260",
+                    "is_group": 1,
+                    "Rückstellungen": {
+                        "account_number": "2600"
+                    }
+                }
+            },
+            "Eigenkapital (juristische Personen)": {
+                "account_number": "28",
+                "is_group": 1,
+                "Grund-, Gesellschafter- oder Stiftungskapital": {
+                    "account_number": "280",
+                    "is_group": 1,
+                    "Aktien-, Stamm-, Anteilschein- oder Stiftungskapital": {
+                        "account_number": "2800"
+                    }
+                },
+                "Reserven und Jahresgewinn oder Jahresverlust": {
+                    "account_number": "290",
+                    "is_group": 1,
+                    "Gesetzliche Kapitalreserve": {
+                        "account_number": "2900"
+                    },
+                    "Reserve für eigene Kapitalanteile": {
+                        "account_number": "2930"
+                    },
+                    "Aufwertungsreserve": {
+                        "account_number": "2940"
+                    },
+                    "Gesetzliche Gewinnreserve": {
+                        "account_number": "2950"
+                    },
+                    "Freiwillige Gewinnreserven": {
+                        "account_number": "2960"
+                    },
+                    "Gewinnvortrag oder Verlustvortrag": {
+                        "account_number": "2970"
+                    },
+                    "Jahresgewinn oder Jahresverlust": {
+                        "account_number": "2979"
+                    },
+                    "Eigene Aktien, Stammanteile oder Anteilscheine (Minusposten)": {
+                        "account_number": "2980"
+                    }
+                }
+            }
+        },
+        "Betrieblicher Ertrag aus Lieferungen und Leistungen": {
+            "account_number": "3",
+            "is_group": 1,
+            "root_type": "Income",
+            "Produktionserlöse": {
+                "account_number": "3000"
+            },
+            "Handelserlöse": {
+                "account_number": "3200"
+            },
+            "Dienstleistungserlöse": {
+                "account_number": "3400"
+            },
+            "Übrige Erlöse aus Lieferungen und Leistungen": {
+                "account_number": "3600"
+            },
+            "Eigenleistungen": {
+                "account_number": "3700"
+            },
+            "Eigenverbrauch": {
+                "account_number": "3710"
+            },
+            "Erlösminderungen": {
+                "account_number": "3800"
+            },
+            "Verluste Forderungen (Debitoren), Veränderung Delkredere": {
+                "account_number": "3805"
+            },
+            "Bestandesänderungen unfertige Erzeugnisse": {
+                "account_number": "3900"
+            },
+            "Bestandesänderungen fertige Erzeugnisse": {
+                "account_number": "3901"
+            },
+            "Bestandesänderungen nicht fakturierte Dienstleistungen": {
+                "account_number": "3940"
+            }
+        },
+        "Aufwand für Material, Handelswaren, Dienstleistungen und Energie": {
+            "account_number": "4",
+            "is_group": 1,
+            "root_type": "Expense",
+            "Materialaufwand Produktion": {
+                "account_number": "4000"
+            },
+            "Handelswarenaufwand": {
+                "account_number": "4200"
+            },
+            "Aufwand für bezogene Dienstleistungen": {
+                "account_number": "4400"
+            },
+            "Energieaufwand zur Leistungserstellung": {
+                "account_number": "4500"
+            },
+            "Aufwandminderungen": {
+                "account_number": "4900"
+            }
+        },
+        "Personalaufwand": {
+            "account_number": "5",
+            "is_group": 1,
+            "root_type": "Expense",
+            "Lohnaufwand": {
+                "account_number": "5000"
+            },
+            "Sozialversicherungsaufwand": {
+                "account_number": "5700"
+            },
+            "Übriger Personalaufwand": {
+                "account_number": "5800"
+            },
+            "Leistungen Dritter": {
+                "account_number": "5900"
+            }
+        },
+        "Übriger betrieblicher Aufwand, Abschreibungen und Wertberichtigungen sowie Finanzergebnis": {
+            "account_number": "6",
+            "is_group": 1,
+            "root_type": "Expense",
+            "Raumaufwand": {
+                "account_number": "6000"
+            },
+            "Unterhalt, Reparaturen, Ersatz mobile Sachanlagen": {
+                "account_number": "6100"
+            },
+            "Leasingaufwand mobile Sachanlagen": {
+                "account_number": "6105"
+            },
+            "Fahrzeug- und Transportaufwand": {
+                "account_number": "6200"
+            },
+            "Fahrzeugleasing und -mieten": {
+                "account_number": "6260"
+            },
+            "Sachversicherungen, Abgaben, Gebühren, Bewilligungen": {
+                "account_number": "6300"
+            },
+            "Energie- und Entsorgungsaufwand": {
+                "account_number": "6400"
+            },
+            "Verwaltungsaufwand": {
+                "account_number": "6500"
+            },
+            "Informatikaufwand inkl. Leasing": {
+                "account_number": "6570"
+            },
+            "Werbeaufwand": {
+                "account_number": "6600"
+            },
+            "Sonstiger betrieblicher Aufwand": {
+                "account_number": "6700"
+            },
+            "Abschreibungen und Wertberichtigungen auf Positionen des Anlagevermögens": {
+                "account_number": "6800"
+            },
+            "Finanzaufwand": {
+                "account_number": "6900"
+            },
+            "Finanzertrag": {
+                "account_number": "6950"
+            }
+        },
+        "Betrieblicher Nebenerfolg": {
+            "account_number": "7",
+            "is_group": 1,
+            "root_type": "Income",
+            "Ertrag Nebenbetrieb": {
+                "account_number": "7000"
+            },
+            "Aufwand Nebenbetrieb": {
+                "account_number": "7010"
+            },
+            "Ertrag betriebliche Liegenschaft": {
+                "account_number": "7500"
+            },
+            "Aufwand betriebliche Liegenschaft": {
+                "account_number": "7510"
+            }
+        },
+        "Betriebsfremder, ausserordentlicher, einmaliger oder periodenfremder Aufwand und Ertrag": {
+            "account_number": "8",
+            "is_group": 1,
+            "root_type": "Expense",
+            "Betriebsfremder Aufwand": {
+                "account_number": "8000"
+            },
+            "Betriebsfremder Ertrag": {
+                "account_number": "8100"
+            },
+            "Ausserordentlicher, einmaliger oder periodenfremder Aufwand": {
+                "account_number": "8500"
+            },
+            "Ausserordentlicher, einmaliger oder periodenfremder Ertrag": {
+                "account_number": "8510"
+            },
+            "Direkte Steuern": {
+                "account_number": "8900"
+            }
+        },
+        "Abschluss": {
+            "account_number": "9",
+            "is_group": 1,
+            "root_type": "Equity",
+            "Jahresgewinn oder Jahresverlust": {
+                "account_number": "9200"
+            }
+        }
+    }
+}

erpnext/accounts/doctype/account/chart_of_accounts/verified/in_standard_chart_of_accounts.json

@@ -98,7 +98,7 @@
                 "Office Maintenance Expenses": {},
                 "Office Rent": {},
                 "Postal Expenses": {},
-                "Print and Stationary": {},
+                "Print and Stationery": {},
                 "Rounded Off": {
                     "account_type": "Round Off"
                 },

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.json

@@ -31,7 +31,8 @@
    "label": "Reference Document Type",
    "options": "DocType",
    "read_only_depends_on": "eval:!doc.__islocal",
-   "reqd": 1
+   "reqd": 1,
+   "search_index": 1
   },
   {
    "default": "0",

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -41,6 +41,11 @@ class AccountingDimension(Document):
 		self.set_fieldname_and_label()
 
 	def validate(self):
+		self.validate_doctype()
+		validate_column_name(self.fieldname)
+		self.validate_dimension_defaults()
+
+	def validate_doctype(self):
 		if self.document_type in (
 			*core_doctypes_list,
 			"Accounting Dimension",
@@ -49,6 +54,7 @@ class AccountingDimension(Document):
 			"Accounting Dimension Detail",
 			"Company",
 			"Account",
+			"Finance Book",
 		):
 			msg = _("Not allowed to create accounting dimension for {0}").format(self.document_type)
 			frappe.throw(msg)
@@ -61,9 +67,6 @@ class AccountingDimension(Document):
 		if not self.is_new():
 			self.validate_document_type_change()
 
-		validate_column_name(self.fieldname)
-		self.validate_dimension_defaults()
-
 	def validate_document_type_change(self):
 		doctype_before_save = frappe.db.get_value("Accounting Dimension", self.name, "document_type")
 		if doctype_before_save != self.document_type:
@@ -102,6 +105,7 @@ class AccountingDimension(Document):
 
 	def on_update(self):
 		frappe.flags.accounting_dimensions = None
+		frappe.flags.accounting_dimensions_details = None
 
 
 def make_dimension_in_accounting_doctypes(doc, doclist=None):
@@ -262,7 +266,7 @@ def get_checks_for_pl_and_bs_accounts():
 		frappe.flags.accounting_dimensions_details = frappe.db.sql(
 			"""SELECT p.label, p.disabled, p.fieldname, c.default_dimension, c.company, c.mandatory_for_pl, c.mandatory_for_bs
 			FROM `tabAccounting Dimension`p ,`tabAccounting Dimension Detail` c
-			WHERE p.name = c.parent""",
+			WHERE p.name = c.parent AND p.disabled = 0""",
 			as_dict=1,
 		)
 

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -47,6 +47,7 @@
   "auto_reconciliation_job_trigger",
   "reconciliation_queue_size",
   "column_break_resa",
+  "exchange_gain_loss_posting_date",
   "invoicing_settings_tab",
   "accounts_transactions_settings_section",
   "over_billing_allowance",
@@ -389,7 +390,7 @@
   {
    "fieldname": "section_break_jpd0",
    "fieldtype": "Section Break",
-   "label": "Payment Reconciliations"
+   "label": "Payment Reconciliation Settings"
   },
   {
    "default": "0",
@@ -523,6 +524,14 @@
    "fieldname": "ignore_is_opening_check_for_reporting",
    "fieldtype": "Check",
    "label": "Ignore Is Opening check for reporting"
+  },
+  {
+   "default": "Payment",
+   "description": "Only applies for Normal Payments",
+   "fieldname": "exchange_gain_loss_posting_date",
+   "fieldtype": "Select",
+   "label": "Posting Date Inheritance for Exchange Gain / Loss",
+   "options": "Invoice\nPayment\nReconciliation Date"
   }
  ],
  "icon": "icon-cog",
@@ -530,7 +539,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2025-01-18 21:24:19.840745",
+ "modified": "2025-01-23 13:15:44.077853",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -45,6 +45,7 @@ class AccountsSettings(Document):
 		enable_fuzzy_matching: DF.Check
 		enable_immutable_ledger: DF.Check
 		enable_party_matching: DF.Check
+		exchange_gain_loss_posting_date: DF.Literal["Invoice", "Payment", "Reconciliation Date"]
 		frozen_accounts_modifier: DF.Link | None
 		general_ledger_remarks_length: DF.Int
 		ignore_account_closing_balance: DF.Check

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -159,9 +159,6 @@ def get_payment_entries_for_bank_clearance(
 		as_dict=1,
 	)
 
-	if bank_account:
-		condition += "and bank_account = %(bank_account)s"
-
 	payment_entries = frappe.db.sql(
 		f"""
 			select
@@ -183,7 +180,6 @@ def get_payment_entries_for_bank_clearance(
 			"account": account,
 			"from": from_date,
 			"to": to_date,
-			"bank_account": bank_account,
 		},
 		as_dict=1,
 	)

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.js

@@ -19,10 +19,15 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	onload: function (frm) {
+		if (!frm.doc.company) {
+			frm.set_value("company", frappe.defaults.get_default("company"));
+		}
+
 		// Set default filter dates
 		let today = frappe.datetime.get_today();
 		frm.doc.bank_statement_from_date = frappe.datetime.add_months(today, -1);
 		frm.doc.bank_statement_to_date = today;
+
 		frm.trigger("bank_account");
 	},
 
@@ -98,7 +103,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 
 	make_reconciliation_tool(frm) {
 		frm.get_field("reconciliation_tool_cards").$wrapper.empty();
-		if (frm.doc.bank_account && frm.doc.bank_statement_to_date) {
+		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_to_date) {
 			frm.trigger("get_cleared_balance").then(() => {
 				if (
 					frm.doc.bank_account &&
@@ -114,7 +119,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	get_account_opening_balance(frm) {
-		if (frm.doc.bank_account && frm.doc.bank_statement_from_date) {
+		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_from_date) {
 			frappe.call({
 				method: "erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {
@@ -130,7 +135,7 @@ frappe.ui.form.on("Bank Reconciliation Tool", {
 	},
 
 	get_cleared_balance(frm) {
-		if (frm.doc.bank_account && frm.doc.bank_statement_to_date) {
+		if (frm.doc.company && frm.doc.bank_account && frm.doc.bank_statement_to_date) {
 			return frappe.call({
 				method: "erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.get_account_balance",
 				args: {

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -374,9 +374,36 @@ def auto_reconcile_vouchers(
 	to_reference_date=None,
 ):
 	frappe.flags.auto_reconcile_vouchers = True
-	reconciled, partially_reconciled = set(), set()
 
 	bank_transactions = get_bank_transactions(bank_account)
+
+	if len(bank_transactions) > 10:
+		frappe.enqueue(
+			method="erpnext.accounts.doctype.bank_reconciliation_tool.bank_reconciliation_tool.start_auto_reconcile",
+			queue="long",
+			bank_transactions=bank_transactions,
+			from_date=from_date,
+			to_date=to_date,
+			filter_by_reference_date=filter_by_reference_date,
+			from_reference_date=from_reference_date,
+			to_reference_date=to_reference_date,
+		)
+		frappe.msgprint(_("Auto Reconciliation has started in the background"))
+	else:
+		start_auto_reconcile(
+			bank_transactions,
+			from_date,
+			to_date,
+			filter_by_reference_date,
+			from_reference_date,
+			to_reference_date,
+		)
+
+
+def start_auto_reconcile(
+	bank_transactions, from_date, to_date, filter_by_reference_date, from_reference_date, to_reference_date
+):
+	reconciled, partially_reconciled = set(), set()
 	for transaction in bank_transactions:
 		linked_payments = get_linked_payments(
 			transaction.name,
@@ -414,7 +441,6 @@ def auto_reconcile_vouchers(
 	frappe.msgprint(title=_("Auto Reconciliation"), msg=alert_message, indicator=indicator)
 
 	frappe.flags.auto_reconcile_vouchers = False
-	return reconciled, partially_reconciled
 
 
 def get_auto_reconcile_message(partially_reconciled, reconciled):
@@ -802,7 +828,6 @@ def get_je_matching_query(
 		.where(je.clearance_date.isnull())
 		.where(jea.account == common_filters.bank_account)
 		.where(amount_equality if exact_match else getattr(jea, amount_field) > 0.0)
-		.where(je.docstatus == 1)
 		.where(filter_by_date)
 		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
 	)

erpnext/accounts/doctype/bank_transaction/auto_match_party.py

@@ -45,45 +45,41 @@ class AutoMatchbyAccountIBAN:
 		if not (self.bank_party_account_number or self.bank_party_iban):
 			return None
 
-		result = self.match_account_in_party()
-		return result
+		return self.match_account_in_party()
 
 	def match_account_in_party(self) -> tuple | None:
-		"""Check if there is a IBAN/Account No. match in Customer/Supplier/Employee"""
-		result = None
-		parties = get_parties_in_order(self.deposit)
-		or_filters = self.get_or_filters()
+		"""
+		Returns (Party Type, Party) if a matching account is found in Bank Account or Employee:
+		1. Get party from a matching (iban/account no) Bank Account
+		2. If not found, get party from Employee with matching bank account details (iban/account no)
+		"""
+		if not (self.bank_party_account_number or self.bank_party_iban):
+			# Nothing to match
+			return None
 
-		for party in parties:
-			party_result = frappe.db.get_all(
-				"Bank Account", or_filters=or_filters, pluck="party", limit_page_length=1
-			)
+		# Search for a matching Bank Account that has party set
+		party_result = frappe.db.get_all(
+			"Bank Account",
+			or_filters=self.get_or_filters(),
+			filters={"party_type": ("is", "set"), "party": ("is", "set")},
+			fields=["party", "party_type"],
+			limit_page_length=1,
+		)
+		if result := party_result[0] if party_result else None:
+			return (result["party_type"], result["party"])
 
-			if party == "Employee" and not party_result:
-				# Search in Bank Accounts first for Employee, and then Employee record
-				if "bank_account_no" in or_filters:
-					or_filters["bank_ac_no"] = or_filters.pop("bank_account_no")
+		# If no party is found, search in Employee (since it has bank account details)
+		if employee_result := frappe.db.get_all(
+			"Employee", or_filters=self.get_or_filters("Employee"), pluck="name", limit_page_length=1
+		):
+			return ("Employee", employee_result[0])
 
-				party_result = frappe.db.get_all(
-					party, or_filters=or_filters, pluck="name", limit_page_length=1
-				)
-
-				if "bank_ac_no" in or_filters:
-					or_filters["bank_account_no"] = or_filters.pop("bank_ac_no")
-
-			if party_result:
-				result = (
-					party,
-					party_result[0],
-				)
-				break
-
-		return result
-
-	def get_or_filters(self) -> dict:
+	def get_or_filters(self, party: str | None = None) -> dict:
+		"""Return OR filters for Bank Account and IBAN"""
 		or_filters = {}
 		if self.bank_party_account_number:
-			or_filters["bank_account_no"] = self.bank_party_account_number
+			bank_ac_field = "bank_ac_no" if party == "Employee" else "bank_account_no"
+			or_filters[bank_ac_field] = self.bank_party_account_number
 
 		if self.bank_party_iban:
 			or_filters["iban"] = self.bank_party_iban
@@ -103,8 +99,7 @@ class AutoMatchbyPartyNameDescription:
 		if not (self.bank_party_name or self.description):
 			return None
 
-		result = self.match_party_name_desc_in_party()
-		return result
+		return self.match_party_name_desc_in_party()
 
 	def match_party_name_desc_in_party(self) -> tuple | None:
 		"""Fuzzy search party name and/or description against parties in the system"""
@@ -113,7 +108,8 @@ class AutoMatchbyPartyNameDescription:
 
 		for party in parties:
 			filters = {"status": "Active"} if party == "Employee" else {"disabled": 0}
-			names = frappe.get_all(party, filters=filters, pluck=party.lower() + "_name")
+			field = f"{party.lower()}_name"
+			names = frappe.get_all(party, filters=filters, fields=[f"{field} as party_name", "name"])
 
 			for field in ["bank_party_name", "description"]:
 				if not self.get(field):
@@ -132,16 +128,14 @@ class AutoMatchbyPartyNameDescription:
 
 	def fuzzy_search_and_return_result(self, party, names, field) -> tuple | None:
 		skip = False
-		result = process.extract(query=self.get(field), choices=names, scorer=fuzz.token_set_ratio)
+		result = process.extract(
+			query=self.get(field),
+			choices={row.get("name"): row.get("party_name") for row in names},
+			scorer=fuzz.token_set_ratio,
+		)
 		party_name, skip = self.process_fuzzy_result(result)
 
-		if not party_name:
-			return None, skip
-
-		return (
-			party,
-			party_name,
-		), skip
+		return ((party, party_name), skip) if party_name else (None, skip)
 
 	def process_fuzzy_result(self, result: list | None):
 		"""
@@ -150,30 +144,30 @@ class AutoMatchbyPartyNameDescription:
 
 		Returns: Result, Skip (whether or not to discontinue matching)
 		"""
-		PARTY, SCORE, CUTOFF = 0, 1, 80
+		SCORE, PARTY_ID, CUTOFF = 1, 2, 80
 
 		if not result or not len(result):
 			return None, False
 
 		first_result = result[0]
 		if len(result) == 1:
-			return (first_result[PARTY] if first_result[SCORE] > CUTOFF else None), True
+			return (first_result[PARTY_ID] if first_result[SCORE] > CUTOFF else None), True
 
-		second_result = result[1]
 		if first_result[SCORE] > CUTOFF:
+			second_result = result[1]
 			# If multiple matches with the same score, return None but discontinue matching
 			# Matches were found but were too close to distinguish between
 			if first_result[SCORE] == second_result[SCORE]:
 				return None, True
 
-			return first_result[PARTY], True
+			return first_result[PARTY_ID], True
 		else:
 			return None, False
 
 
 def get_parties_in_order(deposit: float) -> list:
-	parties = ["Supplier", "Employee", "Customer"]  # most -> least likely to receive
-	if flt(deposit) > 0:
-		parties = ["Customer", "Supplier", "Employee"]  # most -> least likely to pay
-
-	return parties
+	return (
+		["Customer", "Supplier", "Employee"]  # most -> least likely to pay us
+		if flt(deposit) > 0
+		else ["Supplier", "Employee", "Customer"]  # most -> least likely to receive from us
+	)

erpnext/accounts/doctype/coupon_code/test_coupon_code.py

@@ -128,7 +128,7 @@ class TestCouponCode(unittest.TestCase):
 			item_code="_Test Tesla Car",
 			rate=5000,
 			qty=1,
-			do_not_submit=True,
+			do_not_save=True,
 		)
 
 		self.assertEqual(so.items[0].rate, 5000)

erpnext/accounts/doctype/gl_entry/gl_entry.json

@@ -279,7 +279,8 @@
   {
    "fieldname": "transaction_exchange_rate",
    "fieldtype": "Float",
-   "label": "Transaction Exchange Rate"
+   "label": "Transaction Exchange Rate",
+   "precision": "9"
   },
   {
    "fieldname": "debit_in_transaction_currency",
@@ -357,7 +358,7 @@
  "idx": 1,
  "in_create": 1,
  "links": [],
- "modified": "2024-08-22 13:03:39.997475",
+ "modified": "2025-02-21 14:36:49.431166",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "GL Entry",

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -129,7 +129,7 @@ class GLEntry(Document):
 			if not self.get(k):
 				frappe.throw(_("{0} is required").format(_(self.meta.get_label(k))))
 
-		if not (self.party_type and self.party):
+		if not self.is_cancelled and not (self.party_type and self.party):
 			account_type = frappe.get_cached_value("Account", self.account, "account_type")
 			if account_type == "Receivable":
 				frappe.throw(

erpnext/accounts/doctype/gl_entry/test_gl_entry.py

@@ -124,3 +124,20 @@ class TestGLEntry(unittest.TestCase):
 				str(e),
 				"Party Type and Party can only be set for Receivable / Payable account_Test Account Cost for Goods Sold - _TC",
 			)
+
+	def test_validate_account_party_type_shareholder(self):
+		jv = make_journal_entry(
+			"Opening Balance Equity - _TC",
+			"Cash - _TC",
+			100,
+			"_Test Cost Center - _TC",
+			save=False,
+			submit=False,
+		)
+
+		for row in jv.accounts:
+			row.party_type = "Shareholder"
+			break
+
+		jv.save().submit()
+		self.assertEqual(1, jv.docstatus)

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -430,12 +430,6 @@ frappe.ui.form.on("Journal Entry Account", {
 			});
 		}
 	},
-	cost_center: function (frm, dt, dn) {
-		// Don't reset for Gain/Loss type journals, as it will make Debit and Credit values '0'
-		if (frm.doc.voucher_type != "Exchange Gain Or Loss") {
-			erpnext.journal_entry.set_account_details(frm, dt, dn);
-		}
-	},
 
 	account: function (frm, dt, dn) {
 		erpnext.journal_entry.set_account_details(frm, dt, dn);

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -141,6 +141,7 @@ class JournalEntry(AccountsController):
 		self.validate_empty_accounts_table()
 		self.validate_inter_company_accounts()
 		self.validate_depr_entry_voucher_type()
+		self.validate_company_in_accounting_dimension()
 		self.validate_advance_accounts()
 
 		if self.docstatus == 0:
@@ -575,8 +576,22 @@ class JournalEntry(AccountsController):
 		if customers:
 			from erpnext.selling.doctype.customer.customer import check_credit_limit
 
+			customer_details = frappe._dict(
+				frappe.db.get_all(
+					"Customer Credit Limit",
+					filters={
+						"parent": ["in", customers],
+						"parenttype": ["=", "Customer"],
+						"company": ["=", self.company],
+					},
+					fields=["parent", "bypass_credit_limit_check"],
+					as_list=True,
+				)
+			)
+
 			for customer in customers:
-				check_credit_limit(customer, self.company)
+				ignore_outstanding_sales_order = bool(customer_details.get(customer))
+				check_credit_limit(customer, self.company, ignore_outstanding_sales_order)
 
 	def validate_cheque_info(self):
 		if self.voucher_type in ["Bank Entry"]:
@@ -1059,14 +1074,15 @@ class JournalEntry(AccountsController):
 		gl_map = []
 
 		company_currency = erpnext.get_company_currency(self.company)
+		self.transaction_currency = company_currency
+		self.transaction_exchange_rate = 1
 		if self.multi_currency:
 			for row in self.get("accounts"):
 				if row.account_currency != company_currency:
-					self.currency = row.account_currency
-					self.conversion_rate = row.exchange_rate
+					# Journal assumes the first foreign currency as transaction currency
+					self.transaction_currency = row.account_currency
+					self.transaction_exchange_rate = row.exchange_rate
 					break
-		else:
-			self.currency = company_currency
 
 		for d in self.get("accounts"):
 			if d.debit or d.credit or (self.voucher_type == "Exchange Gain Or Loss"):
@@ -1091,6 +1107,18 @@ class JournalEntry(AccountsController):
 							"credit_in_account_currency": flt(
 								d.credit_in_account_currency, d.precision("credit_in_account_currency")
 							),
+							"transaction_currency": self.transaction_currency,
+							"transaction_exchange_rate": self.transaction_exchange_rate,
+							"debit_in_transaction_currency": flt(
+								d.debit_in_account_currency, d.precision("debit_in_account_currency")
+							)
+							if self.transaction_currency == d.account_currency
+							else flt(d.debit, d.precision("debit")) / self.transaction_exchange_rate,
+							"credit_in_transaction_currency": flt(
+								d.credit_in_account_currency, d.precision("credit_in_account_currency")
+							)
+							if self.transaction_currency == d.account_currency
+							else flt(d.credit, d.precision("credit")) / self.transaction_exchange_rate,
 							"against_voucher_type": d.reference_type,
 							"against_voucher": d.reference_name,
 							"remarks": remarks,

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -146,10 +146,9 @@ class TestJournalEntry(unittest.TestCase):
 				"credit_in_account_currency": 0 if diff > 0 else abs(diff),
 			},
 		)
-		jv.insert()
 
 		if account_bal == stock_bal:
-			self.assertRaises(StockAccountInvalidTransaction, jv.submit)
+			self.assertRaises(StockAccountInvalidTransaction, jv.save)
 			frappe.db.rollback()
 		else:
 			jv.submit()
@@ -576,7 +575,7 @@ class TestJournalEntry(unittest.TestCase):
 			order_by="account",
 		)
 		expected = [
-			{"account": "_Test Bank - _TC", "transaction_exchange_rate": 1.0},
+			{"account": "_Test Bank - _TC", "transaction_exchange_rate": 85.0},
 			{"account": "_Test Receivable USD - _TC", "transaction_exchange_rate": 85.0},
 		]
 		self.assertEqual(expected, actual)
@@ -592,13 +591,14 @@ def make_journal_entry(
 	save=True,
 	submit=False,
 	project=None,
+	company=None,
 ):
 	if not cost_center:
 		cost_center = "_Test Cost Center - _TC"
 
 	jv = frappe.new_doc("Journal Entry")
 	jv.posting_date = posting_date or nowdate()
-	jv.company = "_Test Company"
+	jv.company = company or "_Test Company"
 	jv.user_remark = "test"
 	jv.multi_currency = 1
 	jv.set(

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -258,6 +258,10 @@ frappe.ui.form.on("Payment Entry", {
 		frappe.flags.allocate_payment_amount = true;
 	},
 
+	validate: async function (frm) {
+		await frm.events.set_exchange_gain_loss_deduction(frm);
+	},
+
 	validate_company: (frm) => {
 		if (!frm.doc.company) {
 			frappe.throw({ message: __("Please select a Company first."), title: __("Mandatory") });
@@ -812,27 +816,41 @@ frappe.ui.form.on("Payment Entry", {
 
 	paid_amount: function (frm) {
 		frm.set_value("base_paid_amount", flt(frm.doc.paid_amount) * flt(frm.doc.source_exchange_rate));
+		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
+		if (!frm.doc.received_amount) {
+			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
+				frm.set_value("received_amount", frm.doc.paid_amount);
+			} else if (company_currency == frm.doc.paid_to_account_currency) {
+				frm.set_value("received_amount", frm.doc.base_paid_amount);
+				frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+			}
+		}
 		frm.trigger("reset_received_amount");
 		frm.events.hide_unhide_fields(frm);
 	},
 
 	received_amount: function (frm) {
+		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 		frm.set_paid_amount_based_on_received_amount = true;
 
-		if (!frm.doc.paid_amount && frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
-			frm.set_value("paid_amount", frm.doc.received_amount);
-
-			if (frm.doc.target_exchange_rate) {
-				frm.set_value("source_exchange_rate", frm.doc.target_exchange_rate);
-			}
-			frm.set_value("base_paid_amount", frm.doc.base_received_amount);
-		}
-
 		frm.set_value(
 			"base_received_amount",
 			flt(frm.doc.received_amount) * flt(frm.doc.target_exchange_rate)
 		);
 
+		if (!frm.doc.paid_amount) {
+			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
+				frm.set_value("paid_amount", frm.doc.received_amount);
+				if (frm.doc.target_exchange_rate) {
+					frm.set_value("source_exchange_rate", frm.doc.target_exchange_rate);
+				}
+				frm.set_value("base_paid_amount", frm.doc.base_received_amount);
+			} else if (company_currency == frm.doc.paid_from_account_currency) {
+				frm.set_value("paid_amount", frm.doc.base_received_amount);
+				frm.set_value("base_paid_amount", frm.doc.base_received_amount);
+			}
+		}
+
 		if (frm.doc.payment_type == "Pay")
 			frm.events.allocate_party_amount_against_ref_docs(frm, frm.doc.received_amount, true);
 		else frm.events.set_unallocated_amount(frm);
@@ -1879,8 +1897,6 @@ function prompt_for_missing_account(frm, account) {
 			(values) => resolve(values?.[account]),
 			__("Please Specify Account")
 		);
-
-		dialog.on_hide = () => resolve("");
 	});
 }
 

erpnext/accounts/doctype/payment_entry/payment_entry.json

@@ -224,6 +224,7 @@
    "label": "Accounts"
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "party",
    "fieldname": "party_balance",
    "fieldtype": "Currency",
@@ -253,6 +254,7 @@
    "reqd": 1
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "paid_from",
    "fieldname": "paid_from_account_balance",
    "fieldtype": "Currency",
@@ -286,6 +288,7 @@
    "reqd": 1
   },
   {
+   "allow_on_submit": 1,
    "depends_on": "paid_to",
    "fieldname": "paid_to_account_balance",
    "fieldtype": "Currency",
@@ -806,7 +809,7 @@
    "table_fieldname": "payment_entries"
   }
  ],
- "modified": "2025-01-13 16:03:47.169699",
+ "modified": "2025-01-31 17:27:28.555246",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Entry",

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -7,6 +7,7 @@ from functools import reduce
 
 import frappe
 from frappe import ValidationError, _, qb, scrub, throw
+from frappe.model.meta import get_field_precision
 from frappe.query_builder import Tuple
 from frappe.query_builder.functions import Count
 from frappe.utils import cint, comma_or, flt, getdate, nowdate
@@ -25,6 +26,10 @@ from erpnext.accounts.doctype.invoice_discounting.invoice_discounting import (
 	get_party_account_based_on_invoice_discounting,
 )
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account
+from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
+	validate_docs_for_deferred_accounting,
+	validate_docs_for_voucher_types,
+)
 from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category import (
 	get_party_tax_withholding_details,
 )
@@ -33,7 +38,7 @@ from erpnext.accounts.general_ledger import (
 	make_reverse_gl_entries,
 	process_gl_map,
 )
-from erpnext.accounts.party import get_party_account
+from erpnext.accounts.party import complete_contact_details, get_party_account, set_contact_details
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
 	get_account_currency,
@@ -114,6 +119,23 @@ class PaymentEntry(AccountsController):
 		self.update_advance_paid()  # advance_paid_status depends on the payment request amount
 		self.set_status()
 
+	def validate_for_repost(self):
+		validate_docs_for_voucher_types(["Payment Entry"])
+		validate_docs_for_deferred_accounting([self.name], [])
+
+	def on_update_after_submit(self):
+		# Flag will be set on Reconciliation
+		# Reconciliation tool will anyways repost ledger entries. So, no need to check and do implicit repost.
+		if self.flags.get("ignore_reposting_on_reconciliation"):
+			return
+
+		self.needs_repost = self.check_if_fields_updated(
+			fields_to_check=[], child_tables={"references": [], "taxes": [], "deductions": []}
+		)
+		if self.needs_repost:
+			self.validate_for_repost()
+			self.repost_accounting_entries()
+
 	def set_liability_account(self):
 		# Auto setting liability account should only be done during 'draft' status
 		if self.docstatus > 0 or self.payment_type == "Internal Transfer":
@@ -418,6 +440,12 @@ class PaymentEntry(AccountsController):
 				self.party_name = frappe.db.get_value(self.party_type, self.party, "name")
 
 		if self.party:
+			if not self.contact_person:
+				set_contact_details(
+					self, party=frappe._dict({"name": self.party}), party_type=self.party_type
+				)
+			else:
+				complete_contact_details(self)
 			if not self.party_balance:
 				self.party_balance = get_balance_on(
 					party_type=self.party_type, party=self.party, date=self.posting_date, company=self.company
@@ -543,7 +571,7 @@ class PaymentEntry(AccountsController):
 			if d.reference_doctype not in valid_reference_doctypes:
 				frappe.throw(
 					_("Reference Doctype must be one of {0}").format(
-						comma_or(_(d) for d in valid_reference_doctypes)
+						comma_or([_(d) for d in valid_reference_doctypes])
 					)
 				)
 
@@ -715,16 +743,39 @@ class PaymentEntry(AccountsController):
 			outstanding = flt(invoice_paid_amount_map.get(key, {}).get("outstanding"))
 			discounted_amt = flt(invoice_paid_amount_map.get(key, {}).get("discounted_amt"))
 
+			conversion_rate = frappe.db.get_value(key[2], {"name": key[1]}, "conversion_rate")
+			base_paid_amount_precision = get_field_precision(
+				frappe.get_meta("Payment Schedule").get_field("base_paid_amount")
+			)
+			base_outstanding_precision = get_field_precision(
+				frappe.get_meta("Payment Schedule").get_field("base_outstanding")
+			)
+
+			base_paid_amount = flt(
+				(allocated_amount - discounted_amt) * conversion_rate, base_paid_amount_precision
+			)
+			base_outstanding = flt(allocated_amount * conversion_rate, base_outstanding_precision)
+
 			if cancel:
 				frappe.db.sql(
 					"""
 					UPDATE `tabPayment Schedule`
 					SET
 						paid_amount = `paid_amount` - %s,
+						base_paid_amount = `base_paid_amount` - %s,
 						discounted_amount = `discounted_amount` - %s,
-						outstanding = `outstanding` + %s
+						outstanding = `outstanding` + %s,
+						base_outstanding = `base_outstanding` - %s
 					WHERE parent = %s and payment_term = %s""",
-					(allocated_amount - discounted_amt, discounted_amt, allocated_amount, key[1], key[0]),
+					(
+						allocated_amount - discounted_amt,
+						base_paid_amount,
+						discounted_amt,
+						allocated_amount,
+						base_outstanding,
+						key[1],
+						key[0],
+					),
 				)
 			else:
 				if allocated_amount > outstanding:
@@ -740,10 +791,20 @@ class PaymentEntry(AccountsController):
 						UPDATE `tabPayment Schedule`
 						SET
 							paid_amount = `paid_amount` + %s,
+							base_paid_amount = `base_paid_amount` + %s,
 							discounted_amount = `discounted_amount` + %s,
-							outstanding = `outstanding` - %s
+							outstanding = `outstanding` - %s,
+							base_outstanding = `base_outstanding` - %s
 						WHERE parent = %s and payment_term = %s""",
-						(allocated_amount - discounted_amt, discounted_amt, allocated_amount, key[1], key[0]),
+						(
+							allocated_amount - discounted_amt,
+							base_paid_amount,
+							discounted_amt,
+							allocated_amount,
+							base_outstanding,
+							key[1],
+							key[0],
+						),
 					)
 
 	def get_allocated_amount_in_transaction_currency(
@@ -1196,15 +1257,22 @@ class PaymentEntry(AccountsController):
 
 		self.set("remarks", "\n".join(remarks))
 
+	def set_transaction_currency_and_rate(self):
+		company_currency = erpnext.get_company_currency(self.company)
+		self.transaction_currency = company_currency
+		self.transaction_exchange_rate = 1
+
+		if self.paid_from_account_currency != company_currency:
+			self.transaction_currency = self.paid_from_account_currency
+			self.transaction_exchange_rate = self.source_exchange_rate
+		elif self.paid_to_account_currency != company_currency:
+			self.transaction_currency = self.paid_to_account_currency
+			self.transaction_exchange_rate = self.target_exchange_rate
+
 	def build_gl_map(self):
 		if self.payment_type in ("Receive", "Pay") and not self.get("party_account_field"):
 			self.setup_party_account_field()
-
-		company_currency = erpnext.get_company_currency(self.company)
-		if self.paid_from_account_currency != company_currency:
-			self.currency = self.paid_from_account_currency
-		elif self.paid_to_account_currency != company_currency:
-			self.currency = self.paid_to_account_currency
+		self.set_transaction_currency_and_rate()
 
 		gl_entries = []
 		self.add_party_gl_entries(gl_entries)
@@ -1283,6 +1351,9 @@ class PaymentEntry(AccountsController):
 						"cost_center": cost_center,
 						dr_or_cr + "_in_account_currency": d.allocated_amount,
 						dr_or_cr: allocated_amount_in_company_currency,
+						dr_or_cr + "_in_transaction_currency": d.allocated_amount
+						if self.transaction_currency == self.party_account_currency
+						else allocated_amount_in_company_currency / self.transaction_exchange_rate,
 					},
 					item=self,
 				)
@@ -1327,6 +1398,9 @@ class PaymentEntry(AccountsController):
 						"account_currency": self.party_account_currency,
 						"cost_center": self.cost_center,
 						dr_or_cr + "_in_account_currency": self.unallocated_amount,
+						dr_or_cr + "_in_transaction_currency": self.unallocated_amount
+						if self.party_account_currency == self.transaction_currency
+						else base_unallocated_amount / self.transaction_exchange_rate,
 						dr_or_cr: base_unallocated_amount,
 					},
 					item=self,
@@ -1344,6 +1418,7 @@ class PaymentEntry(AccountsController):
 	def make_advance_gl_entries(
 		self, entry: object | dict = None, cancel: bool = 0, update_outstanding: str = "Yes"
 	):
+		self.set_transaction_currency_and_rate()
 		gl_entries = []
 		self.add_advance_gl_entries(gl_entries, entry)
 
@@ -1423,9 +1498,16 @@ class PaymentEntry(AccountsController):
 			frappe.db.set_value("Payment Entry Reference", invoice.name, "reconcile_effect_on", posting_date)
 
 		dr_or_cr, account = self.get_dr_and_account_for_advances(invoice)
+		base_allocated_amount = self.calculate_base_allocated_amount_for_reference(invoice)
 		args_dict["account"] = account
-		args_dict[dr_or_cr] = self.calculate_base_allocated_amount_for_reference(invoice)
+		args_dict[dr_or_cr] = base_allocated_amount
 		args_dict[dr_or_cr + "_in_account_currency"] = invoice.allocated_amount
+		args_dict[dr_or_cr + "_in_transaction_currency"] = (
+			invoice.allocated_amount
+			if self.party_account_currency == self.transaction_currency
+			else base_allocated_amount / self.transaction_exchange_rate
+		)
+
 		args_dict.update(
 			{
 				"against_voucher_type": invoice.reference_doctype,
@@ -1443,8 +1525,13 @@ class PaymentEntry(AccountsController):
 		args_dict[dr_or_cr + "_in_account_currency"] = 0
 		dr_or_cr = "debit" if dr_or_cr == "credit" else "credit"
 		args_dict["account"] = self.party_account
-		args_dict[dr_or_cr] = self.calculate_base_allocated_amount_for_reference(invoice)
+		args_dict[dr_or_cr] = base_allocated_amount
 		args_dict[dr_or_cr + "_in_account_currency"] = invoice.allocated_amount
+		args_dict[dr_or_cr + "_in_transaction_currency"] = (
+			invoice.allocated_amount
+			if self.party_account_currency == self.transaction_currency
+			else base_allocated_amount / self.transaction_exchange_rate
+		)
 		args_dict.update(
 			{
 				"against_voucher_type": "Payment Entry",
@@ -1466,6 +1553,9 @@ class PaymentEntry(AccountsController):
 						"account_currency": self.paid_from_account_currency,
 						"against": self.party if self.payment_type == "Pay" else self.paid_to,
 						"credit_in_account_currency": self.paid_amount,
+						"credit_in_transaction_currency": self.paid_amount
+						if self.paid_from_account_currency == self.transaction_currency
+						else self.base_paid_amount / self.transaction_exchange_rate,
 						"credit": self.base_paid_amount,
 						"cost_center": self.cost_center,
 						"post_net_value": True,
@@ -1481,6 +1571,9 @@ class PaymentEntry(AccountsController):
 						"account_currency": self.paid_to_account_currency,
 						"against": self.party if self.payment_type == "Receive" else self.paid_from,
 						"debit_in_account_currency": self.received_amount,
+						"debit_in_transaction_currency": self.received_amount
+						if self.paid_to_account_currency == self.transaction_currency
+						else self.base_received_amount / self.transaction_exchange_rate,
 						"debit": self.base_received_amount,
 						"cost_center": self.cost_center,
 					},
@@ -1516,6 +1609,8 @@ class PaymentEntry(AccountsController):
 						dr_or_cr + "_in_account_currency": base_tax_amount
 						if account_currency == self.company_currency
 						else d.tax_amount,
+						dr_or_cr + "_in_transaction_currency": base_tax_amount
+						/ self.transaction_exchange_rate,
 						"cost_center": d.cost_center,
 						"post_net_value": True,
 					},
@@ -1541,6 +1636,8 @@ class PaymentEntry(AccountsController):
 							rev_dr_or_cr + "_in_account_currency": base_tax_amount
 							if account_currency == self.company_currency
 							else d.tax_amount,
+							rev_dr_or_cr + "_in_transaction_currency": base_tax_amount
+							/ self.transaction_exchange_rate,
 							"cost_center": self.cost_center,
 							"post_net_value": True,
 						},
@@ -1563,6 +1660,7 @@ class PaymentEntry(AccountsController):
 							"account_currency": account_currency,
 							"against": self.party or self.paid_from,
 							"debit_in_account_currency": d.amount,
+							"debit_in_transaction_currency": d.amount / self.transaction_exchange_rate,
 							"debit": d.amount,
 							"cost_center": d.cost_center,
 						},
@@ -1576,6 +1674,14 @@ class PaymentEntry(AccountsController):
 		elif self.payment_type in ("Pay", "Internal Transfer"):
 			return self.paid_from
 
+	def get_value_in_transaction_currency(self, account_currency, gl_dict, field):
+		company_currency = erpnext.get_company_currency(self.company)
+		conversion_rate = self.target_exchange_rate
+		if self.paid_from_account_currency != company_currency:
+			conversion_rate = self.source_exchange_rate
+
+		return flt(gl_dict.get(field, 0) / (conversion_rate or 1))
+
 	def update_advance_paid(self):
 		if self.payment_type in ("Receive", "Pay") and self.party:
 			for d in self.get("references"):
@@ -1790,7 +1896,7 @@ class PaymentEntry(AccountsController):
 		paid_amount -= sum(flt(d.amount, precision) for d in self.deductions)
 
 		for ref in self.references:
-			reference_outstanding_amount = ref.outstanding_amount
+			reference_outstanding_amount = flt(ref.outstanding_amount)
 			abs_outstanding_amount = abs(reference_outstanding_amount)
 
 			if reference_outstanding_amount > 0:
@@ -1814,7 +1920,7 @@ class PaymentEntry(AccountsController):
 
 			allocated_positive_outstanding = paid_amount + allocated_negative_outstanding
 
-		elif self.party_type in ("Supplier", "Employee"):
+		elif self.party_type in ("Supplier", "Customer"):
 			if paid_amount > total_negative_outstanding:
 				if total_negative_outstanding == 0:
 					frappe.msgprint(
@@ -2235,10 +2341,17 @@ def get_outstanding_reference_documents(args, validate=False):
 	outstanding_invoices = []
 	negative_outstanding_invoices = []
 
+	party_account = args.get("party_account")
+
+	# get party account if advance account is set.
 	if args.get("book_advance_payments_in_separate_party_account"):
-		party_account = get_party_account(args.get("party_type"), args.get("party"), args.get("company"))
-	else:
-		party_account = args.get("party_account")
+		accounts = get_party_account(
+			args.get("party_type"), args.get("party"), args.get("company"), include_advance=True
+		)
+		advance_account = accounts[1] if len(accounts) >= 1 else None
+
+		if party_account == advance_account:
+			party_account = accounts[0]
 
 	if args.get("get_outstanding_invoices"):
 		outstanding_invoices = get_outstanding_invoices(
@@ -2806,7 +2919,7 @@ def get_payment_entry(
 	pe.party_type = party_type
 	pe.party = doc.get(scrub(party_type))
 	pe.contact_person = doc.get("contact_person")
-	pe.contact_email = doc.get("contact_email")
+	complete_contact_details(pe)
 	pe.ensure_supplier_is_not_blocked()
 
 	pe.paid_from = party_account if payment_type == "Receive" else bank.account
@@ -2818,6 +2931,9 @@ def get_payment_entry(
 	pe.paid_amount = paid_amount
 	pe.received_amount = received_amount
 	pe.letter_head = doc.get("letter_head")
+	pe.bank_account = frappe.db.get_value(
+		"Bank Account", {"is_company_account": 1, "is_default": 1, "company": doc.company}, "name"
+	)
 
 	if dt in ["Purchase Order", "Sales Order", "Sales Invoice", "Purchase Invoice"]:
 		pe.project = doc.get("project") or reduce(
@@ -2826,7 +2942,7 @@ def get_payment_entry(
 
 	if pe.party_type in ["Customer", "Supplier"]:
 		bank_account = get_party_bank_account(pe.party_type, pe.party)
-		pe.set("bank_account", bank_account)
+		pe.set("party_bank_account", bank_account)
 		pe.set_bank_account_data()
 
 	# only Purchase Invoice can be blocked individually
@@ -3300,13 +3416,14 @@ def add_income_discount_loss(pe, doc, total_discount_percent) -> float:
 	"""Add loss on income discount in base currency."""
 	precision = doc.precision("total")
 	base_loss_on_income = doc.get("base_total") * (total_discount_percent / 100)
+	positive_negative = -1 if pe.payment_type == "Pay" else 1
 
 	pe.append(
 		"deductions",
 		{
 			"account": frappe.get_cached_value("Company", pe.company, "default_discount_account"),
 			"cost_center": pe.cost_center or frappe.get_cached_value("Company", pe.company, "cost_center"),
-			"amount": flt(base_loss_on_income, precision),
+			"amount": flt(base_loss_on_income, precision) * positive_negative,
 		},
 	)
 
@@ -3318,6 +3435,7 @@ def add_tax_discount_loss(pe, doc, total_discount_percentage) -> float:
 	tax_discount_loss = {}
 	base_total_tax_loss = 0
 	precision = doc.precision("tax_amount_after_discount_amount", "taxes")
+	positive_negative = -1 if pe.payment_type == "Pay" else 1
 
 	# The same account head could be used more than once
 	for tax in doc.get("taxes", []):
@@ -3340,7 +3458,7 @@ def add_tax_discount_loss(pe, doc, total_discount_percentage) -> float:
 				"account": account,
 				"cost_center": pe.cost_center
 				or frappe.get_cached_value("Company", pe.company, "cost_center"),
-				"amount": flt(loss, precision),
+				"amount": flt(loss, precision) * positive_negative,
 			},
 		)
 

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -282,6 +282,48 @@ class TestPaymentEntry(FrappeTestCase):
 		self.assertEqual(si.payment_schedule[0].paid_amount, 200.0)
 		self.assertEqual(si.payment_schedule[1].paid_amount, 36.0)
 
+	def test_payment_entry_against_payment_terms_with_discount_on_pi(self):
+		pi = make_purchase_invoice(do_not_save=1)
+		create_payment_terms_template_with_discount()
+		pi.payment_terms_template = "Test Discount Template"
+
+		frappe.db.set_value("Company", pi.company, "default_discount_account", "Write Off - _TC")
+
+		pi.append(
+			"taxes",
+			{
+				"charge_type": "On Net Total",
+				"account_head": "_Test Account Service Tax - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"description": "Service Tax",
+				"rate": 18,
+			},
+		)
+		pi.save()
+		pi.submit()
+
+		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 1)
+		pe_with_tax_loss = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Cash - _TC")
+
+		self.assertEqual(pe_with_tax_loss.references[0].payment_term, "30 Credit Days with 10% Discount")
+		self.assertEqual(pe_with_tax_loss.payment_type, "Pay")
+		self.assertEqual(pe_with_tax_loss.references[0].allocated_amount, 295.0)
+		self.assertEqual(pe_with_tax_loss.paid_amount, 265.5)
+		self.assertEqual(pe_with_tax_loss.difference_amount, 0)
+		self.assertEqual(pe_with_tax_loss.deductions[0].amount, -25.0)  # Loss on Income
+		self.assertEqual(pe_with_tax_loss.deductions[1].amount, -4.5)  # Loss on Tax
+		self.assertEqual(pe_with_tax_loss.deductions[1].account, "_Test Account Service Tax - _TC")
+
+		frappe.db.set_single_value("Accounts Settings", "book_tax_discount_loss", 0)
+		pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Cash - _TC")
+
+		self.assertEqual(pe.references[0].payment_term, "30 Credit Days with 10% Discount")
+		self.assertEqual(pe.payment_type, "Pay")
+		self.assertEqual(pe.references[0].allocated_amount, 295.0)
+		self.assertEqual(pe.paid_amount, 265.5)
+		self.assertEqual(pe.deductions[0].amount, -29.5)
+		self.assertEqual(pe.difference_amount, 0)
+
 	def test_payment_entry_against_payment_terms_with_discount(self):
 		si = create_sales_invoice(do_not_save=1, qty=1, rate=200)
 		create_payment_terms_template_with_discount()

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -335,6 +335,7 @@ class PaymentReconciliation(Document):
 		for payment in non_reconciled_payments:
 			row = self.append("payments", {})
 			row.update(payment)
+			row.is_advance = payment.book_advance_payments_in_separate_party_account
 
 	def get_invoice_entries(self):
 		# Fetch JVs, Sales and Purchase Invoices for 'invoices' to reconcile against
@@ -424,6 +425,9 @@ class PaymentReconciliation(Document):
 	def allocate_entries(self, args):
 		self.validate_entries()
 
+		exc_gain_loss_posting_date = frappe.db.get_single_value(
+			"Accounts Settings", "exchange_gain_loss_posting_date", cache=True
+		)
 		invoice_exchange_map = self.get_invoice_exchange_map(args.get("invoices"), args.get("payments"))
 		default_exchange_gain_loss_account = frappe.get_cached_value(
 			"Company", self.company, "exchange_gain_loss_account"
@@ -450,6 +454,11 @@ class PaymentReconciliation(Document):
 				res.difference_account = default_exchange_gain_loss_account
 				res.exchange_rate = inv.get("exchange_rate")
 				res.update({"gain_loss_posting_date": pay.get("posting_date")})
+				if not pay.get("is_advance"):
+					if exc_gain_loss_posting_date == "Invoice":
+						res.update({"gain_loss_posting_date": inv.get("invoice_date")})
+					elif exc_gain_loss_posting_date == "Reconciliation Date":
+						res.update({"gain_loss_posting_date": nowdate()})
 
 				if pay.get("amount") == 0:
 					entries.append(res)

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -313,6 +313,7 @@ class PaymentRequest(Document):
 				"payer_name": data.customer_name,
 				"order_id": self.name,
 				"currency": self.currency,
+				"payment_gateway": self.payment_gateway,
 			}
 		)
 
@@ -767,26 +768,39 @@ def get_existing_payment_request_amount(ref_dt, ref_dn, statuses: list | None =
 
 
 def get_existing_paid_amount(doctype, name):
-	PL = frappe.qb.DocType("Payment Ledger Entry")
+	PLE = frappe.qb.DocType("Payment Ledger Entry")
 	PER = frappe.qb.DocType("Payment Entry Reference")
 
 	query = (
-		frappe.qb.from_(PL)
+		frappe.qb.from_(PLE)
 		.left_join(PER)
 		.on(
-			(PER.reference_doctype == PL.against_voucher_type) & (PER.reference_name == PL.against_voucher_no)
+			(PLE.against_voucher_type == PER.reference_doctype)
+			& (PLE.against_voucher_no == PER.reference_name)
+			& (PLE.voucher_type == PER.parenttype)
+			& (PLE.voucher_no == PER.parent)
+		)
+		.select(
+			Abs(Sum(PLE.amount)).as_("total_amount"),
+			Abs(Sum(frappe.qb.terms.Case().when(PER.payment_request.isnotnull(), PLE.amount).else_(0))).as_(
+				"request_paid_amount"
+			),
+		)
+		.where(
+			(PLE.voucher_type.isin([doctype, "Journal Entry", "Payment Entry"]))
+			& (PLE.against_voucher_type == doctype)
+			& (PLE.against_voucher_no == name)
+			& (PLE.delinked == 0)
+			& (PLE.docstatus == 1)
+			& (PLE.amount < 0)
 		)
-		.select(Abs(Sum(PL.amount)).as_("total_paid_amount"))
-		.where(PL.against_voucher_type.eq(doctype))
-		.where(PL.against_voucher_no.eq(name))
-		.where(PL.amount < 0)
-		.where(PL.delinked == 0)
-		.where(PER.docstatus == 1)
-		.where(PER.payment_request.isnull())
 	)
-	response = query.run()
 
-	return response[0][0] if response[0] else 0
+	result = query.run()
+	ledger_amount = flt(result[0][0]) if result else 0
+	request_paid_amount = flt(result[0][1]) if result else 0
+
+	return ledger_amount - request_paid_amount
 
 
 def get_gateway_details(args):  # nosemgrep

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -83,8 +83,7 @@ class TestPaymentRequest(FrappeTestCase):
 
 	def test_payment_entry_against_purchase_invoice(self):
 		si_usd = make_purchase_invoice(
-			customer="_Test Supplier USD",
-			debit_to="_Test Payable USD - _TC",
+			supplier="_Test Supplier USD",
 			currency="USD",
 			conversion_rate=50,
 		)
@@ -108,8 +107,7 @@ class TestPaymentRequest(FrappeTestCase):
 
 	def test_multiple_payment_entry_against_purchase_invoice(self):
 		purchase_invoice = make_purchase_invoice(
-			customer="_Test Supplier USD",
-			debit_to="_Test Payable USD - _TC",
+			supplier="_Test Supplier USD",
 			currency="USD",
 			conversion_rate=50,
 		)
@@ -544,6 +542,73 @@ class TestPaymentRequest(FrappeTestCase):
 
 		self.assertEqual(pr.grand_total, si.outstanding_amount)
 
+	def test_partial_paid_invoice_with_more_payment_entry(self):
+		pi = make_purchase_invoice(currency="INR", qty=1, rate=500)
+		pi.submit()
+		pi_1 = make_purchase_invoice(currency="INR", qty=1, rate=300)
+		pi_1.submit()
+
+		pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1, submit_doc=0, return_doc=1)
+		pr.grand_total = 200
+		pr.submit()
+		pr.create_payment_entry()
+		pr_1 = make_payment_request(
+			dt="Purchase Invoice", dn=pi.name, mute_email=1, submit_doc=0, return_doc=1
+		)
+		pr_1.grand_total = 200
+		pr_1.submit()
+		pr_1.create_payment_entry()
+
+		pe = get_payment_entry(dt="Purchase Invoice", dn=pi.name)
+		pe.paid_amount = 200
+		pe.references[0].reference_doctype = pi.doctype
+		pe.references[0].reference_name = pi.name
+		pe.references[0].grand_total = pi.grand_total
+		pe.references[0].outstanding_amount = pi.outstanding_amount
+		pe.references[0].allocated_amount = 100
+		pe.append(
+			"references",
+			{
+				"reference_doctype": pi_1.doctype,
+				"reference_name": pi_1.name,
+				"grand_total": pi_1.grand_total,
+				"outstanding_amount": pi_1.outstanding_amount,
+				"allocated_amount": 100,
+			},
+		)
+
+		pr_2 = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1)
+		pi.load_from_db()
+		self.assertEqual(pr_2.grand_total, pi.outstanding_amount)
+
+	def test_consider_journal_entry_and_return_invoice(self):
+		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
+
+		si = create_sales_invoice(currency="INR", qty=5, rate=500)
+
+		je = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 500, save=False)
+		je.accounts[1].party_type = "Customer"
+		je.accounts[1].party = si.customer
+		je.accounts[1].reference_type = "Sales Invoice"
+		je.accounts[1].reference_name = si.name
+		je.accounts[1].credit_in_account_currency = 500
+		je.submit()
+
+		pe = get_payment_entry("Sales Invoice", si.name)
+		pe.paid_amount = 500
+		pe.references[0].allocated_amount = 500
+		pe.save()
+		pe.submit()
+
+		cr_note = create_sales_invoice(qty=-1, rate=500, is_return=1, return_against=si.name, do_not_save=1)
+		cr_note.update_outstanding_for_self = 0
+		cr_note.save()
+		cr_note.submit()
+
+		si.load_from_db()
+		pr = make_payment_request(dt="Sales Invoice", dn=si.name, mute_email=1)
+		self.assertEqual(pr.grand_total, si.outstanding_amount)
+
 
 def test_partial_paid_invoice_with_submitted_payment_entry(self):
 	pi = make_purchase_invoice(currency="INR", qty=1, rate=5000)

erpnext/accounts/doctype/payment_schedule/payment_schedule.json

@@ -24,7 +24,9 @@
   "paid_amount",
   "discounted_amount",
   "column_break_3",
-  "base_payment_amount"
+  "base_payment_amount",
+  "base_outstanding",
+  "base_paid_amount"
  ],
  "fields": [
   {
@@ -155,19 +157,35 @@
    "fieldtype": "Currency",
    "label": "Payment Amount (Company Currency)",
    "options": "Company:company:default_currency"
+  },
+  {
+   "fieldname": "base_outstanding",
+   "fieldtype": "Currency",
+   "label": "Outstanding (Company Currency)",
+   "options": "Company:company:default_currency",
+   "read_only": 1
+  },
+  {
+   "depends_on": "base_paid_amount",
+   "fieldname": "base_paid_amount",
+   "fieldtype": "Currency",
+   "label": "Paid Amount (Company Currency)",
+   "options": "Company:company:default_currency",
+   "read_only": 1
   }
  ],
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2022-09-16 13:57:06.382859",
+ "modified": "2025-03-11 11:06:51.792982",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Schedule",
  "owner": "Administrator",
  "permissions": [],
  "quick_entry": 1,
- "sort_field": "modified",
+ "row_format": "Dynamic",
+ "sort_field": "creation",
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1

erpnext/accounts/doctype/payment_schedule/payment_schedule.py

@@ -14,6 +14,8 @@ class PaymentSchedule(Document):
 	if TYPE_CHECKING:
 		from frappe.types import DF
 
+		base_outstanding: DF.Currency
+		base_paid_amount: DF.Currency
 		base_payment_amount: DF.Currency
 		description: DF.SmallText | None
 		discount: DF.Float

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -139,7 +139,7 @@ class PeriodClosingVoucher(AccountsController):
 		self.cancel_gl_entries()
 
 	def make_gl_entries(self):
-		if self.get_gle_count_in_selected_period() > 5000:
+		if frappe.db.estimate_count("GL Entry") > 100_000:
 			frappe.enqueue(
 				process_gl_and_closing_entries,
 				doc=self,
@@ -154,16 +154,6 @@ class PeriodClosingVoucher(AccountsController):
 		else:
 			process_gl_and_closing_entries(self)
 
-	def get_gle_count_in_selected_period(self):
-		return frappe.db.count(
-			"GL Entry",
-			{
-				"posting_date": ["between", [self.period_start_date, self.period_end_date]],
-				"company": self.company,
-				"is_cancelled": 0,
-			},
-		)
-
 	def get_pcv_gl_entries(self):
 		self.pl_accounts_reverse_gle = []
 		self.closing_account_gle = []

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -27,6 +27,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
+			company=company,
 			save=False,
 		)
 		jv1.company = company
@@ -39,6 +40,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cost of Goods Sold - TPC",
 			account2="Cash - TPC",
 			cost_center=cost_center,
+			company=company,
 			save=False,
 		)
 		jv2.company = company
@@ -156,6 +158,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			amount=400,
 			cost_center=cost_center,
 			posting_date="2021-03-15",
+			company=company,
 		)
 		jv.company = company
 		jv.finance_book = create_finance_book().name
@@ -198,6 +201,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
+			company=company,
 			save=False,
 		)
 		jv1.company = company
@@ -220,6 +224,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center1,
+			company=company,
 			save=False,
 		)
 		jv1.company = company
@@ -232,6 +237,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
+			company=company,
 			save=False,
 		)
 		jv2.company = company
@@ -261,6 +267,7 @@ class TestPeriodClosingVoucher(unittest.TestCase):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
+			company=company,
 			save=False,
 		)
 

erpnext/accounts/doctype/pos_closing_entry/test_pos_closing_entry.py

@@ -39,10 +39,12 @@ class TestPOSClosingEntry(unittest.TestCase):
 
 		pos_inv1 = create_pos_invoice(rate=3500, do_not_submit=1)
 		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv1.save()
 		pos_inv1.submit()
 
 		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
@@ -68,6 +70,7 @@ class TestPOSClosingEntry(unittest.TestCase):
 
 		pos_inv = create_pos_invoice(rate=3500, do_not_submit=1, item_name="Test Item", without_item_code=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv.save()
 		pos_inv.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
@@ -86,10 +89,12 @@ class TestPOSClosingEntry(unittest.TestCase):
 
 		pos_inv1 = create_pos_invoice(rate=3500, do_not_submit=1)
 		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv1.save()
 		pos_inv1.submit()
 
 		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		# make return entry of pos_inv2
@@ -111,10 +116,12 @@ class TestPOSClosingEntry(unittest.TestCase):
 
 		pos_inv1 = create_pos_invoice(rate=3500, do_not_submit=1)
 		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv1.save()
 		pos_inv1.submit()
 
 		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		pcv_doc = make_closing_entry_from_opening(opening_entry)
@@ -165,6 +172,7 @@ class TestPOSClosingEntry(unittest.TestCase):
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
 		pos_inv1 = create_pos_invoice(rate=350, do_not_submit=1, pos_profile=pos_profile.name)
 		pos_inv1.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3500})
+		pos_inv1.save()
 		pos_inv1.submit()
 
 		# if in between a mandatory accounting dimension is added to the POS Profile then
@@ -218,14 +226,27 @@ class TestPOSClosingEntry(unittest.TestCase):
 		opening_entry = create_opening_entry(pos_profile, test_user.name)
 
 		pos_inv = create_pos_invoice(
-			item_code=item_code, qty=5, rate=300, use_serial_batch_fields=1, batch_no=batch_no
+			item_code=item_code,
+			qty=5,
+			rate=300,
+			use_serial_batch_fields=1,
+			batch_no=batch_no,
+			do_not_submit=True,
 		)
+		pos_inv.payments[0].amount = pos_inv.grand_total
+		pos_inv.save()
+		pos_inv.submit()
 		pos_inv2 = create_pos_invoice(
-			item_code=item_code, qty=5, rate=300, use_serial_batch_fields=1, batch_no=batch_no
+			item_code=item_code,
+			qty=5,
+			rate=300,
+			use_serial_batch_fields=1,
+			batch_no=batch_no,
+			do_not_submit=True,
 		)
-
-		batch_qty = frappe.db.get_value("Batch", batch_no, "batch_qty")
-		self.assertEqual(batch_qty, 10)
+		pos_inv2.payments[0].amount = pos_inv2.grand_total
+		pos_inv2.save()
+		pos_inv2.submit()
 
 		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
 		self.assertEqual(batch_qty_with_pos, 0.0)
@@ -256,9 +277,6 @@ class TestPOSClosingEntry(unittest.TestCase):
 		pcv_doc.reload()
 		pcv_doc.cancel()
 
-		batch_qty = frappe.db.get_value("Batch", batch_no, "batch_qty")
-		self.assertEqual(batch_qty, 10)
-
 		batch_qty_with_pos = get_batch_qty(batch_no, "_Test Warehouse - _TC", item_code)
 		self.assertEqual(batch_qty_with_pos, 0.0)
 

erpnext/accounts/doctype/pos_invoice/pos_invoice.json

@@ -1623,6 +1623,5 @@
  "states": [],
  "timeline_field": "customer",
  "title_field": "title",
- "track_changes": 1,
- "track_seen": 1
-}
+ "track_changes": 1
+}

erpnext/accounts/doctype/pos_invoice/pos_invoice.py

@@ -20,6 +20,10 @@ from erpnext.controllers.queries import item_query as _item_query
 from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
 
 
+class PartialPaymentValidationError(frappe.ValidationError):
+	pass
+
+
 class POSInvoice(SalesInvoice):
 	# begin: auto-generated types
 	# This code is auto-generated. Do not modify anything in this block.
@@ -210,6 +214,7 @@ class POSInvoice(SalesInvoice):
 		self.validate_payment_amount()
 		self.validate_loyalty_transaction()
 		self.validate_company_with_pos_company()
+		self.validate_full_payment()
 		if self.coupon_code:
 			from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
 
@@ -477,6 +482,20 @@ class POSInvoice(SalesInvoice):
 		if self.redeem_loyalty_points and self.loyalty_program and self.loyalty_points:
 			validate_loyalty_points(self, self.loyalty_points)
 
+	def validate_full_payment(self):
+		invoice_total = flt(self.rounded_total) or flt(self.grand_total)
+
+		if self.docstatus == 1:
+			if self.is_return and self.paid_amount != invoice_total:
+				frappe.throw(
+					msg=_("Partial Payment in POS Invoice is not allowed."), exc=PartialPaymentValidationError
+				)
+
+			if self.paid_amount < invoice_total:
+				frappe.throw(
+					msg=_("Partial Payment in POS Invoice is not allowed."), exc=PartialPaymentValidationError
+				)
+
 	def set_status(self, update=False, status=None, update_modified=True):
 		if self.is_new():
 			if self.get("amended_from"):

erpnext/accounts/doctype/pos_invoice/test_pos_invoice.py

@@ -7,7 +7,7 @@ import unittest
 import frappe
 from frappe import _
 
-from erpnext.accounts.doctype.pos_invoice.pos_invoice import make_sales_return
+from erpnext.accounts.doctype.pos_invoice.pos_invoice import PartialPaymentValidationError, make_sales_return
 from erpnext.accounts.doctype.pos_profile.test_pos_profile import make_pos_profile
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.stock.doctype.item.test_item import make_item
@@ -313,7 +313,7 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 
 		pos.append(
-			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000, "default": 1}
+			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2000, "default": 1}
 		)
 
 		pos.insert()
@@ -324,6 +324,11 @@ class TestPOSInvoice(unittest.TestCase):
 
 		# partial return 1
 		pos_return1.get("items")[0].qty = -1
+		pos_return1.set("payments", [])
+		pos_return1.append(
+			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -1000, "default": 1}
+		)
+		pos_return1.paid_amount = -1000
 		pos_return1.submit()
 		pos_return1.reload()
 
@@ -338,6 +343,11 @@ class TestPOSInvoice(unittest.TestCase):
 
 		# partial return 2
 		pos_return2 = make_sales_return(pos.name)
+		pos_return2.set("payments", [])
+		pos_return2.append(
+			"payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": -1000, "default": 1}
+		)
+		pos_return2.paid_amount = -1000
 		pos_return2.submit()
 
 		self.assertEqual(pos_return2.get("items")[0].qty, -1)
@@ -373,6 +383,15 @@ class TestPOSInvoice(unittest.TestCase):
 		inv.payments = []
 		self.assertRaises(frappe.ValidationError, inv.insert)
 
+	def test_partial_payment(self):
+		pos_inv = create_pos_invoice(rate=10000, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 9000},
+		)
+		pos_inv.insert()
+		self.assertRaises(PartialPaymentValidationError, pos_inv.submit)
+
 	def test_serialized_item_transaction(self):
 		from erpnext.stock.doctype.stock_entry.test_stock_entry import make_serialized_item
 
@@ -581,7 +600,13 @@ class TestPOSInvoice(unittest.TestCase):
 			"Test Loyalty Customer", company="_Test Company", loyalty_program="Test Single Loyalty"
 		)
 
-		inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000)
+		inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000, do_not_save=1)
+		inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 10000},
+		)
+		inv.insert()
+		inv.submit()
 
 		lpe = frappe.get_doc(
 			"Loyalty Point Entry",
@@ -607,7 +632,13 @@ class TestPOSInvoice(unittest.TestCase):
 		)
 
 		# add 10 loyalty points
-		create_pos_invoice(customer="Test Loyalty Customer", rate=10000)
+		pos_inv = create_pos_invoice(customer="Test Loyalty Customer", rate=10000, do_not_save=1)
+		pos_inv.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 10000},
+		)
+		pos_inv.paid_amount = 10000
+		pos_inv.submit()
 
 		before_lp_details = get_loyalty_program_details_with_points(
 			"Test Loyalty Customer", company="_Test Company", loyalty_program="Test Single Loyalty"
@@ -641,10 +672,12 @@ class TestPOSInvoice(unittest.TestCase):
 		test_user, pos_profile = init_user_and_profile()
 		pos_inv = create_pos_invoice(rate=300, additional_discount_percentage=10, do_not_submit=1)
 		pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 270})
+		pos_inv.save()
 		pos_inv.submit()
 
 		pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 		pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		consolidate_pos_invoices()
@@ -676,6 +709,7 @@ class TestPOSInvoice(unittest.TestCase):
 				"included_in_print_rate": 1,
 			},
 		)
+		pos_inv.save()
 		pos_inv.submit()
 
 		pos_inv2 = create_pos_invoice(rate=300, qty=2, do_not_submit=1)
@@ -692,6 +726,7 @@ class TestPOSInvoice(unittest.TestCase):
 				"included_in_print_rate": 1,
 			},
 		)
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		consolidate_pos_invoices()
@@ -744,6 +779,7 @@ class TestPOSInvoice(unittest.TestCase):
 				"included_in_print_rate": 1,
 			},
 		)
+		pos_inv2.save()
 		pos_inv2.submit()
 
 		consolidate_pos_invoices()
@@ -774,7 +810,10 @@ class TestPOSInvoice(unittest.TestCase):
 
 		# POS Invoice 1, for the batch without bundle
 		pos_inv1 = create_pos_invoice(item="_BATCH ITEM Test For Reserve", rate=300, qty=15, do_not_save=1)
-
+		pos_inv1.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 4500},
+		)
 		pos_inv1.items[0].batch_no = batch_no
 		pos_inv1.save()
 		pos_inv1.submit()
@@ -790,8 +829,14 @@ class TestPOSInvoice(unittest.TestCase):
 
 		# POS Invoice 2, for the batch with bundle
 		pos_inv2 = create_pos_invoice(
-			item="_BATCH ITEM Test For Reserve", rate=300, qty=10, batch_no=batch_no
+			item="_BATCH ITEM Test For Reserve", rate=300, qty=10, batch_no=batch_no, do_not_save=1
 		)
+		pos_inv2.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3000},
+		)
+		pos_inv2.save()
+		pos_inv2.submit()
 		pos_inv2.reload()
 		self.assertTrue(pos_inv2.items[0].serial_and_batch_bundle)
 
@@ -826,6 +871,10 @@ class TestPOSInvoice(unittest.TestCase):
 		pos_inv1 = create_pos_invoice(
 			item=item.name, rate=300, qty=1, do_not_submit=1, batch_no="TestBatch 01"
 		)
+		pos_inv1.append(
+			"payments",
+			{"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300},
+		)
 		pos_inv1.save()
 		pos_inv1.submit()
 

erpnext/accounts/doctype/pos_invoice_merge_log/pos_invoice_merge_log.py

@@ -8,11 +8,14 @@ import frappe
 from frappe import _
 from frappe.model.document import Document
 from frappe.model.mapper import map_child_doc, map_doc
+from frappe.query_builder import DocType
 from frappe.utils import cint, flt, get_time, getdate, nowdate, nowtime
 from frappe.utils.background_jobs import enqueue, is_job_enqueued
 from frappe.utils.scheduler import is_scheduler_inactive
 
-from erpnext.accounts.doctype.pos_profile.pos_profile import required_accounting_dimensions
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_checks_for_pl_and_bs_accounts,
+)
 
 
 class POSInvoiceMergeLog(Document):
@@ -116,17 +119,18 @@ class POSInvoiceMergeLog(Document):
 		returns = [d for d in pos_invoice_docs if d.get("is_return") == 1]
 		sales = [d for d in pos_invoice_docs if d.get("is_return") == 0]
 
-		sales_invoice, credit_note = "", ""
+		sales_invoice, credit_notes = "", {}
 		sales_invoice_doc = None
 		if sales:
 			sales_invoice_doc = self.process_merging_into_sales_invoice(sales)
 			sales_invoice = sales_invoice_doc.name
 
 		if returns:
-			credit_note = self.process_merging_into_credit_note(returns, sales_invoice_doc)
+			distinguished_returns = self.distinguish_return_pos_invoices(returns, sales_invoice_doc)
+			credit_notes = self.process_merging_into_credit_notes(distinguished_returns)
 
 		self.save()  # save consolidated_sales_invoice & consolidated_credit_note ref in merge log
-		self.update_pos_invoices(pos_invoice_docs, sales_invoice, credit_note)
+		self.update_pos_invoices(pos_invoice_docs, sales_invoice, credit_notes)
 
 	def on_cancel(self):
 		pos_invoice_docs = [frappe.get_cached_doc("POS Invoice", d.pos_invoice) for d in self.pos_invoices]
@@ -156,34 +160,50 @@ class POSInvoiceMergeLog(Document):
 
 		return sales_invoice
 
-	def process_merging_into_credit_note(self, data, sales_invoice_doc=None):
-		credit_note = self.get_new_sales_invoice()
-		credit_note.is_return = 1
+	def process_merging_into_credit_notes(self, data):
+		credit_notes = {}
+		for key, value in data.items():
+			if not value:
+				continue
 
-		credit_note = self.merge_pos_invoice_into(credit_note, data)
-		referenes = {}
+			credit_note = self.get_new_sales_invoice()
+			credit_note.is_return = 1
 
-		if sales_invoice_doc:
-			credit_note.return_against = sales_invoice_doc.name
+			credit_note = self.merge_pos_invoice_into(credit_note, value)
+			credit_note.return_against = key
 
-			for d in sales_invoice_doc.items:
-				referenes[d.item_code] = d.name
+			credit_note.is_consolidated = 1
+			credit_note.set_posting_time = 1
+			credit_note.posting_date = getdate(self.posting_date)
+			credit_note.posting_time = get_time(self.posting_time)
+			# TODO: return could be against multiple sales invoice which could also have been consolidated?
+			# credit_note.return_against = self.consolidated_invoice
+			credit_note.save()
+			credit_note.submit()
 
-			for d in credit_note.items:
-				d.sales_invoice_item = referenes.get(d.item_code)
+			self.consolidated_credit_note = credit_note.name
+			credit_notes[credit_note.name] = [d.name for d in value]
 
-		credit_note.is_consolidated = 1
-		credit_note.set_posting_time = 1
-		credit_note.posting_date = getdate(self.posting_date)
-		credit_note.posting_time = get_time(self.posting_time)
-		# TODO: return could be against multiple sales invoice which could also have been consolidated?
-		# credit_note.return_against = self.consolidated_invoice
-		credit_note.save()
-		credit_note.submit()
+		return credit_notes
 
-		self.consolidated_credit_note = credit_note.name
+	def distinguish_return_pos_invoices(self, data, sales_invoice_doc=None):
+		return_invoices = {}
 
-		return credit_note.name
+		return_invoices[sales_invoice_doc.name if sales_invoice_doc else None] = []
+
+		for doc in data:
+			sales_invoices_of_return_against = frappe.db.get_value(
+				"POS Invoice", doc.return_against, "consolidated_invoice"
+			)
+			if sales_invoices_of_return_against:
+				if sales_invoices_of_return_against in return_invoices:
+					return_invoices[sales_invoices_of_return_against].append(doc)
+				else:
+					return_invoices[sales_invoices_of_return_against] = [doc]
+			else:
+				return_invoices[sales_invoice_doc.name if sales_invoice_doc else None].append(doc)
+
+		return return_invoices
 
 	def merge_pos_invoice_into(self, invoice, data):
 		items, payments, taxes = [], [], []
@@ -209,33 +229,20 @@ class POSInvoiceMergeLog(Document):
 				loyalty_amount_sum += doc.loyalty_amount
 
 			for item in doc.get("items"):
-				found = False
-				for i in items:
-					if (
-						i.item_code == item.item_code
-						and not i.serial_and_batch_bundle
-						and not i.serial_no
-						and not i.batch_no
-						and i.uom == item.uom
-						and i.net_rate == item.net_rate
-						and i.warehouse == item.warehouse
-					):
-						found = True
-						i.qty = i.qty + item.qty
-						i.amount = i.amount + item.net_amount
-						i.net_amount = i.amount
-						i.base_amount = i.base_amount + item.base_net_amount
-						i.base_net_amount = i.base_amount
-
-				if not found:
-					item.rate = item.net_rate
-					item.amount = item.net_amount
-					item.base_amount = item.base_net_amount
-					item.price_list_rate = 0
-					si_item = map_child_doc(item, invoice, {"doctype": "Sales Invoice Item"})
-					if item.serial_and_batch_bundle:
-						si_item.serial_and_batch_bundle = item.serial_and_batch_bundle
-					items.append(si_item)
+				item.rate = item.net_rate
+				item.amount = item.net_amount
+				item.base_amount = item.base_net_amount
+				item.price_list_rate = 0
+				si_item = map_child_doc(item, invoice, {"doctype": "Sales Invoice Item"})
+				si_item.pos_invoice = doc.name
+				si_item.pos_invoice_item = item.name
+				if doc.is_return:
+					si_item.sales_invoice_item = get_sales_invoice_item(
+						doc.return_against, item.pos_invoice_item
+					)
+				if item.serial_and_batch_bundle:
+					si_item.serial_and_batch_bundle = item.serial_and_batch_bundle
+				items.append(si_item)
 
 			for tax in doc.get("taxes"):
 				found = False
@@ -292,22 +299,23 @@ class POSInvoiceMergeLog(Document):
 		invoice.disable_rounded_total = cint(
 			frappe.db.get_value("POS Profile", invoice.pos_profile, "disable_rounded_total")
 		)
-		accounting_dimensions = required_accounting_dimensions()
+		accounting_dimensions = get_checks_for_pl_and_bs_accounts()
+		accounting_dimensions_fields = [d.fieldname for d in accounting_dimensions]
 		dimension_values = frappe.db.get_value(
-			"POS Profile", {"name": invoice.pos_profile}, accounting_dimensions, as_dict=1
+			"POS Profile", {"name": invoice.pos_profile}, accounting_dimensions_fields, as_dict=1
 		)
 		for dimension in accounting_dimensions:
-			dimension_value = dimension_values.get(dimension)
+			dimension_value = dimension_values.get(dimension.fieldname)
 
-			if not dimension_value:
+			if not dimension_value and (dimension.mandatory_for_pl or dimension.mandatory_for_bs):
 				frappe.throw(
 					_("Please set Accounting Dimension {} in {}").format(
-						frappe.bold(frappe.unscrub(dimension)),
+						frappe.bold(dimension.label),
 						frappe.get_desk_link("POS Profile", invoice.pos_profile),
 					)
 				)
 
-			invoice.set(dimension, dimension_value)
+			invoice.set(dimension.fieldname, dimension_value)
 
 		if self.merge_invoices_based_on == "Customer Group":
 			invoice.flags.ignore_pos_profile = True
@@ -324,16 +332,16 @@ class POSInvoiceMergeLog(Document):
 
 		return sales_invoice
 
-	def update_pos_invoices(self, invoice_docs, sales_invoice="", credit_note=""):
+	def update_pos_invoices(self, invoice_docs, sales_invoice="", credit_notes=None):
 		for doc in invoice_docs:
 			doc.load_from_db()
-			doc.update(
-				{
-					"consolidated_invoice": None
-					if self.docstatus == 2
-					else (credit_note if doc.is_return else sales_invoice)
-				}
-			)
+			inv = sales_invoice
+			if doc.is_return:
+				for key, value in credit_notes.items():
+					if doc.name in value:
+						inv = key
+						break
+			doc.update({"consolidated_invoice": None if self.docstatus == 2 else inv})
 			doc.set_status(update=True)
 			doc.save()
 
@@ -625,3 +633,26 @@ def get_error_message(message) -> str:
 		return message["message"]
 	except Exception:
 		return str(message)
+
+
+def get_sales_invoice_item(return_against_pos_invoice, pos_invoice_item):
+	try:
+		SalesInvoice = DocType("Sales Invoice")
+		SalesInvoiceItem = DocType("Sales Invoice Item")
+
+		query = (
+			frappe.qb.from_(SalesInvoice)
+			.from_(SalesInvoiceItem)
+			.select(SalesInvoiceItem.name)
+			.where(
+				(SalesInvoice.name == SalesInvoiceItem.parent)
+				& (SalesInvoice.is_return == 0)
+				& (SalesInvoiceItem.pos_invoice == return_against_pos_invoice)
+				& (SalesInvoiceItem.pos_invoice_item == pos_invoice_item)
+			)
+		)
+
+		result = query.run(as_dict=True)
+		return result[0].name if result else None
+	except Exception:
+		return None

erpnext/accounts/doctype/pos_invoice_merge_log/test_pos_invoice_merge_log.py

@@ -28,14 +28,17 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 
 			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+			pos_inv.save()
 			pos_inv.submit()
 
 			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+			pos_inv2.save()
 			pos_inv2.submit()
 
 			pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
 			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+			pos_inv3.save()
 			pos_inv3.submit()
 
 			consolidate_pos_invoices()
@@ -61,14 +64,17 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 
 			pos_inv = create_pos_invoice(rate=300, do_not_submit=1)
 			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 300})
+			pos_inv.save()
 			pos_inv.submit()
 
 			pos_inv2 = create_pos_invoice(rate=3200, do_not_submit=1)
 			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 3200})
+			pos_inv2.save()
 			pos_inv2.submit()
 
 			pos_inv3 = create_pos_invoice(customer="_Test Customer 2", rate=2300, do_not_submit=1)
 			pos_inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 2300})
+			pos_inv3.save()
 			pos_inv3.submit()
 
 			pos_inv_cn = make_sales_return(pos_inv.name)
@@ -122,6 +128,8 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 				},
 			)
 			inv.insert()
+			inv.payments[0].amount = inv.grand_total
+			inv.save()
 			inv.submit()
 
 			inv2 = create_pos_invoice(qty=1, rate=100, do_not_save=True)
@@ -138,6 +146,8 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 				},
 			)
 			inv2.insert()
+			inv2.payments[0].amount = inv.grand_total
+			inv2.save()
 			inv2.submit()
 
 			consolidate_pos_invoices()
@@ -272,7 +282,7 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 			inv2.submit()
 
 			inv3 = create_pos_invoice(qty=3, rate=600, do_not_save=True)
-			inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1000})
+			inv3.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 1800})
 			inv3.insert()
 			inv3.submit()
 
@@ -280,8 +290,8 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 
 			inv.load_from_db()
 			consolidated_invoice = frappe.get_doc("Sales Invoice", inv.consolidated_invoice)
-			self.assertEqual(consolidated_invoice.outstanding_amount, 800)
-			self.assertNotEqual(consolidated_invoice.status, "Paid")
+			self.assertNotEqual(consolidated_invoice.outstanding_amount, 800)
+			self.assertEqual(consolidated_invoice.status, "Paid")
 
 		finally:
 			frappe.set_user("Administrator")
@@ -416,6 +426,7 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 				do_not_submit=1,
 			)
 			pos_inv.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			pos_inv.save()
 			pos_inv.submit()
 
 			pos_inv_cn = make_sales_return(pos_inv.name)
@@ -430,6 +441,7 @@ class TestPOSInvoiceMergeLog(unittest.TestCase):
 				do_not_submit=1,
 			)
 			pos_inv2.append("payments", {"mode_of_payment": "Cash", "account": "Cash - _TC", "amount": 100})
+			pos_inv2.save()
 			pos_inv2.submit()
 
 			consolidate_pos_invoices()

erpnext/accounts/doctype/pos_profile/pos_profile.json

@@ -23,11 +23,13 @@
   "hide_unavailable_items",
   "auto_add_item_to_cart",
   "validate_stock_on_save",
+  "print_receipt_on_order_complete",
   "column_break_16",
   "update_stock",
   "ignore_pricing_rule",
   "allow_rate_change",
   "allow_discount_change",
+  "disable_grand_total_to_default_mop",
   "section_break_23",
   "item_groups",
   "column_break_25",
@@ -375,6 +377,18 @@
    "fieldname": "disable_rounded_total",
    "fieldtype": "Check",
    "label": "Disable Rounded Total"
+  },
+  {
+   "default": "0",
+   "fieldname": "print_receipt_on_order_complete",
+   "fieldtype": "Check",
+   "label": "Print Receipt on Order Complete"
+  },
+  {
+   "default": "0",
+   "fieldname": "disable_grand_total_to_default_mop",
+   "fieldtype": "Check",
+   "label": "Disable auto setting Grand Total to default Payment Mode"
   }
  ],
  "icon": "icon-cog",
@@ -402,7 +416,7 @@
    "link_fieldname": "pos_profile"
   }
  ],
- "modified": "2022-08-10 12:57:06.241439",
+ "modified": "2025-01-29 13:12:30.796630",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "POS Profile",

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -4,9 +4,14 @@
 
 import frappe
 from frappe import _, msgprint, scrub, unscrub
+from frappe.core.doctype.user_permission.user_permission import get_permitted_documents
 from frappe.model.document import Document
 from frappe.utils import get_link_to_form, now
 
+from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
+	get_checks_for_pl_and_bs_accounts,
+)
+
 
 class POSProfile(Document):
 	# begin: auto-generated types
@@ -36,6 +41,7 @@ class POSProfile(Document):
 		currency: DF.Link
 		customer: DF.Link | None
 		customer_groups: DF.Table[POSCustomerGroup]
+		disable_grand_total_to_default_mop: DF.Check
 		disable_rounded_total: DF.Check
 		disabled: DF.Check
 		expense_account: DF.Link | None
@@ -47,6 +53,7 @@ class POSProfile(Document):
 		letter_head: DF.Link | None
 		payments: DF.Table[POSPaymentMethod]
 		print_format: DF.Link | None
+		print_receipt_on_order_complete: DF.Check
 		select_print_heading: DF.Link | None
 		selling_price_list: DF.Link | None
 		tax_category: DF.Link | None
@@ -68,15 +75,19 @@ class POSProfile(Document):
 		self.validate_accounting_dimensions()
 
 	def validate_accounting_dimensions(self):
-		acc_dim_names = required_accounting_dimensions()
-		for acc_dim in acc_dim_names:
-			if not self.get(acc_dim):
+		acc_dims = get_checks_for_pl_and_bs_accounts()
+		for acc_dim in acc_dims:
+			if (
+				self.company == acc_dim.company
+				and not self.get(acc_dim.fieldname)
+				and (acc_dim.mandatory_for_pl or acc_dim.mandatory_for_bs)
+			):
 				frappe.throw(
 					_(
 						"{0} is a mandatory Accounting Dimension. <br>"
 						"Please set a value for {0} in Accounting Dimensions section."
 					).format(
-						unscrub(frappe.bold(acc_dim)),
+						frappe.bold(acc_dim.label),
 					),
 					title=_("Mandatory Accounting Dimension"),
 				)
@@ -194,17 +205,41 @@ class POSProfile(Document):
 def get_item_groups(pos_profile):
 	item_groups = []
 	pos_profile = frappe.get_cached_doc("POS Profile", pos_profile)
+	permitted_item_groups = get_permitted_nodes("Item Group")
 
 	if pos_profile.get("item_groups"):
 		# Get items based on the item groups defined in the POS profile
 		for data in pos_profile.get("item_groups"):
 			item_groups.extend(
-				["%s" % frappe.db.escape(d.name) for d in get_child_nodes("Item Group", data.item_group)]
+				[
+					"%s" % frappe.db.escape(d.name)
+					for d in get_child_nodes("Item Group", data.item_group)
+					if not permitted_item_groups or d.name in permitted_item_groups
+				]
 			)
 
+	if not item_groups and permitted_item_groups:
+		item_groups = ["%s" % frappe.db.escape(d) for d in permitted_item_groups]
+
 	return list(set(item_groups))
 
 
+def get_permitted_nodes(group_type):
+	nodes = []
+	permitted_nodes = get_permitted_documents(group_type)
+
+	if not permitted_nodes:
+		return nodes
+
+	for node in permitted_nodes:
+		if frappe.db.get_value(group_type, node, "is_group"):
+			nodes.extend([d.name for d in get_child_nodes(group_type, node)])
+		else:
+			nodes.append(node)
+
+	return nodes
+
+
 def get_child_nodes(group_type, root):
 	lft, rgt = frappe.db.get_value(group_type, root, ["lft", "rgt"])
 	return frappe.db.sql(
@@ -214,23 +249,6 @@ def get_child_nodes(group_type, root):
 	)
 
 
-def required_accounting_dimensions():
-	p = frappe.qb.DocType("Accounting Dimension")
-	c = frappe.qb.DocType("Accounting Dimension Detail")
-
-	acc_dim_doc = (
-		frappe.qb.from_(p)
-		.inner_join(c)
-		.on(p.name == c.parent)
-		.select(c.parent)
-		.where((c.mandatory_for_bs == 1) | (c.mandatory_for_pl == 1))
-		.where(p.disabled == 0)
-	).run(as_dict=1)
-
-	acc_dim_names = [scrub(d.parent) for d in acc_dim_doc]
-	return acc_dim_names
-
-
 @frappe.whitelist()
 @frappe.validate_and_sanitize_search_inputs
 def pos_profile_query(doctype, txt, searchfield, start, page_len, filters):

erpnext/accounts/doctype/pricing_rule/pricing_rule.json

@@ -53,6 +53,7 @@
   "column_break_42",
   "free_item_uom",
   "round_free_qty",
+  "dont_enforce_free_item_qty",
   "is_recursive",
   "recurse_for",
   "apply_recursion_over",
@@ -643,12 +644,19 @@
    "fieldname": "has_priority",
    "fieldtype": "Check",
    "label": "Has Priority"
+  },
+  {
+   "default": "0",
+   "depends_on": "eval:doc.price_or_product_discount == 'Product'",
+   "fieldname": "dont_enforce_free_item_qty",
+   "fieldtype": "Check",
+   "label": "Don't Enforce Free Item Qty"
   }
  ],
  "icon": "fa fa-gift",
  "idx": 1,
  "links": [],
- "modified": "2024-09-16 18:14:51.314765",
+ "modified": "2025-02-17 18:15:39.824639",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Pricing Rule",

erpnext/accounts/doctype/pricing_rule/pricing_rule.py

@@ -60,6 +60,7 @@ class PricingRule(Document):
 		disable: DF.Check
 		discount_amount: DF.Currency
 		discount_percentage: DF.Float
+		dont_enforce_free_item_qty: DF.Check
 		for_price_list: DF.Link | None
 		free_item: DF.Link | None
 		free_item_rate: DF.Currency
@@ -415,8 +416,6 @@ def get_pricing_rule_for_item(args, doc=None, for_validate=False):
 			"parent": args.parent,
 			"parenttype": args.parenttype,
 			"child_docname": args.get("child_docname"),
-			"discount_percentage": 0.0,
-			"discount_amount": 0,
 		}
 	)
 
@@ -455,8 +454,7 @@ def get_pricing_rule_for_item(args, doc=None, for_validate=False):
 
 			if pricing_rule.coupon_code_based == 1:
 				if not args.coupon_code:
-					return item_details
-
+					continue
 				coupon_code = frappe.db.get_value(
 					doctype="Coupon Code", filters={"pricing_rule": pricing_rule.name}, fieldname="name"
 				)
@@ -647,7 +645,7 @@ def remove_pricing_rule_for_item(pricing_rules, item_details, item_code=None, ra
 			if pricing_rule.margin_type in ["Percentage", "Amount"]:
 				item_details.margin_rate_or_amount = 0.0
 				item_details.margin_type = None
-		elif pricing_rule.get("free_item"):
+		elif pricing_rule.get("free_item") and not pricing_rule.get("dont_enforce_free_item_qty"):
 			item_details.remove_free_item = (
 				item_code if pricing_rule.get("same_item") else pricing_rule.get("free_item")
 			)

erpnext/accounts/doctype/pricing_rule/test_pricing_rule.py

@@ -428,6 +428,54 @@ class TestPricingRule(FrappeTestCase):
 		self.assertEqual(so.items[1].is_free_item, 1)
 		self.assertEqual(so.items[1].item_code, "_Test Item 2")
 
+	def test_dont_enforce_free_item_qty(self):
+		# this test is only for testing non-enforcement as all other tests in this file already test with enforcement
+		frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule")
+		test_record = {
+			"doctype": "Pricing Rule",
+			"title": "_Test Pricing Rule",
+			"apply_on": "Item Code",
+			"currency": "USD",
+			"items": [
+				{
+					"item_code": "_Test Item",
+				}
+			],
+			"selling": 1,
+			"rate_or_discount": "Discount Percentage",
+			"rate": 0,
+			"min_qty": 0,
+			"max_qty": 7,
+			"discount_percentage": 17.5,
+			"price_or_product_discount": "Product",
+			"same_item": 0,
+			"free_item": "_Test Item 2",
+			"free_qty": 1,
+			"company": "_Test Company",
+		}
+		pricing_rule = frappe.get_doc(test_record.copy()).insert()
+
+		# With enforcement
+		so = make_sales_order(item_code="_Test Item", qty=1, do_not_submit=True)
+		self.assertEqual(so.items[1].is_free_item, 1)
+		self.assertEqual(so.items[1].item_code, "_Test Item 2")
+
+		# Test 1 : Saving a document with an item with pricing list without it's corresponding free item will cause it the free item to be refetched on save
+		so.items.pop(1)
+		so.save()
+		so.reload()
+		self.assertEqual(len(so.items), 2)
+
+		# Without enforcement
+		pricing_rule.dont_enforce_free_item_qty = 1
+		pricing_rule.save()
+
+		# Test 2 : Deleted free item will not be fetched again on save without enforcement
+		so.items.pop(1)
+		so.save()
+		so.reload()
+		self.assertEqual(len(so.items), 1)
+
 	def test_cumulative_pricing_rule(self):
 		frappe.delete_doc_if_exists("Pricing Rule", "_Test Cumulative Pricing Rule")
 		test_record = {
@@ -1451,6 +1499,7 @@ def make_pricing_rule(**args):
 			"discount_amount": args.discount_amount or 0.0,
 			"apply_multiple_pricing_rules": args.apply_multiple_pricing_rules or 0,
 			"has_priority": args.has_priority or 0,
+			"enforce_free_item_qty": args.dont_enforce_free_item_qty or 0,
 		}
 	)
 

erpnext/accounts/doctype/pricing_rule/utils.py

@@ -713,7 +713,10 @@ def apply_pricing_rule_for_free_items(doc, pricing_rule_args):
 				args.pop((item.item_code, item.pricing_rules))
 
 		for free_item in args.values():
-			doc.append("items", free_item)
+			if doc.is_new() or not frappe.get_value(
+				"Pricing Rule", free_item["pricing_rules"], "dont_enforce_free_item_qty"
+			):
+				doc.append("items", free_item)
 
 
 def get_pricing_rule_items(pr_doc, other_items=False) -> list:

erpnext/accounts/doctype/process_payment_reconciliation_log_allocations/process_payment_reconciliation_log_allocations.json

@@ -20,6 +20,7 @@
   "is_advance",
   "section_break_5",
   "difference_amount",
+  "gain_loss_posting_date",
   "column_break_7",
   "difference_account",
   "exchange_rate",
@@ -153,11 +154,16 @@
    "fieldtype": "Check",
    "in_list_view": 1,
    "label": "Reconciled"
+  },
+  {
+   "fieldname": "gain_loss_posting_date",
+   "fieldtype": "Date",
+   "label": "Difference Posting Date"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2023-03-20 21:05:43.121945",
+ "modified": "2025-01-23 16:09:01.058574",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Process Payment Reconciliation Log Allocations",
@@ -167,4 +173,4 @@
  "sort_order": "DESC",
  "states": [],
  "track_changes": 1
-}
+}

erpnext/accounts/doctype/process_payment_reconciliation_log_allocations/process_payment_reconciliation_log_allocations.py

@@ -20,6 +20,7 @@ class ProcessPaymentReconciliationLogAllocations(Document):
 		difference_account: DF.Link | None
 		difference_amount: DF.Currency
 		exchange_rate: DF.Float
+		gain_loss_posting_date: DF.Date | None
 		invoice_number: DF.DynamicLink
 		invoice_type: DF.Link
 		is_advance: DF.Data | None

erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.py

@@ -236,17 +236,21 @@ def get_ar_filters(doc, entry):
 
 def get_html(doc, filters, entry, col, res, ageing):
 	base_template_path = "frappe/www/printview.html"
-	template_path = (
-		"erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html"
-		if doc.report == "General Ledger"
-		else "erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html"
-	)
+	template_path = "erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts_accounts_receivable.html"
+	if doc.report == "General Ledger":
+		template_path = (
+			"erpnext/accounts/doctype/process_statement_of_accounts/process_statement_of_accounts.html"
+		)
+
+	process_soa_html = frappe.get_hooks("process_soa_html")
+	# fetching custom print format for Process Statement of Accounts
+	if process_soa_html and process_soa_html.get(doc.report):
+		template_path = process_soa_html[doc.report][-1]
 
 	if doc.letter_head:
 		from frappe.www.printview import get_letter_head
 
 		letter_head = get_letter_head(doc, 0)
-
 	html = frappe.render_template(
 		template_path,
 		{
@@ -262,7 +266,6 @@ def get_html(doc, filters, entry, col, res, ageing):
 			else None,
 		},
 	)
-
 	html = frappe.render_template(
 		base_template_path,
 		{"body": html, "css": get_print_style(), "title": "Statement For " + entry.customer},
@@ -321,9 +324,12 @@ def get_recipients_and_cc(customer, doc):
 	recipients = []
 	for clist in doc.customers:
 		if clist.customer == customer:
-			recipients.append(clist.billing_email)
+			if clist.billing_email:
+				for email in clist.billing_email.split(","):
+					recipients.append(email.strip())
 			if doc.primary_mandatory and clist.primary_email:
-				recipients.append(clist.primary_email)
+				for email in clist.primary_email.split(","):
+					recipients.append(email.strip())
 	cc = []
 	if doc.cc_to != "":
 		try:

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js

@@ -332,6 +332,8 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 
 		if (this.frm.doc.__onload && this.frm.doc.__onload.load_after_mapping) return;
 
+		let payment_terms_template = this.frm.doc.payment_terms_template;
+
 		erpnext.utils.get_party_details(
 			this.frm,
 			"erpnext.accounts.party.get_party_details",
@@ -352,6 +354,12 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 				me.frm.doc.tax_withholding_category = me.frm.supplier_tds;
 				me.frm.set_df_property("apply_tds", "read_only", me.frm.supplier_tds ? 0 : 1);
 				me.frm.set_df_property("tax_withholding_category", "hidden", me.frm.supplier_tds ? 0 : 1);
+
+				// while duplicating, don't change payment terms
+				if (me.frm.doc.__run_link_triggers === false) {
+					me.frm.set_value("payment_terms_template", payment_terms_template);
+					me.frm.refresh_field("payment_terms_template");
+				}
 			}
 		);
 	}
@@ -368,6 +376,18 @@ erpnext.accounts.PurchaseInvoice = class PurchaseInvoice extends erpnext.buying.
 		}
 	}
 
+	tax_withholding_category(frm) {
+		var me = this;
+		let filtered_taxes = (me.frm.doc.taxes || []).filter((row) => !row.is_tax_withholding_account);
+		me.frm.clear_table("taxes");
+
+		filtered_taxes.forEach((row) => {
+			me.frm.add_child("taxes", row);
+		});
+
+		me.frm.refresh_field("taxes");
+	}
+
 	credit_to() {
 		var me = this;
 		if (this.frm.doc.credit_to) {

erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py

@@ -10,7 +10,6 @@ from frappe.utils import cint, cstr, flt, formatdate, get_link_to_form, getdate,
 
 import erpnext
 from erpnext.accounts.deferred_revenue import validate_service_stop_date
-from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
 from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger import (
 	validate_docs_for_deferred_accounting,
 	validate_docs_for_voucher_types,
@@ -33,7 +32,7 @@ from erpnext.accounts.general_ledger import (
 	merge_similar_entries,
 )
 from erpnext.accounts.party import get_due_date, get_party_account
-from erpnext.accounts.utils import get_account_currency, get_fiscal_year
+from erpnext.accounts.utils import get_account_currency, get_fiscal_year, update_voucher_outstanding
 from erpnext.assets.doctype.asset.asset import is_cwip_accounting_enabled
 from erpnext.assets.doctype.asset_category.asset_category import get_asset_category_account
 from erpnext.buying.utils import check_on_hold_or_closed_status
@@ -838,12 +837,12 @@ class PurchaseInvoice(BuyingController):
 
 	def update_supplier_outstanding(self, update_outstanding):
 		if update_outstanding == "No":
-			update_outstanding_amt(
-				self.credit_to,
-				"Supplier",
-				self.supplier,
-				self.doctype,
-				self.return_against if cint(self.is_return) and self.return_against else self.name,
+			update_voucher_outstanding(
+				voucher_type=self.doctype,
+				voucher_no=self.return_against if cint(self.is_return) and self.return_against else self.name,
+				account=self.credit_to,
+				party_type="Supplier",
+				party=self.supplier,
 			)
 
 	def get_gl_entries(self, warehouse_account=None):
@@ -872,6 +871,7 @@ class PurchaseInvoice(BuyingController):
 		self.make_payment_gl_entries(gl_entries)
 		self.make_write_off_gl_entry(gl_entries)
 		self.make_gle_for_rounding_adjustment(gl_entries)
+		self.set_transaction_currency_and_rate_in_gl_map(gl_entries)
 		return gl_entries
 
 	def check_asset_cwip_enabled(self):
@@ -917,6 +917,7 @@ class PurchaseInvoice(BuyingController):
 			"credit_in_account_currency": base_grand_total
 			if self.party_account_currency == self.company_currency
 			else grand_total,
+			"credit_in_transaction_currency": grand_total,
 			"against_voucher": against_voucher,
 			"against_voucher_type": self.doctype,
 			"project": self.project,
@@ -952,7 +953,7 @@ class PurchaseInvoice(BuyingController):
 		valuation_tax_accounts = [
 			d.account_head
 			for d in self.get("taxes")
-			if d.category in ("Valuation", "Total and Valuation")
+			if d.category in ("Valuation", "Valuation and Total")
 			and flt(d.base_tax_amount_after_discount_amount)
 		]
 
@@ -968,7 +969,6 @@ class PurchaseInvoice(BuyingController):
 
 		for item in self.get("items"):
 			if flt(item.base_net_amount):
-				account_currency = get_account_currency(item.expense_account)
 				if item.item_code:
 					frappe.get_cached_value("Item", item.item_code, "asset_category")
 
@@ -977,6 +977,7 @@ class PurchaseInvoice(BuyingController):
 					and self.auto_accounting_for_stock
 					and (item.item_code in stock_items or item.is_fixed_asset)
 				):
+					account_currency = get_account_currency(item.expense_account)
 					# warehouse account
 					warehouse_debit_amount = self.make_stock_adjustment_entry(
 						gl_entries, item, voucher_wise_stock_value, account_currency
@@ -992,6 +993,7 @@ class PurchaseInvoice(BuyingController):
 									"project": item.project or self.project,
 									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
 									"debit": warehouse_debit_amount,
+									"debit_in_transaction_currency": item.net_amount,
 								},
 								warehouse_account[item.warehouse]["account_currency"],
 								item=item,
@@ -1012,6 +1014,7 @@ class PurchaseInvoice(BuyingController):
 									"project": item.project or self.project,
 									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
 									"debit": -1 * flt(credit_amount, item.precision("base_net_amount")),
+									"debit_in_transaction_currency": item.net_amount,
 								},
 								warehouse_account[item.from_warehouse]["account_currency"],
 								item=item,
@@ -1026,6 +1029,7 @@ class PurchaseInvoice(BuyingController):
 										"account": item.expense_account,
 										"against": self.supplier,
 										"debit": flt(item.base_net_amount, item.precision("base_net_amount")),
+										"debit_in_transaction_currency": item.net_amount,
 										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
 										"cost_center": item.cost_center,
 										"project": item.project,
@@ -1043,6 +1047,10 @@ class PurchaseInvoice(BuyingController):
 										"account": item.expense_account,
 										"against": self.supplier,
 										"debit": warehouse_debit_amount,
+										"debit_in_transaction_currency": flt(
+											warehouse_debit_amount / self.conversion_rate,
+											item.precision("net_amount"),
+										),
 										"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
 										"cost_center": item.cost_center,
 										"project": item.project or self.project,
@@ -1055,7 +1063,9 @@ class PurchaseInvoice(BuyingController):
 					# Amount added through landed-cost-voucher
 					if landed_cost_entries:
 						if (item.item_code, item.name) in landed_cost_entries:
-							for account, amount in landed_cost_entries[(item.item_code, item.name)].items():
+							for account, base_amount in landed_cost_entries[
+								(item.item_code, item.name)
+							].items():
 								gl_entries.append(
 									self.get_gl_dict(
 										{
@@ -1063,8 +1073,9 @@ class PurchaseInvoice(BuyingController):
 											"against": item.expense_account,
 											"cost_center": item.cost_center,
 											"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
-											"credit": flt(amount["base_amount"]),
-											"credit_in_account_currency": flt(amount["amount"]),
+											"credit": flt(base_amount["base_amount"]),
+											"credit_in_account_currency": flt(base_amount["amount"]),
+											"credit_in_transaction_currency": item.net_amount,
 											"project": item.project or self.project,
 										},
 										item=item,
@@ -1087,6 +1098,7 @@ class PurchaseInvoice(BuyingController):
 									"project": item.project or self.project,
 									"remarks": self.get("remarks") or _("Accounting Entry for Stock"),
 									"credit": flt(item.rm_supp_cost),
+									"credit_in_transaction_currency": item.net_amount,
 								},
 								warehouse_account[self.supplier_warehouse]["account_currency"],
 								item=item,
@@ -1100,7 +1112,8 @@ class PurchaseInvoice(BuyingController):
 						else item.deferred_expense_account
 					)
 
-					dummy, amount = self.get_amount_and_base_amount(item, None)
+					account_currency = get_account_currency(expense_account)
+					amount, base_amount = self.get_amount_and_base_amount(item, None)
 
 					if provisional_accounting_for_non_stock_items:
 						self.make_provisional_gl_entry(gl_entries, item)
@@ -1111,7 +1124,8 @@ class PurchaseInvoice(BuyingController):
 								{
 									"account": expense_account,
 									"against": self.supplier,
-									"debit": amount,
+									"debit": base_amount,
+									"debit_in_transaction_currency": amount,
 									"cost_center": item.cost_center,
 									"project": item.project or self.project,
 								},
@@ -1126,6 +1140,7 @@ class PurchaseInvoice(BuyingController):
 								exchange_rate_map[item.purchase_receipt]
 								and self.conversion_rate != exchange_rate_map[item.purchase_receipt]
 								and item.net_rate == net_rate_map[item.pr_detail]
+								and item.item_code in stock_items
 							):
 								discrepancy_caused_by_exchange_rate_difference = (
 									item.qty * item.net_rate
@@ -1184,6 +1199,10 @@ class PurchaseInvoice(BuyingController):
 									"account": stock_rbnb,
 									"against": self.supplier,
 									"debit": flt(item.item_tax_amount, item.precision("item_tax_amount")),
+									"debit_in_transaction_currency": flt(
+										item.item_tax_amount / self.conversion_rate,
+										item.precision("item_tax_amount"),
+									),
 									"remarks": self.remarks or _("Accounting Entry for Stock"),
 									"cost_center": self.cost_center,
 									"project": item.project or self.project,
@@ -1299,6 +1318,7 @@ class PurchaseInvoice(BuyingController):
 						"account": cost_of_goods_sold_account,
 						"against": item.expense_account,
 						"debit": stock_adjustment_amt,
+						"debit_in_transaction_currency": stock_adjustment_amt / self.conversion_rate,
 						"remarks": self.get("remarks") or _("Stock Adjustment"),
 						"cost_center": item.cost_center,
 						"project": item.project or self.project,
@@ -1310,6 +1330,38 @@ class PurchaseInvoice(BuyingController):
 
 			warehouse_debit_amount = stock_amount
 
+		elif self.is_return and self.update_stock and self.is_internal_supplier and warehouse_debit_amount:
+			net_rate = item.base_net_amount
+			if item.sales_incoming_rate:  # for internal transfer
+				net_rate = item.qty * item.sales_incoming_rate
+
+			stock_amount = (
+				net_rate
+				+ item.item_tax_amount
+				+ flt(item.landed_cost_voucher_amount)
+				+ flt(item.get("amount_difference_with_purchase_invoice"))
+			)
+
+			if flt(stock_amount, net_amt_precision) != flt(warehouse_debit_amount, net_amt_precision):
+				cost_of_goods_sold_account = self.get_company_default("default_expense_account")
+				stock_adjustment_amt = stock_amount - warehouse_debit_amount
+
+				gl_entries.append(
+					self.get_gl_dict(
+						{
+							"account": cost_of_goods_sold_account,
+							"against": item.expense_account,
+							"debit": stock_adjustment_amt,
+							"debit_in_transaction_currency": stock_adjustment_amt / self.conversion_rate,
+							"remarks": self.get("remarks") or _("Stock Adjustment"),
+							"cost_center": item.cost_center,
+							"project": item.project or self.project,
+						},
+						account_currency,
+						item=item,
+					)
+				)
+
 		return warehouse_debit_amount
 
 	def make_tax_gl_entries(self, gl_entries):
@@ -1332,6 +1384,7 @@ class PurchaseInvoice(BuyingController):
 							dr_or_cr + "_in_account_currency": base_amount
 							if account_currency == self.company_currency
 							else amount,
+							dr_or_cr + "_in_transaction_currency": amount,
 							"cost_center": tax.cost_center,
 						},
 						account_currency,
@@ -1378,6 +1431,10 @@ class PurchaseInvoice(BuyingController):
 								"cost_center": tax.cost_center,
 								"against": self.supplier,
 								"credit": applicable_amount,
+								"credit_in_transaction_currency": flt(
+									applicable_amount / self.conversion_rate,
+									frappe.get_precision("Purchase Invoice Item", "item_tax_amount"),
+								),
 								"remarks": self.remarks or _("Accounting Entry for Stock"),
 							},
 							item=tax,
@@ -1396,6 +1453,10 @@ class PurchaseInvoice(BuyingController):
 								"cost_center": tax.cost_center,
 								"against": self.supplier,
 								"credit": valuation_tax[tax.name],
+								"credit_in_transaction_currency": flt(
+									valuation_tax[tax.name] / self.conversion_rate,
+									frappe.get_precision("Purchase Invoice Item", "item_tax_amount"),
+								),
 								"remarks": self.remarks or _("Accounting Entry for Stock"),
 							},
 							item=tax,
@@ -1411,6 +1472,7 @@ class PurchaseInvoice(BuyingController):
 						"account": self.unrealized_profit_loss_account,
 						"against": self.supplier,
 						"credit": flt(self.total_taxes_and_charges),
+						"credit_in_transaction_currency": flt(self.total_taxes_and_charges),
 						"credit_in_account_currency": flt(self.base_total_taxes_and_charges),
 						"cost_center": self.cost_center,
 					},
@@ -1460,6 +1522,7 @@ class PurchaseInvoice(BuyingController):
 						"debit_in_account_currency": self.base_paid_amount
 						if self.party_account_currency == self.company_currency
 						else self.paid_amount,
+						"debit_in_transaction_currency": self.paid_amount,
 						"against_voucher": self.return_against
 						if cint(self.is_return) and self.return_against
 						else self.name,
@@ -1481,6 +1544,7 @@ class PurchaseInvoice(BuyingController):
 						"credit_in_account_currency": self.base_paid_amount
 						if bank_account_currency == self.company_currency
 						else self.paid_amount,
+						"credit_in_transaction_currency": self.paid_amount,
 						"cost_center": self.cost_center,
 					},
 					bank_account_currency,
@@ -1505,6 +1569,7 @@ class PurchaseInvoice(BuyingController):
 						"debit_in_account_currency": self.base_write_off_amount
 						if self.party_account_currency == self.company_currency
 						else self.write_off_amount,
+						"debit_in_transaction_currency": self.write_off_amount,
 						"against_voucher": self.return_against
 						if cint(self.is_return) and self.return_against
 						else self.name,
@@ -1525,6 +1590,7 @@ class PurchaseInvoice(BuyingController):
 						"credit_in_account_currency": self.base_write_off_amount
 						if write_off_account_currency == self.company_currency
 						else self.write_off_amount,
+						"credit_in_transaction_currency": self.write_off_amount,
 						"cost_center": self.cost_center or self.write_off_cost_center,
 					},
 					item=self,
@@ -1796,13 +1862,13 @@ class PurchaseInvoice(BuyingController):
 			self.remove(d)
 
 		## Add pending vouchers on which tax was withheld
-		for voucher_no, voucher_details in voucher_wise_amount.items():
+		for row in voucher_wise_amount:
 			self.append(
 				"tax_withheld_vouchers",
 				{
-					"voucher_name": voucher_no,
-					"voucher_type": voucher_details.get("voucher_type"),
-					"taxable_amount": voucher_details.get("amount"),
+					"voucher_name": row.voucher_name,
+					"voucher_type": row.voucher_type,
+					"taxable_amount": row.taxable_amount,
 				},
 			)
 

erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js

@@ -45,12 +45,16 @@ frappe.listview_settings["Purchase Invoice"] = {
 	},
 
 	onload: function (listview) {
-		listview.page.add_action_item(__("Purchase Receipt"), () => {
-			erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Purchase Receipt");
-		});
+		if (frappe.model.can_create("Purchase Receipt")) {
+			listview.page.add_action_item(__("Purchase Receipt"), () => {
+				erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Purchase Receipt");
+			});
+		}
 
-		listview.page.add_action_item(__("Payment"), () => {
-			erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Payment Entry");
-		});
+		if (frappe.model.can_create("Payment Entry")) {
+			listview.page.add_action_item(__("Payment"), () => {
+				erpnext.bulk_transaction_processing.create(listview, "Purchase Invoice", "Payment Entry");
+			});
+		}
 	},
 };

erpnext/accounts/doctype/purchase_invoice/test_purchase_invoice.py

@@ -372,6 +372,53 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 
 		self.assertEqual(discrepancy_caused_by_exchange_rate_diff, amount)
 
+	def test_purchase_invoice_with_exchange_rate_difference_for_non_stock_item(self):
+		from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
+			make_purchase_invoice as create_purchase_invoice,
+		)
+
+		# Creating Purchase Invoice with USD currency
+		pr = frappe.new_doc("Purchase Receipt")
+		pr.currency = "USD"
+		pr.company = "_Test Company with perpetual inventory"
+		pr.conversion_rate = (70,)
+		pr.supplier = "_Test Supplier USD"
+		pr.append(
+			"items",
+			{
+				"item_code": "_Test Non Stock Item",
+				"qty": 1,
+				"rate": 100,
+			},
+		)
+		pr.append(
+			"items",
+			{"item_code": "_Test Item", "qty": 1, "rate": 5, "warehouse": "Stores - TCP1"},
+		)
+		pr.insert()
+		pr.submit()
+
+		# Createing purchase invoice against Purchase Receipt
+		pi = create_purchase_invoice(pr.name)
+		pi.conversion_rate = 80
+		pi.credit_to = "_Test Payable USD - TCP1"
+		pi.insert()
+		pi.submit()
+
+		# Get exchnage gain and loss account
+		exchange_gain_loss_account = frappe.db.get_value("Company", pi.company, "exchange_gain_loss_account")
+
+		# fetching the latest GL Entry with exchange gain and loss account account
+		amount = frappe.db.get_value(
+			"GL Entry", {"account": exchange_gain_loss_account, "voucher_no": pi.name}, "debit"
+		)
+
+		discrepancy_caused_by_exchange_rate_diff = abs(
+			pi.items[1].base_net_amount - pr.items[1].base_net_amount
+		)
+
+		self.assertEqual(discrepancy_caused_by_exchange_rate_diff, amount)
+
 	def test_purchase_invoice_change_naming_series(self):
 		pi = frappe.copy_doc(test_records[1])
 		pi.insert()
@@ -2435,6 +2482,76 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 		item.reload()
 		self.assertEqual(item.last_purchase_rate, 0)
 
+	def test_adjust_incoming_rate_from_pi_with_multi_currency_and_partial_billing(self):
+		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 0)
+
+		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 1)
+
+		pr = make_purchase_receipt(
+			qty=10, rate=10, currency="USD", do_not_save=1, supplier="_Test Supplier USD"
+		)
+		pr.conversion_rate = 5300
+		pr.save()
+		pr.submit()
+
+		incoming_rate = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"incoming_rate",
+		)
+		self.assertEqual(incoming_rate, 53000)  # Asserting to confirm if the default calculation is correct
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.qty = 1
+
+		pi.save()
+		pi.submit()
+
+		incoming_rate = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"incoming_rate",
+		)
+		# Test 1 : Incoming rate should not change as only the qty has changed and not the rate (this was not the case before)
+		self.assertEqual(incoming_rate, 53000)
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.qty = 1
+			row.rate = 9
+
+		pi.save()
+		pi.submit()
+
+		incoming_rate = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"incoming_rate",
+		)
+		# Test 2 : Rate in new PI is lower than PR, so incoming rate should also be lower
+		self.assertEqual(incoming_rate, 50350)
+
+		pi = create_purchase_invoice_from_receipt(pr.name)
+		for row in pi.items:
+			row.qty = 1
+			row.rate = 12
+
+		pi.save()
+		pi.submit()
+
+		incoming_rate = frappe.db.get_value(
+			"Stock Ledger Entry",
+			{"voucher_type": "Purchase Receipt", "voucher_no": pr.name},
+			"incoming_rate",
+		)
+		# Test 3 : Rate in new PI is higher than PR, so incoming rate should also be higher
+		self.assertEqual(incoming_rate, 54766.667)
+
+		frappe.db.set_single_value("Buying Settings", "set_landed_cost_based_on_purchase_invoice_rate", 0)
+
+		frappe.db.set_single_value("Buying Settings", "maintain_same_rate", 1)
+
 	def test_opening_invoice_rounding_adjustment_validation(self):
 		pi = make_purchase_invoice(do_not_save=1)
 		pi.items[0].rate = 99.98
@@ -2522,6 +2639,50 @@ class TestPurchaseInvoice(FrappeTestCase, StockTestMixin):
 			"Buying Settings", "bill_for_rejected_quantity_in_purchase_invoice", original_value
 		)
 
+	def test_trx_currency_debit_credit_for_high_precision(self):
+		exc_rate = 0.737517516
+		pi = make_purchase_invoice(
+			currency="USD", conversion_rate=exc_rate, qty=1, rate=2000, do_not_save=True
+		)
+		pi.supplier = "_Test Supplier USD"
+		pi.save().submit()
+
+		expected = (
+			("_Test Account Cost for Goods Sold - _TC", 1475.04, 0.0, 2000.0, 0.0, "USD", exc_rate),
+			("_Test Payable USD - _TC", 0.0, 1475.04, 0.0, 2000.0, "USD", exc_rate),
+		)
+
+		actual = frappe.db.get_all(
+			"GL Entry",
+			filters={"voucher_no": pi.name},
+			fields=[
+				"account",
+				"debit",
+				"credit",
+				"debit_in_transaction_currency",
+				"credit_in_transaction_currency",
+				"transaction_currency",
+				"transaction_exchange_rate",
+			],
+			order_by="account",
+			as_list=1,
+		)
+		self.assertEqual(actual, expected)
+
+	def test_prevents_fully_returned_invoice_with_zero_quantity(self):
+		from erpnext.controllers.sales_and_purchase_return import StockOverReturnError, make_return_doc
+
+		invoice = make_purchase_invoice(qty=10)
+
+		return_doc = make_return_doc(invoice.doctype, invoice.name)
+		return_doc.items[0].qty = -10
+		return_doc.save().submit()
+
+		return_doc = make_return_doc(invoice.doctype, invoice.name)
+		return_doc.items[0].qty = 0
+
+		self.assertRaises(StockOverReturnError, return_doc.save)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/purchase_invoice_item/purchase_invoice_item.json

@@ -461,7 +461,8 @@
    "depends_on": "eval:!doc.is_fixed_asset && doc.use_serial_batch_fields === 1 && parent.update_stock === 1",
    "fieldname": "serial_no",
    "fieldtype": "Text",
-   "label": "Serial No"
+   "label": "Serial No",
+   "no_copy": 1
   },
   {
    "depends_on": "eval:!doc.is_fixed_asset && doc.use_serial_batch_fields === 1 && parent.update_stock === 1",
@@ -975,7 +976,7 @@
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-10-28 15:06:19.246141",
+ "modified": "2025-03-12 16:33:12.453290",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Purchase Invoice Item",
@@ -985,4 +986,4 @@
  "sort_field": "modified",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/repost_accounting_ledger/repost_accounting_ledger.py

@@ -8,6 +8,8 @@ from frappe import _, qb
 from frappe.model.document import Document
 from frappe.utils.data import comma_and
 
+from erpnext.stock import get_warehouse_account_map
+
 
 class RepostAccountingLedger(Document):
 	# begin: auto-generated types
@@ -97,6 +99,9 @@ class RepostAccountingLedger(Document):
 			doc = frappe.get_doc(x.voucher_type, x.voucher_no)
 			if doc.doctype in ["Payment Entry", "Journal Entry"]:
 				gle_map = doc.build_gl_map()
+			elif doc.doctype == "Purchase Receipt":
+				warehouse_account_map = get_warehouse_account_map(doc.company)
+				gle_map = doc.get_gl_entries(warehouse_account_map)
 			else:
 				gle_map = doc.get_gl_entries()
 
@@ -177,6 +182,14 @@ def start_repost(account_repost_doc=str) -> None:
 						doc.force_set_against_expense_account()
 					doc.make_gl_entries()
 
+				elif doc.doctype == "Purchase Receipt":
+					if not repost_doc.delete_cancelled_entries:
+						doc.docstatus = 2
+						doc.make_gl_entries_on_cancel()
+
+					doc.docstatus = 1
+					doc.make_gl_entries(from_repost=True)
+
 				elif doc.doctype in ["Payment Entry", "Journal Entry", "Expense Claim"]:
 					if not repost_doc.delete_cancelled_entries:
 						doc.make_gl_entries(1)

erpnext/accounts/doctype/repost_accounting_ledger/test_repost_accounting_ledger.py

@@ -12,6 +12,8 @@ from erpnext.accounts.doctype.payment_request.payment_request import make_paymen
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.accounts.utils import get_fiscal_year
+from erpnext.stock.doctype.item.test_item import make_item
+from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import get_gl_entries, make_purchase_receipt
 
 
 class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
@@ -204,9 +206,81 @@ class TestRepostAccountingLedger(AccountsTestMixin, FrappeTestCase):
 		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": si.name, "is_cancelled": 1}))
 		self.assertIsNotNone(frappe.db.exists("GL Entry", {"voucher_no": pe.name, "is_cancelled": 1}))
 
+	def test_06_repost_purchase_receipt(self):
+		from erpnext.accounts.doctype.account.test_account import create_account
+
+		provisional_account = create_account(
+			account_name="Provision Account",
+			parent_account="Current Liabilities - _TC",
+			company=self.company,
+		)
+
+		another_provisional_account = create_account(
+			account_name="Another Provision Account",
+			parent_account="Current Liabilities - _TC",
+			company=self.company,
+		)
+
+		company = frappe.get_doc("Company", self.company)
+		company.enable_provisional_accounting_for_non_stock_items = 1
+		company.default_provisional_account = provisional_account
+		company.save()
+
+		test_cc = company.cost_center
+		default_expense_account = company.default_expense_account
+
+		item = make_item(properties={"is_stock_item": 0})
+
+		pr = make_purchase_receipt(company=self.company, item_code=item.name, rate=1000.0, qty=1.0)
+		pr_gl_entries = get_gl_entries(pr.doctype, pr.name, skip_cancelled=True)
+		expected_pr_gles = [
+			{"account": provisional_account, "debit": 0.0, "credit": 1000.0, "cost_center": test_cc},
+			{"account": default_expense_account, "debit": 1000.0, "credit": 0.0, "cost_center": test_cc},
+		]
+		self.assertEqual(expected_pr_gles, pr_gl_entries)
+
+		# change the provisional account
+		frappe.db.set_value(
+			"Purchase Receipt Item",
+			pr.items[0].name,
+			"provisional_expense_account",
+			another_provisional_account,
+		)
+
+		repost_doc = frappe.new_doc("Repost Accounting Ledger")
+		repost_doc.company = self.company
+		repost_doc.delete_cancelled_entries = True
+		repost_doc.append("vouchers", {"voucher_type": pr.doctype, "voucher_no": pr.name})
+		repost_doc.save().submit()
+
+		pr_gles_after_repost = get_gl_entries(pr.doctype, pr.name, skip_cancelled=True)
+		expected_pr_gles_after_repost = [
+			{"account": default_expense_account, "debit": 1000.0, "credit": 0.0, "cost_center": test_cc},
+			{"account": another_provisional_account, "debit": 0.0, "credit": 1000.0, "cost_center": test_cc},
+		]
+		self.assertEqual(len(pr_gles_after_repost), len(expected_pr_gles_after_repost))
+		self.assertEqual(expected_pr_gles_after_repost, pr_gles_after_repost)
+
+		# teardown
+		repost_doc.cancel()
+		repost_doc.delete()
+
+		pr.reload()
+		pr.cancel()
+
+		company.enable_provisional_accounting_for_non_stock_items = 0
+		company.default_provisional_account = None
+		company.save()
+
 
 def update_repost_settings():
-	allowed_types = ["Sales Invoice", "Purchase Invoice", "Payment Entry", "Journal Entry"]
+	allowed_types = [
+		"Sales Invoice",
+		"Purchase Invoice",
+		"Payment Entry",
+		"Journal Entry",
+		"Purchase Receipt",
+	]
 	repost_settings = frappe.get_doc("Repost Accounting Ledger Settings")
 	for x in allowed_types:
 		repost_settings.append("allowed_types", {"document_type": x, "allowed": True})

erpnext/accounts/doctype/sales_invoice/sales_invoice.js

@@ -16,6 +16,10 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 	setup(doc) {
 		this.setup_posting_date_time_check();
 		super.setup(doc);
+		this.frm.make_methods = {
+			Dunning: this.make_dunning.bind(this),
+			"Invoice Discounting": this.make_invoice_discounting.bind(this),
+		};
 	}
 	company() {
 		super.company();
@@ -61,9 +65,10 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 	refresh(doc, dt, dn) {
 		const me = this;
 		super.refresh();
-		if (cur_frm.msgbox && cur_frm.msgbox.$wrapper.is(":visible")) {
+
+		if (this.frm?.msgbox && this.frm.msgbox.$wrapper.is(":visible")) {
 			// hide new msgbox
-			cur_frm.msgbox.hide();
+			this.frm.msgbox.hide();
 		}
 
 		this.frm.toggle_reqd("due_date", !this.frm.doc.is_return);
@@ -121,12 +126,9 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 					},
 					__("Create")
 				);
-
-				cur_frm.add_custom_button(
+				this.frm.add_custom_button(
 					__("Invoice Discounting"),
-					function () {
-						cur_frm.events.create_invoice_discounting(cur_frm);
-					},
+					this.make_invoice_discounting.bind(this),
 					__("Create")
 				);
 
@@ -135,22 +137,14 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 					.reduce((prev, current) => prev || current, false);
 
 				if (payment_is_overdue) {
-					this.frm.add_custom_button(
-						__("Dunning"),
-						() => {
-							this.frm.events.create_dunning(this.frm);
-						},
-						__("Create")
-					);
+					this.frm.add_custom_button(__("Dunning"), this.make_dunning.bind(this), __("Create"));
 				}
 			}
 
 			if (doc.docstatus === 1) {
 				cur_frm.add_custom_button(
 					__("Maintenance Schedule"),
-					function () {
-						cur_frm.cscript.make_maintenance_schedule();
-					},
+					this.make_maintenance_schedule.bind(this),
 					__("Create")
 				);
 			}
@@ -185,6 +179,20 @@ erpnext.accounts.SalesInvoiceController = class SalesInvoiceController extends (
 		erpnext.accounts.unreconcile_payment.add_unreconcile_btn(me.frm);
 	}
 
+	make_invoice_discounting() {
+		frappe.model.open_mapped_doc({
+			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_invoice_discounting",
+			frm: this.frm,
+		});
+	}
+
+	make_dunning() {
+		frappe.model.open_mapped_doc({
+			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning",
+			frm: this.frm,
+		});
+	}
+
 	make_maintenance_schedule() {
 		frappe.model.open_mapped_doc({
 			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.make_maintenance_schedule",
@@ -889,8 +897,16 @@ frappe.ui.form.on("Sales Invoice", {
 
 	project: function (frm) {
 		if (frm.doc.project) {
-			frm.events.add_timesheet_data(frm, {
-				project: frm.doc.project,
+			frappe.call({
+				method: "is_auto_fetch_timesheet_enabled",
+				doc: frm.doc,
+				callback: function (r) {
+					if (cint(r.message)) {
+						frm.events.add_timesheet_data(frm, {
+							project: frm.doc.project,
+						});
+					}
+				},
 			});
 		}
 	},
@@ -906,9 +922,25 @@ frappe.ui.form.on("Sales Invoice", {
 		}
 
 		const timesheets = await frm.events.get_timesheet_data(frm, kwargs);
+
+		if (kwargs.item_code) {
+			frm.events.add_timesheet_item(frm, kwargs.item_code, timesheets);
+		}
+
 		return frm.events.set_timesheet_data(frm, timesheets);
 	},
 
+	add_timesheet_item: function (frm, item_code, timesheets) {
+		const row = frm.add_child("items");
+		frappe.model.set_value(row.doctype, row.name, "item_code", item_code);
+		frappe.model.set_value(
+			row.doctype,
+			row.name,
+			"qty",
+			timesheets.reduce((a, b) => a + (b["billing_hours"] || 0.0), 0.0)
+		);
+	},
+
 	async get_timesheet_data(frm, kwargs) {
 		return frappe
 			.call({
@@ -1006,6 +1038,22 @@ frappe.ui.form.on("Sales Invoice", {
 								fieldtype: "Date",
 								reqd: 1,
 							},
+							{
+								label: __("Item Code"),
+								fieldname: "item_code",
+								fieldtype: "Link",
+								options: "Item",
+								get_query: () => {
+									return {
+										query: "erpnext.controllers.queries.item_query",
+										filters: {
+											is_sales_item: 1,
+											customer: frm.doc.customer,
+											has_variants: 0,
+										},
+									};
+								},
+							},
 							{
 								fieldtype: "Column Break",
 								fieldname: "col_break_1",
@@ -1030,6 +1078,7 @@ frappe.ui.form.on("Sales Invoice", {
 								from_time: data.from_time,
 								to_time: data.to_time,
 								project: data.project,
+								item_code: data.item_code,
 							});
 							d.hide();
 						},
@@ -1045,20 +1094,6 @@ frappe.ui.form.on("Sales Invoice", {
 			frm.set_df_property("return_against", "label", __("Adjustment Against"));
 		}
 	},
-
-	create_invoice_discounting: function (frm) {
-		frappe.model.open_mapped_doc({
-			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_invoice_discounting",
-			frm: frm,
-		});
-	},
-
-	create_dunning: function (frm) {
-		frappe.model.open_mapped_doc({
-			method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning",
-			frm: frm,
-		});
-	},
 });
 
 frappe.ui.form.on("Sales Invoice Timesheet", {

erpnext/accounts/doctype/sales_invoice/sales_invoice.json

@@ -299,7 +299,8 @@
    "oldfieldname": "project_name",
    "oldfieldtype": "Link",
    "options": "Project",
-   "print_hide": 1
+   "print_hide": 1,
+   "search_index": 1
   },
   {
    "default": "0",
@@ -2176,6 +2177,7 @@
    "print_hide": 1
   }
  ],
+ "grid_page_length": 50,
  "icon": "fa fa-file-text",
  "idx": 181,
  "is_submittable": 1,
@@ -2186,7 +2188,7 @@
    "link_fieldname": "consolidated_invoice"
   }
  ],
- "modified": "2025-01-14 11:38:30.446370",
+ "modified": "2025-03-17 19:32:31.809658",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice",
@@ -2232,6 +2234,7 @@
   }
  ],
  "quick_entry": 1,
+ "row_format": "Dynamic",
  "search_fields": "posting_date, due_date, customer, base_grand_total, outstanding_amount",
  "show_name_in_global_search": 1,
  "sort_field": "modified",
@@ -2241,4 +2244,4 @@
  "title_field": "title",
  "track_changes": 1,
  "track_seen": 1
-}
+}

erpnext/accounts/doctype/sales_invoice/sales_invoice.py

@@ -24,7 +24,11 @@ from erpnext.accounts.doctype.tax_withholding_category.tax_withholding_category
 )
 from erpnext.accounts.general_ledger import get_round_off_account_and_cost_center
 from erpnext.accounts.party import get_due_date, get_party_account, get_party_details
-from erpnext.accounts.utils import cancel_exchange_gain_loss_journal, get_account_currency
+from erpnext.accounts.utils import (
+	cancel_exchange_gain_loss_journal,
+	get_account_currency,
+	update_voucher_outstanding,
+)
 from erpnext.assets.doctype.asset.depreciation import (
 	depreciate_asset,
 	get_disposal_account_and_cost_center,
@@ -456,6 +460,8 @@ class SalesInvoice(SellingController):
 
 				self.make_bundle_for_sales_purchase_return(table_name)
 				self.make_bundle_using_old_serial_batch_fields(table_name)
+
+			self.update_stock_reservation_entries()
 			self.update_stock_ledger()
 
 		# this sequence because outstanding may get -ve
@@ -557,6 +563,7 @@ class SalesInvoice(SellingController):
 		self.make_gl_entries_on_cancel()
 
 		if self.update_stock == 1:
+			self.update_stock_reservation_entries()
 			self.repost_future_sle_and_gle()
 
 		self.db_set("status", "Cancelled")
@@ -671,7 +678,13 @@ class SalesInvoice(SellingController):
 				"Account", self.debit_to, "account_currency", cache=True
 			)
 		if not self.due_date and self.customer:
-			self.due_date = get_due_date(self.posting_date, "Customer", self.customer, self.company)
+			self.due_date = get_due_date(
+				self.posting_date,
+				"Customer",
+				self.customer,
+				self.company,
+				template_name=self.payment_terms_template,
+			)
 
 		super().set_missing_values(for_validate)
 
@@ -1083,11 +1096,15 @@ class SalesInvoice(SellingController):
 					timesheet.billing_amount = ts_doc.total_billable_amount
 
 	def update_timesheet_billing_for_project(self):
-		if not self.timesheets and self.project:
+		if not self.timesheets and self.project and self.is_auto_fetch_timesheet_enabled():
 			self.add_timesheet_data()
 		else:
 			self.calculate_billing_amount_for_timesheet()
 
+	@frappe.whitelist()
+	def is_auto_fetch_timesheet_enabled(self):
+		return frappe.db.get_single_value("Projects Settings", "fetch_timesheet_in_sales_invoice")
+
 	@frappe.whitelist()
 	def add_timesheet_data(self):
 		self.set("timesheets", [])
@@ -1192,14 +1209,14 @@ class SalesInvoice(SellingController):
 				make_reverse_gl_entries(voucher_type=self.doctype, voucher_no=self.name)
 
 			if update_outstanding == "No":
-				from erpnext.accounts.doctype.gl_entry.gl_entry import update_outstanding_amt
-
-				update_outstanding_amt(
-					self.debit_to,
-					"Customer",
-					self.customer,
-					self.doctype,
-					self.return_against if cint(self.is_return) and self.return_against else self.name,
+				update_voucher_outstanding(
+					voucher_type=self.doctype,
+					voucher_no=self.return_against
+					if cint(self.is_return) and self.return_against
+					else self.name,
+					account=self.debit_to,
+					party_type="Customer",
+					party=self.customer,
 				)
 
 		elif self.docstatus == 2 and cint(self.update_stock) and cint(auto_accounting_for_stock):
@@ -1230,6 +1247,7 @@ class SalesInvoice(SellingController):
 		self.make_write_off_gl_entry(gl_entries)
 		self.make_gle_for_rounding_adjustment(gl_entries)
 
+		self.set_transaction_currency_and_rate_in_gl_map(gl_entries)
 		return gl_entries
 
 	def make_customer_gl_entry(self, gl_entries):
@@ -1263,6 +1281,7 @@ class SalesInvoice(SellingController):
 						"debit_in_account_currency": base_grand_total
 						if self.party_account_currency == self.company_currency
 						else grand_total,
+						"debit_in_transaction_currency": grand_total,
 						"against_voucher": against_voucher,
 						"against_voucher_type": self.doctype,
 						"cost_center": self.cost_center,
@@ -1294,6 +1313,9 @@ class SalesInvoice(SellingController):
 								if account_currency == self.company_currency
 								else flt(amount, tax.precision("tax_amount_after_discount_amount"))
 							),
+							"credit_in_transaction_currency": flt(
+								amount, tax.precision("tax_amount_after_discount_amount")
+							),
 							"cost_center": tax.cost_center,
 						},
 						account_currency,
@@ -1311,6 +1333,7 @@ class SalesInvoice(SellingController):
 						"against": self.customer,
 						"debit": flt(self.total_taxes_and_charges),
 						"debit_in_account_currency": flt(self.base_total_taxes_and_charges),
+						"debit_in_transaction_currency": flt(self.total_taxes_and_charges),
 						"cost_center": self.cost_center,
 					},
 					account_currency,
@@ -1409,6 +1432,7 @@ class SalesInvoice(SellingController):
 									if account_currency == self.company_currency
 									else flt(amount, item.precision("net_amount"))
 								),
+								"credit_in_transaction_currency": flt(amount, item.precision("net_amount")),
 								"cost_center": item.cost_center,
 								"project": item.project or self.project,
 							},
@@ -1460,6 +1484,7 @@ class SalesInvoice(SellingController):
 						+ cstr(self.loyalty_redemption_account)
 						+ " for the Loyalty Program",
 						"credit": self.loyalty_amount,
+						"credit_in_transaction_currency": self.loyalty_amount,
 						"against_voucher": self.return_against if cint(self.is_return) else self.name,
 						"against_voucher_type": self.doctype,
 						"cost_center": self.cost_center,
@@ -1474,6 +1499,7 @@ class SalesInvoice(SellingController):
 						"cost_center": self.cost_center or self.loyalty_redemption_cost_center,
 						"against": self.customer,
 						"debit": self.loyalty_amount,
+						"debit_in_transaction_currency": self.loyalty_amount,
 						"remark": "Loyalty Points redeemed by the customer",
 					},
 					item=self,
@@ -1507,6 +1533,7 @@ class SalesInvoice(SellingController):
 								"credit_in_account_currency": payment_mode.base_amount
 								if self.party_account_currency == self.company_currency
 								else payment_mode.amount,
+								"credit_in_transaction_currency": payment_mode.amount,
 								"against_voucher": against_voucher,
 								"against_voucher_type": self.doctype,
 								"cost_center": self.cost_center,
@@ -1526,6 +1553,7 @@ class SalesInvoice(SellingController):
 								"debit_in_account_currency": payment_mode.base_amount
 								if payment_mode_account_currency == self.company_currency
 								else payment_mode.amount,
+								"debit_in_transaction_currency": payment_mode.amount,
 								"cost_center": self.cost_center,
 							},
 							payment_mode_account_currency,
@@ -1550,6 +1578,7 @@ class SalesInvoice(SellingController):
 							"debit_in_account_currency": flt(self.base_change_amount)
 							if self.party_account_currency == self.company_currency
 							else flt(self.change_amount),
+							"debit_in_transaction_currency": flt(self.change_amount),
 							"against_voucher": self.return_against
 							if cint(self.is_return) and self.return_against
 							else self.name,
@@ -1568,6 +1597,7 @@ class SalesInvoice(SellingController):
 							"account": self.account_for_change_amount,
 							"against": self.customer,
 							"credit": self.base_change_amount,
+							"credit_in_transaction_currency": self.change_amount,
 							"cost_center": self.cost_center,
 						},
 						item=self,
@@ -1599,6 +1629,9 @@ class SalesInvoice(SellingController):
 							if self.party_account_currency == self.company_currency
 							else flt(self.write_off_amount, self.precision("write_off_amount"))
 						),
+						"credit_in_transaction_currency": flt(
+							self.write_off_amount, self.precision("write_off_amount")
+						),
 						"against_voucher": self.return_against if cint(self.is_return) else self.name,
 						"against_voucher_type": self.doctype,
 						"cost_center": self.cost_center,
@@ -1619,6 +1652,9 @@ class SalesInvoice(SellingController):
 							if write_off_account_currency == self.company_currency
 							else flt(self.write_off_amount, self.precision("write_off_amount"))
 						),
+						"debit_in_transaction_currency": flt(
+							self.write_off_amount, self.precision("write_off_amount")
+						),
 						"cost_center": self.cost_center or self.write_off_cost_center or default_cost_center,
 					},
 					write_off_account_currency,
@@ -1663,6 +1699,9 @@ class SalesInvoice(SellingController):
 						"credit_in_account_currency": flt(
 							self.rounding_adjustment, self.precision("rounding_adjustment")
 						),
+						"credit_in_transaction_currency": flt(
+							self.rounding_adjustment, self.precision("rounding_adjustment")
+						),
 						"credit": flt(
 							self.base_rounding_adjustment, self.precision("base_rounding_adjustment")
 						),
@@ -1926,13 +1965,16 @@ def is_overdue(doc, total):
 		"base_payment_amount" if doc.party_account_currency != doc.currency else "payment_amount"
 	)
 
-	payable_amount = sum(
-		payment.get(payment_amount_field)
-		for payment in doc.payment_schedule
-		if getdate(payment.due_date) < today
+	payable_amount = flt(
+		sum(
+			payment.get(payment_amount_field)
+			for payment in doc.payment_schedule
+			if getdate(payment.due_date) < today
+		),
+		doc.precision("outstanding_amount"),
 	)
 
-	return (total - outstanding_amount) < payable_amount
+	return flt(total - outstanding_amount, doc.precision("outstanding_amount")) < payable_amount
 
 
 def get_discounting_status(sales_invoice):

erpnext/accounts/doctype/sales_invoice/sales_invoice_list.js

@@ -32,12 +32,16 @@ frappe.listview_settings["Sales Invoice"] = {
 	right_column: "grand_total",
 
 	onload: function (listview) {
-		listview.page.add_action_item(__("Delivery Note"), () => {
-			erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Delivery Note");
-		});
+		if (frappe.model.can_create("Delivery Note")) {
+			listview.page.add_action_item(__("Delivery Note"), () => {
+				erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Delivery Note");
+			});
+		}
 
-		listview.page.add_action_item(__("Payment"), () => {
-			erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Payment Entry");
-		});
+		if (frappe.model.can_create("Payment Entry")) {
+			listview.page.add_action_item(__("Payment"), () => {
+				erpnext.bulk_transaction_processing.create(listview, "Sales Invoice", "Payment Entry");
+			});
+		}
 	},
 };

erpnext/accounts/doctype/sales_invoice/test_sales_invoice.py

@@ -1819,17 +1819,6 @@ class TestSalesInvoice(FrappeTestCase):
 			for field in expected_gle:
 				self.assertEqual(expected_gle[field], gle[field])
 
-	def test_invoice_exchange_rate(self):
-		si = create_sales_invoice(
-			customer="_Test Customer USD",
-			debit_to="_Test Receivable USD - _TC",
-			currency="USD",
-			conversion_rate=1,
-			do_not_save=1,
-		)
-
-		self.assertRaises(frappe.ValidationError, si.save)
-
 	def test_invalid_currency(self):
 		# Customer currency = USD
 
@@ -4235,6 +4224,7 @@ class TestSalesInvoice(FrappeTestCase):
 		si = create_sales_invoice(do_not_submit=True)
 
 		project = frappe.new_doc("Project")
+		project.company = "_Test Company"
 		project.project_name = "Test Total Billed Amount"
 		project.save()
 
@@ -4245,6 +4235,69 @@ class TestSalesInvoice(FrappeTestCase):
 		doc = frappe.get_doc("Project", project.name)
 		self.assertEqual(doc.total_billed_amount, si.grand_total)
 
+	def test_total_billed_amount_with_different_projects(self):
+		# This test case is for checking the scenario where project is set at document level and for **some** child items only, not all
+		from copy import copy
+
+		si = create_sales_invoice(do_not_submit=True)
+
+		project = frappe.new_doc("Project")
+		project.company = "_Test Company"
+		project.project_name = "Test Total Billed Amount"
+		project.save()
+
+		si.project = project.name
+		si.items.append(copy(si.items[0]))
+		si.items.append(copy(si.items[0]))
+		si.items[0].project = project.name
+		si.items[1].project = project.name
+		# Not setting project on last item
+		si.items[1].insert()
+		si.items[2].insert()
+		si.submit()
+
+		project.reload()
+		self.assertIsNone(si.items[2].project)
+		self.assertEqual(project.total_billed_amount, 300)
+
+	def test_pos_returns_with_party_account_currency(self):
+		from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_sales_return
+
+		pos_profile = make_pos_profile()
+		pos_profile.payments = []
+		pos_profile.append("payments", {"default": 1, "mode_of_payment": "Cash"})
+		pos_profile.save()
+
+		pos = create_sales_invoice(
+			customer="_Test Customer USD",
+			currency="USD",
+			conversion_rate=86.595000000,
+			qty=2,
+			do_not_save=True,
+		)
+		pos.is_pos = 1
+		pos.pos_profile = pos_profile.name
+		pos.debit_to = "_Test Receivable USD - _TC"
+		pos.append("payments", {"mode_of_payment": "Cash", "account": "_Test Bank - _TC", "amount": 20.35})
+		pos.save().submit()
+
+		pos_return = make_sales_return(pos.name)
+		self.assertEqual(abs(pos_return.payments[0].amount), pos.payments[0].amount)
+
+	def test_prevents_fully_returned_invoice_with_zero_quantity(self):
+		from erpnext.controllers.sales_and_purchase_return import StockOverReturnError, make_return_doc
+
+		invoice = create_sales_invoice(qty=10)
+
+		return_doc = make_return_doc(invoice.doctype, invoice.name)
+		return_doc.items[0].qty = -10
+		return_doc.save().submit()
+
+		return_doc = make_return_doc(invoice.doctype, invoice.name)
+		return_doc.items[0].qty = 0
+
+		self.assertRaises(StockOverReturnError, return_doc.save)
+
 
 def set_advance_flag(company, flag, default_account):
 	frappe.db.set_value(

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json

@@ -105,6 +105,9 @@
   "delivery_note",
   "dn_detail",
   "delivered_qty",
+  "column_break_vwhb",
+  "pos_invoice",
+  "pos_invoice_item",
   "internal_transfer_section",
   "purchase_order",
   "column_break_92",
@@ -630,6 +633,7 @@
    "fieldname": "serial_no",
    "fieldtype": "Text",
    "label": "Serial No",
+   "no_copy": 1,
    "oldfieldname": "serial_no",
    "oldfieldtype": "Small Text"
   },
@@ -945,19 +949,41 @@
    "no_copy": 1,
    "print_hide": 1,
    "read_only": 1
+  },
+  {
+   "fieldname": "pos_invoice_item",
+   "fieldtype": "Data",
+   "ignore_user_permissions": 1,
+   "label": "POS Invoice Item",
+   "no_copy": 1,
+   "print_hide": 1,
+   "read_only": 1
+  },
+  {
+   "fieldname": "column_break_vwhb",
+   "fieldtype": "Column Break"
+  },
+  {
+   "fieldname": "pos_invoice",
+   "fieldtype": "Link",
+   "label": "POS Invoice",
+   "no_copy": 1,
+   "options": "POS Invoice",
+   "print_hide": 1,
+   "search_index": 1
   }
  ],
  "idx": 1,
  "istable": 1,
  "links": [],
- "modified": "2024-11-25 16:27:33.287341",
+ "modified": "2025-03-12 16:33:52.503777",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Sales Invoice Item",
  "naming_rule": "Random",
  "owner": "Administrator",
  "permissions": [],
- "sort_field": "modified",
+ "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.py

@@ -64,6 +64,8 @@ class SalesInvoiceItem(Document):
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
+		pos_invoice: DF.Link | None
+		pos_invoice_item: DF.Data | None
 		price_list_rate: DF.Currency
 		pricing_rules: DF.SmallText | None
 		project: DF.Link | None

erpnext/accounts/doctype/subscription/subscription.py

@@ -634,9 +634,7 @@ class Subscription(Document):
 		"""
 		invoice = frappe.get_all(
 			self.invoice_document_type,
-			{
-				"subscription": self.name,
-			},
+			{"subscription": self.name, "docstatus": ("<", 2)},
 			limit=1,
 			order_by="to_date desc",
 			pluck="name",
@@ -675,6 +673,7 @@ class Subscription(Document):
 			self.invoice_document_type,
 			{
 				"subscription": self.name,
+				"docstatus": 1,
 				"status": ["!=", "Paid"],
 			},
 		)

erpnext/accounts/doctype/tax_withheld_vouchers/tax_withheld_vouchers.json

@@ -13,17 +13,15 @@
  "fields": [
   {
    "fieldname": "voucher_type",
-   "fieldtype": "Link",
+   "fieldtype": "Data",
    "in_list_view": 1,
-   "label": "Voucher Type",
-   "options": "DocType"
+   "label": "Voucher Type"
   },
   {
    "fieldname": "voucher_name",
-   "fieldtype": "Dynamic Link",
+   "fieldtype": "Data",
    "in_list_view": 1,
-   "label": "Voucher Name",
-   "options": "voucher_type"
+   "label": "Voucher Name"
   },
   {
    "fieldname": "taxable_amount",
@@ -36,7 +34,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2023-01-13 13:40:41.479208",
+ "modified": "2025-02-05 16:39:14.863698",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Tax Withheld Vouchers",

erpnext/accounts/doctype/tax_withheld_vouchers/tax_withheld_vouchers.py

@@ -18,8 +18,8 @@ class TaxWithheldVouchers(Document):
 		parentfield: DF.Data
 		parenttype: DF.Data
 		taxable_amount: DF.Currency
-		voucher_name: DF.DynamicLink | None
-		voucher_type: DF.Link | None
+		voucher_name: DF.Data | None
+		voucher_type: DF.Data | None
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.js

@@ -10,6 +10,7 @@ frappe.ui.form.on("Tax Withholding Category", {
 					filters: {
 						company: child.company,
 						root_type: ["in", ["Asset", "Liability"]],
+						is_group: 0,
 					},
 				};
 			}

erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py

@@ -36,27 +36,38 @@ class TaxWithholdingCategory(Document):
 
 	def validate(self):
 		self.validate_dates()
-		self.validate_accounts()
+		self.validate_companies_and_accounts()
 		self.validate_thresholds()
 
 	def validate_dates(self):
-		last_date = None
-		for d in self.get("rates"):
+		last_to_date = None
+		rates = sorted(self.get("rates"), key=lambda d: getdate(d.from_date))
+
+		for d in rates:
 			if getdate(d.from_date) >= getdate(d.to_date):
 				frappe.throw(_("Row #{0}: From Date cannot be before To Date").format(d.idx))
 
 			# validate overlapping of dates
-			if last_date and getdate(d.to_date) < getdate(last_date):
+			if last_to_date and getdate(d.from_date) < getdate(last_to_date):
 				frappe.throw(_("Row #{0}: Dates overlapping with other row").format(d.idx))
 
-	def validate_accounts(self):
-		existing_accounts = []
+			last_to_date = d.to_date
+
+	def validate_companies_and_accounts(self):
+		existing_accounts = set()
+		companies = set()
 		for d in self.get("accounts"):
+			# validate duplicate company
+			if d.get("company") in companies:
+				frappe.throw(_("Company {0} added multiple times").format(frappe.bold(d.get("company"))))
+			companies.add(d.get("company"))
+
+			# validate duplicate account
 			if d.get("account") in existing_accounts:
 				frappe.throw(_("Account {0} added multiple times").format(frappe.bold(d.get("account"))))
 
 			validate_account_head(d.idx, d.get("account"), d.get("company"))
-			existing_accounts.append(d.get("account"))
+			existing_accounts.add(d.get("account"))
 
 	def validate_thresholds(self):
 		for d in self.get("rates"):
@@ -87,6 +98,7 @@ def get_party_details(inv):
 def get_party_tax_withholding_details(inv, tax_withholding_category=None):
 	if inv.doctype == "Payment Entry":
 		inv.tax_withholding_net_total = inv.net_total
+		inv.base_tax_withholding_net_total = inv.net_total
 
 	pan_no = ""
 	parties = []
@@ -269,7 +281,10 @@ def get_lower_deduction_certificate(company, posting_date, tax_details, pan_no):
 
 def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=None):
 	vouchers, voucher_wise_amount = get_invoice_vouchers(
-		parties, tax_details, inv.company, party_type=party_type
+		parties,
+		tax_details,
+		inv.company,
+		party_type=party_type,
 	)
 
 	payment_entry_vouchers = get_payment_entry_vouchers(
@@ -326,7 +341,7 @@ def get_tax_amount(party_type, parties, inv, tax_details, posting_date, pan_no=N
 			# once tds is deducted, not need to add vouchers in the invoice
 			voucher_wise_amount = {}
 		else:
-			tax_amount = get_tds_amount(ldc, parties, inv, tax_details, vouchers)
+			tax_amount = get_tds_amount(ldc, parties, inv, tax_details, voucher_wise_amount)
 
 	elif party_type == "Customer":
 		if tax_deducted:
@@ -356,13 +371,28 @@ def is_tax_deducted_on_the_basis_of_inv(vouchers):
 
 
 def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
-	doctype = "Purchase Invoice" if party_type == "Supplier" else "Sales Invoice"
-	field = (
-		"base_tax_withholding_net_total as base_net_total" if party_type == "Supplier" else "base_net_total"
-	)
-	voucher_wise_amount = {}
+	voucher_wise_amount = []
 	vouchers = []
 
+	ldcs = frappe.db.get_all(
+		"Lower Deduction Certificate",
+		filters={
+			"valid_from": [">=", tax_details.from_date],
+			"valid_upto": ["<=", tax_details.to_date],
+			"company": company,
+			"supplier": ["in", parties],
+		},
+		fields=["supplier", "valid_from", "valid_upto", "rate"],
+	)
+
+	doctype = "Purchase Invoice" if party_type == "Supplier" else "Sales Invoice"
+	field = [
+		"base_tax_withholding_net_total as base_net_total" if party_type == "Supplier" else "base_net_total",
+		"name",
+		"grand_total",
+		"posting_date",
+	]
+
 	filters = {
 		"company": company,
 		frappe.scrub(party_type): ["in", parties],
@@ -376,15 +406,29 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 			{"apply_tds": 1, "tax_withholding_category": tax_details.get("tax_withholding_category")}
 		)
 
-	invoices_details = frappe.get_all(doctype, filters=filters, fields=["name", field])
+	invoices_details = frappe.get_all(doctype, filters=filters, fields=field)
 
 	for d in invoices_details:
-		vouchers.append(d.name)
-		voucher_wise_amount.update({d.name: {"amount": d.base_net_total, "voucher_type": doctype}})
+		d = frappe._dict(
+			{
+				"voucher_name": d.name,
+				"voucher_type": doctype,
+				"taxable_amount": d.base_net_total,
+				"grand_total": d.grand_total,
+				"posting_date": d.posting_date,
+			}
+		)
+
+		if ldc := [x for x in ldcs if d.posting_date >= x.valid_from and d.posting_date <= x.valid_upto]:
+			if ldc[0].supplier in parties and ldc[0].rate == 0:
+				d.update({"taxable_amount": 0})
+
+		vouchers.append(d.voucher_name)
+		voucher_wise_amount.append(d)
 
 	journal_entries_details = frappe.db.sql(
 		"""
-		SELECT j.name, ja.credit - ja.debit AS amount
+		SELECT j.name, ja.credit - ja.debit AS amount, ja.reference_type
 			FROM `tabJournal Entry` j, `tabJournal Entry Account` ja
 		WHERE
 			j.name = ja.parent
@@ -406,10 +450,18 @@ def get_invoice_vouchers(parties, tax_details, company, party_type="Supplier"):
 		as_dict=1,
 	)
 
-	if journal_entries_details:
-		for d in journal_entries_details:
-			vouchers.append(d.name)
-			voucher_wise_amount.update({d.name: {"amount": d.amount, "voucher_type": "Journal Entry"}})
+	for d in journal_entries_details:
+		vouchers.append(d.name)
+		voucher_wise_amount.append(
+			frappe._dict(
+				{
+					"voucher_name": d.name,
+					"voucher_type": "Journal Entry",
+					"taxable_amount": d.amount,
+					"reference_type": d.reference_type,
+				}
+			)
+		)
 
 	return vouchers, voucher_wise_amount
 
@@ -508,12 +560,24 @@ def get_advance_tax_across_fiscal_year(tax_deducted_on_advances, tax_details):
 	return advance_tax_from_across_fiscal_year
 
 
-def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
+def get_tds_amount(ldc, parties, inv, tax_details, voucher_wise_amount):
 	tds_amount = 0
-	invoice_filters = {"name": ("in", vouchers), "docstatus": 1, "apply_tds": 1}
+
+	pi_grand_total = 0
+	pi_base_net_total = 0
+	jv_credit_amt = 0
+	pe_credit_amt = 0
+
+	for row in voucher_wise_amount:
+		if row.voucher_type == "Purchase Invoice":
+			pi_grand_total += row.get("grand_total", 0)
+			pi_base_net_total += row.get("taxable_amount", 0)
+
+		if row.voucher_type == "Journal Entry" and row.reference_type != "Purchase Invoice":
+			jv_credit_amt += row.get("taxable_amount", 0)
 
 	## for TDS to be deducted on advances
-	payment_entry_filters = {
+	pe_filters = {
 		"party_type": "Supplier",
 		"party": ("in", parties),
 		"docstatus": 1,
@@ -524,70 +588,49 @@ def get_tds_amount(ldc, parties, inv, tax_details, vouchers):
 		"company": inv.company,
 	}
 
-	field = "sum(tax_withholding_net_total)"
+	consider_party_ledger_amt = cint(tax_details.consider_party_ledger_amount)
 
-	if cint(tax_details.consider_party_ledger_amount):
-		invoice_filters.pop("apply_tds", None)
-		field = "sum(grand_total)"
-
-		payment_entry_filters.pop("apply_tax_withholding_amount", None)
-		payment_entry_filters.pop("tax_withholding_category", None)
-
-	supp_inv_credit_amt = frappe.db.get_value("Purchase Invoice", invoice_filters, field) or 0.0
-
-	supp_jv_credit_amt = (
-		frappe.db.get_value(
-			"Journal Entry Account",
-			{
-				"parent": ("in", vouchers),
-				"docstatus": 1,
-				"party": ("in", parties),
-				"reference_type": ("!=", "Purchase Invoice"),
-			},
-			"sum(credit_in_account_currency - debit_in_account_currency)",
-		)
-		or 0.0
-	)
+	if consider_party_ledger_amt:
+		pe_filters.pop("apply_tax_withholding_amount", None)
+		pe_filters.pop("tax_withholding_category", None)
 
 	# Get Amount via payment entry
-	payment_entry_amounts = frappe.db.get_all(
+	payment_entries = frappe.db.get_all(
 		"Payment Entry",
-		filters=payment_entry_filters,
-		fields=["sum(unallocated_amount) as amount", "payment_type"],
-		group_by="payment_type",
+		filters=pe_filters,
+		fields=["name", "unallocated_amount as taxable_amount", "payment_type"],
 	)
 
-	supp_credit_amt = supp_jv_credit_amt
-	supp_credit_amt += inv.get("tax_withholding_net_total", 0)
-
-	for type in payment_entry_amounts:
-		if type.payment_type == "Pay":
-			supp_credit_amt += type.amount
-		else:
-			supp_credit_amt -= type.amount
+	for row in payment_entries:
+		value = row.taxable_amount if row.payment_type == "Pay" else -1 * row.taxable_amount
+		pe_credit_amt += value
+		voucher_wise_amount.append(
+			frappe._dict(
+				{
+					"voucher_name": row.name,
+					"voucher_type": "Payment Entry",
+					"taxable_amount": value,
+				}
+			)
+		)
 
 	threshold = tax_details.get("threshold", 0)
 	cumulative_threshold = tax_details.get("cumulative_threshold", 0)
+	supp_credit_amt = jv_credit_amt + pe_credit_amt + inv.get("tax_withholding_net_total", 0)
+	tax_withholding_net_total = inv.get("base_tax_withholding_net_total", 0)
 
-	if inv.doctype != "Payment Entry":
-		tax_withholding_net_total = inv.get("base_tax_withholding_net_total", 0)
-	else:
-		tax_withholding_net_total = inv.get("tax_withholding_net_total", 0)
+	# if consider_party_ledger_amount is checked, then threshold will be based on grand total
+	amt_for_threshold = pi_grand_total if consider_party_ledger_amt else pi_base_net_total
 
-	has_cumulative_threshold_breached = (
-		cumulative_threshold and (supp_credit_amt + supp_inv_credit_amt) >= cumulative_threshold
+	cumulative_threshold_breached = (
+		cumulative_threshold and (supp_credit_amt + amt_for_threshold) >= cumulative_threshold
 	)
 
-	if (threshold and tax_withholding_net_total >= threshold) or (has_cumulative_threshold_breached):
-		# Get net total again as TDS is calculated on net total
-		# Grand is used to just check for threshold breach
-		net_total = (
-			frappe.db.get_value("Purchase Invoice", invoice_filters, "sum(tax_withholding_net_total)") or 0.0
-		)
-		supp_credit_amt += net_total
+	if (threshold and tax_withholding_net_total >= threshold) or (cumulative_threshold_breached):
+		supp_credit_amt += pi_base_net_total
 
-		if has_cumulative_threshold_breached and cint(tax_details.tax_on_excess_amount):
-			supp_credit_amt = net_total + tax_withholding_net_total - cumulative_threshold
+		if cumulative_threshold_breached and cint(tax_details.tax_on_excess_amount):
+			supp_credit_amt = pi_base_net_total + tax_withholding_net_total - cumulative_threshold
 
 		if ldc and is_valid_certificate(ldc, inv.get("posting_date") or inv.get("transaction_date"), 0):
 			tds_amount = get_lower_deduction_amount(

erpnext/accounts/doctype/tax_withholding_category/test_tax_withholding_category.py

@@ -7,7 +7,7 @@ import unittest
 import frappe
 from frappe.custom.doctype.custom_field.custom_field import create_custom_fields
 from frappe.tests.utils import FrappeTestCase, change_settings
-from frappe.utils import add_days, today
+from frappe.utils import add_days, add_months, today
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.utils import get_fiscal_year
@@ -519,7 +519,7 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		payment = get_payment_entry(order.doctype, order.name)
 		payment.apply_tax_withholding_amount = 1
 		payment.tax_withholding_category = "Cumulative Threshold TDS"
-		payment.submit()
+		payment.save().submit()
 		self.assertEqual(payment.taxes[0].tax_amount, 4000)
 
 	def test_multi_category_single_supplier(self):
@@ -569,6 +569,15 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		pi1.submit()
 		invoices.append(pi1)
 
+		pe = create_payment_entry(
+			payment_type="Pay", party_type="Supplier", party="Test TDS Supplier6", paid_amount=1000
+		)
+		pe.apply_tax_withholding_amount = 1
+		pe.tax_withholding_category = "Test Multi Invoice Category"
+		pe.save()
+		pe.submit()
+		invoices.append(pe)
+
 		pi2 = create_purchase_invoice(supplier="Test TDS Supplier6", rate=9000, do_not_save=True)
 		pi2.apply_tds = 1
 		pi2.tax_withholding_category = "Test Multi Invoice Category"
@@ -584,6 +593,8 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		self.assertTrue(pi2.tax_withheld_vouchers[0].taxable_amount == pi1.net_total)
 		self.assertTrue(pi2.tax_withheld_vouchers[1].voucher_name == pi.name)
 		self.assertTrue(pi2.tax_withheld_vouchers[1].taxable_amount == pi.net_total)
+		self.assertTrue(pi2.tax_withheld_vouchers[2].voucher_name == pe.name)
+		self.assertTrue(pi2.tax_withheld_vouchers[2].taxable_amount == pe.paid_amount)
 
 		# cancel invoices to avoid clashing
 		for d in reversed(invoices):
@@ -655,6 +666,49 @@ class TestTaxWithholdingCategory(FrappeTestCase):
 		pi2.cancel()
 		pi3.cancel()
 
+	def test_ldc_at_0_rate(self):
+		frappe.db.set_value(
+			"Supplier",
+			"Test LDC Supplier",
+			{
+				"tax_withholding_category": "Test Service Category",
+				"pan": "ABCTY1234D",
+			},
+		)
+
+		fiscal_year = get_fiscal_year(today(), company="_Test Company")
+		valid_from = fiscal_year[1]
+		valid_upto = add_months(valid_from, 1)
+		create_lower_deduction_certificate(
+			supplier="Test LDC Supplier",
+			certificate_no="1AE0423AAJ",
+			tax_withholding_category="Test Service Category",
+			tax_rate=0,
+			limit=50000,
+			valid_from=valid_from,
+			valid_upto=valid_upto,
+		)
+
+		pi1 = create_purchase_invoice(
+			supplier="Test LDC Supplier", rate=35000, posting_date=valid_from, set_posting_time=True
+		)
+		pi1.submit()
+		self.assertEqual(pi1.taxes, [])
+
+		pi2 = create_purchase_invoice(
+			supplier="Test LDC Supplier",
+			rate=35000,
+			posting_date=add_days(valid_upto, 1),
+			set_posting_time=True,
+		)
+		pi2.submit()
+		self.assertEqual(len(pi2.taxes), 1)
+		# pi1 net total shouldn't be included as it lies within LDC at rate of '0'
+		self.assertEqual(pi2.taxes[0].tax_amount, 3500)
+
+		pi1.cancel()
+		pi2.cancel()
+
 	def set_previous_fy_and_tax_category(self):
 		test_company = "_Test Company"
 		category = "Cumulative Threshold TDS"
@@ -812,7 +866,8 @@ def create_purchase_invoice(**args):
 	pi = frappe.get_doc(
 		{
 			"doctype": "Purchase Invoice",
-			"posting_date": today(),
+			"set_posting_time": args.set_posting_time or False,
+			"posting_date": args.posting_date or today(),
 			"apply_tds": 0 if args.do_not_apply_tds else 1,
 			"supplier": args.supplier,
 			"company": "_Test Company",
@@ -1150,7 +1205,9 @@ def create_tax_withholding_category(
 		).insert()
 
 
-def create_lower_deduction_certificate(supplier, tax_withholding_category, tax_rate, certificate_no, limit):
+def create_lower_deduction_certificate(
+	supplier, tax_withholding_category, tax_rate, certificate_no, limit, valid_from=None, valid_upto=None
+):
 	fiscal_year = get_fiscal_year(today(), company="_Test Company")
 	if not frappe.db.exists("Lower Deduction Certificate", certificate_no):
 		frappe.get_doc(
@@ -1161,8 +1218,8 @@ def create_lower_deduction_certificate(supplier, tax_withholding_category, tax_r
 				"certificate_no": certificate_no,
 				"tax_withholding_category": tax_withholding_category,
 				"fiscal_year": fiscal_year[0],
-				"valid_from": fiscal_year[1],
-				"valid_upto": fiscal_year[2],
+				"valid_from": valid_from or fiscal_year[1],
+				"valid_upto": valid_upto or fiscal_year[2],
 				"rate": tax_rate,
 				"certificate_limit": limit,
 			}

erpnext/accounts/general_ledger.py

@@ -35,7 +35,7 @@ def make_gl_entries(
 			make_acc_dimensions_offsetting_entry(gl_map)
 			validate_accounting_period(gl_map)
 			validate_disabled_accounts(gl_map)
-			gl_map = process_gl_map(gl_map, merge_entries)
+			gl_map = process_gl_map(gl_map, merge_entries, from_repost=from_repost)
 			if gl_map and len(gl_map) > 1:
 				if gl_map[0].voucher_type != "Period Closing Voucher":
 					create_payment_ledger_entry(
@@ -81,6 +81,10 @@ def make_acc_dimensions_offsetting_entry(gl_map):
 					"credit_in_account_currency": credit,
 					"remarks": _("Offsetting for Accounting Dimension") + f" - {dimension.name}",
 					"against_voucher": None,
+					"account_currency": dimension.account_currency,
+					# Party Type and Party are restricted to Receivable and Payable accounts
+					"party_type": None,
+					"party": None,
 				}
 			)
 			offsetting_entry["against_voucher_type"] = None
@@ -108,6 +112,9 @@ def get_accounting_dimensions_for_offsetting_entry(gl_map, company):
 	accounting_dimensions_to_offset = []
 	for acc_dimension in acc_dimensions:
 		values = set([entry.get(acc_dimension.fieldname) for entry in gl_map])
+		acc_dimension.account_currency = frappe.get_cached_value(
+			"Account", acc_dimension.offsetting_account, "account_currency"
+		)
 		if len(values) > 1:
 			accounting_dimensions_to_offset.append(acc_dimension)
 
@@ -163,12 +170,12 @@ def validate_accounting_period(gl_map):
 		)
 
 
-def process_gl_map(gl_map, merge_entries=True, precision=None):
+def process_gl_map(gl_map, merge_entries=True, precision=None, from_repost=False):
 	if not gl_map:
 		return []
 
 	if gl_map[0].voucher_type != "Period Closing Voucher":
-		gl_map = distribute_gl_based_on_cost_center_allocation(gl_map, precision)
+		gl_map = distribute_gl_based_on_cost_center_allocation(gl_map, precision, from_repost)
 
 	if merge_entries:
 		gl_map = merge_similar_entries(gl_map, precision)
@@ -178,13 +185,17 @@ def process_gl_map(gl_map, merge_entries=True, precision=None):
 	return gl_map
 
 
-def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None):
+def distribute_gl_based_on_cost_center_allocation(gl_map, precision=None, from_repost=False):
 	new_gl_map = []
 	for d in gl_map:
 		cost_center = d.get("cost_center")
 
 		# Validate budget against main cost center
-		validate_expense_against_budget(d, expense_amount=flt(d.debit, precision) - flt(d.credit, precision))
+		if not from_repost:
+			validate_expense_against_budget(
+				d, expense_amount=flt(d.debit, precision) - flt(d.credit, precision)
+			)
+
 		cost_center_allocation = get_cost_center_allocation_data(
 			gl_map[0]["company"], gl_map[0]["posting_date"], cost_center
 		)
@@ -426,7 +437,7 @@ def process_debit_credit_difference(gl_map):
 	voucher_no = gl_map[0].voucher_no
 	allowance = get_debit_credit_allowance(voucher_type, precision)
 
-	debit_credit_diff = get_debit_credit_difference(gl_map, precision)
+	debit_credit_diff, trx_cur_debit_credit_diff = get_debit_credit_difference(gl_map, precision)
 
 	if abs(debit_credit_diff) > allowance:
 		if not (
@@ -437,9 +448,9 @@ def process_debit_credit_difference(gl_map):
 			raise_debit_credit_not_equal_error(debit_credit_diff, voucher_type, voucher_no)
 
 	elif abs(debit_credit_diff) >= (1.0 / (10**precision)):
-		make_round_off_gle(gl_map, debit_credit_diff, precision)
+		make_round_off_gle(gl_map, debit_credit_diff, trx_cur_debit_credit_diff, precision)
 
-	debit_credit_diff = get_debit_credit_difference(gl_map, precision)
+	debit_credit_diff, trx_cur_debit_credit_diff = get_debit_credit_difference(gl_map, precision)
 	if abs(debit_credit_diff) > allowance:
 		if not (
 			voucher_type == "Journal Entry"
@@ -451,14 +462,23 @@ def process_debit_credit_difference(gl_map):
 
 def get_debit_credit_difference(gl_map, precision):
 	debit_credit_diff = 0.0
+	trx_cur_debit_credit_diff = 0
+
 	for entry in gl_map:
 		entry.debit = flt(entry.debit, precision)
 		entry.credit = flt(entry.credit, precision)
 		debit_credit_diff += entry.debit - entry.credit
 
-	debit_credit_diff = flt(debit_credit_diff, precision)
+		entry.debit_in_transaction_currency = flt(entry.debit_in_transaction_currency, precision)
+		entry.credit_in_transaction_currency = flt(entry.credit_in_transaction_currency, precision)
+		trx_cur_debit_credit_diff += (
+			entry.debit_in_transaction_currency - entry.credit_in_transaction_currency
+		)
 
-	return debit_credit_diff
+	debit_credit_diff = flt(debit_credit_diff, precision)
+	trx_cur_debit_credit_diff = flt(trx_cur_debit_credit_diff, precision)
+
+	return debit_credit_diff, trx_cur_debit_credit_diff
 
 
 def get_debit_credit_allowance(voucher_type, precision):
@@ -485,7 +505,7 @@ def has_opening_entries(gl_map: list) -> bool:
 	return False
 
 
-def make_round_off_gle(gl_map, debit_credit_diff, precision):
+def make_round_off_gle(gl_map, debit_credit_diff, trx_cur_debit_credit_diff, precision):
 	round_off_account, round_off_cost_center, round_off_for_opening = get_round_off_account_and_cost_center(
 		gl_map[0].company, gl_map[0].voucher_type, gl_map[0].voucher_no
 	)
@@ -530,6 +550,12 @@ def make_round_off_gle(gl_map, debit_credit_diff, precision):
 			"credit_in_account_currency": debit_credit_diff if debit_credit_diff > 0 else 0,
 			"debit": abs(debit_credit_diff) if debit_credit_diff < 0 else 0,
 			"credit": debit_credit_diff if debit_credit_diff > 0 else 0,
+			"debit_in_transaction_currency": abs(trx_cur_debit_credit_diff)
+			if trx_cur_debit_credit_diff < 0
+			else 0,
+			"credit_in_transaction_currency": trx_cur_debit_credit_diff
+			if trx_cur_debit_credit_diff > 0
+			else 0,
 			"cost_center": round_off_cost_center,
 			"party_type": None,
 			"party": None,
@@ -676,11 +702,15 @@ def make_reverse_gl_entries(
 
 			debit_in_account_currency = new_gle.get("debit_in_account_currency", 0)
 			credit_in_account_currency = new_gle.get("credit_in_account_currency", 0)
+			debit_in_transaction_currency = new_gle.get("debit_in_transaction_currency", 0)
+			credit_in_transaction_currency = new_gle.get("credit_in_transaction_currency", 0)
 
 			new_gle["debit"] = credit
 			new_gle["credit"] = debit
 			new_gle["debit_in_account_currency"] = credit_in_account_currency
 			new_gle["credit_in_account_currency"] = debit_in_account_currency
+			new_gle["debit_in_transaction_currency"] = credit_in_transaction_currency
+			new_gle["credit_in_transaction_currency"] = debit_in_transaction_currency
 
 			new_gle["remarks"] = "On cancellation of " + new_gle["voucher_no"]
 			new_gle["is_cancelled"] = 1

erpnext/accounts/party.py

@@ -279,9 +279,7 @@ def get_regional_address_details(party_details, doctype, company):
 	pass
 
 
-def set_contact_details(party_details, party, party_type):
-	party_details.contact_person = get_default_contact(party_type, party.name)
-
+def complete_contact_details(party_details):
 	if not party_details.contact_person:
 		party_details.update(
 			{
@@ -310,6 +308,11 @@ def set_contact_details(party_details, party, party_type):
 		party_details.update(contact_details)
 
 
+def set_contact_details(party_details, party, party_type):
+	party_details.contact_person = get_default_contact(party_type, party.name)
+	complete_contact_details(party_details)
+
+
 def set_other_values(party_details, party, party_type):
 	# copy
 	if party_type == "Customer":
@@ -572,12 +575,13 @@ def validate_party_accounts(doc):
 
 
 @frappe.whitelist()
-def get_due_date(posting_date, party_type, party, company=None, bill_date=None):
+def get_due_date(posting_date, party_type, party, company=None, bill_date=None, template_name=None):
 	"""Get due date from `Payment Terms Template`"""
 	due_date = None
 	if (bill_date or posting_date) and party:
 		due_date = bill_date or posting_date
-		template_name = get_payment_terms_template(party, party_type, company)
+		if not template_name:
+			template_name = get_payment_terms_template(party, party_type, company)
 
 		if template_name:
 			due_date = get_due_date_from_template(template_name, posting_date, bill_date).strftime("%Y-%m-%d")
@@ -765,7 +769,7 @@ def validate_account_party_type(self):
 
 	if self.party_type and self.party:
 		account_type = frappe.get_cached_value("Account", self.account, "account_type")
-		if account_type and (account_type not in ["Receivable", "Payable"]):
+		if account_type and (account_type not in ["Receivable", "Payable", "Equity"]):
 			frappe.throw(
 				_(
 					"Party Type and Party can only be set for Receivable / Payable account<br><br>" "{0}"

erpnext/accounts/print_format/journal_auditing_voucher/journal_auditing_voucher.html

@@ -44,7 +44,7 @@
             {% endfor %}
             <tr>
                     <td class="right" colspan="3" ><strong>Total (debit) </strong></td>
-                    <td class="left" >{{ gl | sum(attribute='debit') }}</td>
+                    <td class="left" >{{ gl | sum(attribute='debit') | round(2) }}</td>
             </tr>
             <tr>
                     <td class="top-bottom" colspan="5"><strong>Credit</strong></td>
@@ -61,7 +61,7 @@
             {% endfor %}
             <tr>
                 <td class="right" colspan="3"><strong>Total (credit) </strong></td>
-                <td class="left" >{{ gl | sum(attribute='credit') }}</td>
+                <td class="left" >{{ gl | sum(attribute='credit') | round(2) }}</td>
             </tr>
             <tr>
                 <td class="top-bottom" colspan="5"><b>Narration: </b>{{ gl[0].remarks }}</td>

erpnext/accounts/print_format/sales_invoice_print/sales_invoice_print.html

@@ -0,0 +1,161 @@
+{%- macro add_header(page_num, max_pages, doc, letter_head, no_letterhead, footer, print_settings=None, print_heading_template=None) -%}
+	{% if letter_head and not no_letterhead %}
+		<div class="letter-head">{{ letter_head }}</div>
+	{% endif %}
+	{% if print_heading_template %}
+		{{ frappe.render_template(print_heading_template, {"doc":doc}) }}
+	{% else %}
+	{% endif %}
+	{%- if doc.meta.is_submittable and doc.docstatus==2-%}
+	<div class="text-center" document-status="cancelled">
+		<h4 style="margin: 0px;">{{ _("CANCELLED") }}</h4>
+	</div>
+	{%- endif -%}
+{%- endmacro -%}
+{% for page in layout %}
+<div class="page-break">
+	<div {% if print_settings.repeat_header_footer %} id="header-html" class="hidden-pdf" {% endif %}>
+		{{ add_header(loop.index, layout|len, doc, letter_head, no_letterhead, footer, print_settings) }}
+	</div>
+	<style>
+		.taxes-section .order-taxes.mt-5{
+			margin-top: 0px !important;
+		}
+		.taxes-section .order-taxes .border-btm.pb-5{
+			padding-bottom: 0px !important;
+		}
+		.print-format label{
+			color: #74808b;
+			font-size: 12px;
+			margin-bottom: 4px;
+		}
+
+	</style>
+
+	{% if print_settings.repeat_header_footer %}
+	<div id="footer-html" class="visible-pdf">
+		{% if not no_letterhead and footer %}
+		<div class="letter-head-footer">
+			{{ footer }}
+		</div>
+		{% endif %}
+		<p class="text-center small page-number visible-pdf">
+			{{ _("Page {0} of {1}").format('<span class="page"></span>', '<span class="topage"></span>') }}
+		</p>
+	</div>
+	{% endif %}
+
+	<div class="row section-break" style="margin-bottom: 10px;">
+		<div class="col-xs-6 p-0">
+			<div class="col-xs-12 value text-uppercase"><b>{{ doc.customer }}</b></div>
+			<div class="col-xs-12">
+				{{ doc.address_display }}
+			</div>
+			<div class="col-xs-12">
+				{{ _("Contact: ")+doc.contact_display if doc.contact_display else '' }}
+			</div>
+			<div class="col-xs-12">
+				{{ _("Mobile: ")+doc.contact_mobile if doc.contact_mobile else '' }}
+			</div>
+		</div>
+		<div class="col-xs-3"></div>
+		<div class="col-xs-3" style="padding-left: 5px;">
+			<div>
+				<div><label>{{ _("Invoice ID") }}</label></div>
+				<div>{{ doc.name }}</div>
+			</div>
+			<div style="margin-top: 20px;">
+				<div><label>{{ _("Invoice Date") }}</label></div>
+				<div>{{ frappe.utils.format_date(doc.posting_date) }}</div>
+			</div>
+			<div style="margin-top: 20px;">
+				<div><label>{{ _("Due Date") }}</label></div>
+				<div>{{ frappe.utils.format_date(doc.due_date) }}</div>
+			</div>
+		</div>
+	</div>
+
+	<div class="section-break">
+		<table class="table table-bordered table-condensed mb-0" style="width: 100%; border-collapse: collapse; font-size: 12px;">
+			<colgroup>
+				<col style="width: 5%">
+				<col style="width: 45%">
+				<col style="width: 10%">
+				<col style="width: 20%">
+				<col style="width: 20%">
+			</colgroup>
+			<thead>
+				<tr>
+					<th class="text-uppercase" style="text-align:center">{{ _("Sr") }}</th>
+					<th class="text-uppercase" style="text-align:center">{{ _("Details") }}</th>
+					<th class="text-uppercase" style="text-align:center">{{ _("Qty") }}</th>
+					<th class="text-uppercase" style="text-align:right">{{ _("Rate") }}</th>
+					<th class="text-uppercase" style="text-align:right">{{ _("Amount") }}</th>
+				</tr>
+			</thead>
+			{% for item in doc.items %}
+			<tr>
+				<td style="text-align:center">{{ loop.index }}</td>
+				<td>
+					<b>{{ item.item_code }}: {{ item.item_name }}</b>
+					{% if (item.description != item.item_name) %}
+						<br>{{ item.description }}
+					{% endif %}
+				</td>
+				<td style="text-align: center;">
+					{{ item.get_formatted("qty", 0) }}
+					{{ item.get_formatted("uom", 0) }}
+				</td>
+				<td style="text-align: right;">{{ item.get_formatted("net_rate", doc) }}</td>
+				<td style="text-align: right;">{{ item.get_formatted("net_amount", doc) }}</td>
+			</tr>
+			{% endfor %}
+		</table>
+		<!-- total -->
+		<div class="row">
+
+			<div class="col-xs-6">
+				<div>
+					<label>{{ _("Amount in Words") }}</label>
+					{{ doc.in_words }}
+				</div>
+				<div style="margin-top: 20px;">
+					<label>{{ _("Payment Status") }}</label>
+					{{ doc.status }}
+				</div>
+			</div>
+			<div class="col-xs-6">
+				<div class="row section-break">
+					<div class="col-xs-7"><div>{{ _("Sub Total") }}</div></div>
+					<div class="col-xs-5" style="text-align: right;">{{ doc.get_formatted("net_total", doc) }}</div>
+				</div>
+				<div>
+					{% for d in doc.taxes %}
+						{% if d.tax_amount %}
+							<div class="row">
+								<div class="col-xs-8"><div>{{ _(d.description) }}</div></div>
+								<div class="col-xs-4" style="text-align: right;">{{ d.get_formatted("tax_amount") }}</div>
+							</div>
+						{% endif %}
+					{% endfor %}
+				</div>
+				<div class="row">
+					<div class="col-xs-7"><div>{{ _("Total") }}</div></div>
+					<div class="col-xs-5" style="text-align: right;">{{ doc.get_formatted("grand_total", doc) }}</div>
+				</div>
+			</div>
+
+		</div>
+	</div>
+
+
+	<div class="row">
+		<div class="col-xs-12">
+			<div class="row important data-field">
+				<div class="col-xs-12"><label>{{ _("Terms and Conditions") }}: </label></div>
+				<div class="col-xs-12">{{ doc.terms if doc.terms else '' }}</div>
+			</div>
+		</div>
+	</div>
+</div>
+{% endfor %}

erpnext/accounts/print_format/sales_invoice_print/sales_invoice_print.json

@@ -0,0 +1,32 @@
+{
+ "absolute_value": 0,
+ "align_labels_right": 0,
+ "creation": "2025-01-22 16:23:51.012200",
+ "css": "",
+ "custom_format": 0,
+ "default_print_language": "en",
+ "disabled": 0,
+ "doc_type": "Sales Invoice",
+ "docstatus": 0,
+ "doctype": "Print Format",
+ "font": "",
+ "font_size": 14,
+ "idx": 0,
+ "line_breaks": 0,
+ "margin_bottom": 0.0,
+ "margin_left": 0.0,
+ "margin_right": 0.0,
+ "margin_top": 0.0,
+ "modified": "2025-01-22 16:23:51.012200",
+ "modified_by": "Administrator",
+ "module": "Accounts",
+ "name": "Sales Invoice Print",
+ "owner": "Administrator",
+ "page_number": "Hide",
+ "print_format_builder": 0,
+ "print_format_builder_beta": 0,
+ "print_format_type": "Jinja",
+ "raw_printing": 0,
+ "show_section_headings": 0,
+ "standard": "Yes"
+}

erpnext/accounts/report/accounts_payable/accounts_payable.js

@@ -89,6 +89,7 @@ frappe.query_reports["Accounts Payable"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.js

@@ -66,6 +66,7 @@ frappe.query_reports["Accounts Payable Summary"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.js

@@ -56,6 +56,7 @@ frappe.query_reports["Accounts Receivable"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/accounts_receivable/accounts_receivable.py

@@ -517,10 +517,10 @@ class ReceivablePayableReport:
 			select
 				si.name, si.party_account_currency, si.currency, si.conversion_rate,
 				si.total_advance, ps.due_date, ps.payment_term, ps.payment_amount, ps.base_payment_amount,
-				ps.description, ps.paid_amount, ps.discounted_amount
+				ps.description, ps.paid_amount, ps.base_paid_amount, ps.discounted_amount
 			from `tab{row.voucher_type}` si, `tabPayment Schedule` ps
 			where
-				si.name = ps.parent and
+				si.name = ps.parent and ps.parenttype = '{row.voucher_type}' and
 				si.name = %s and
 				si.is_return = 0
 			order by ps.paid_amount desc, due_date
@@ -540,20 +540,24 @@ class ReceivablePayableReport:
 		# Deduct that from paid amount pre allocation
 		row.paid -= flt(payment_terms_details[0].total_advance)
 
+		company_currency = frappe.get_value("Company", self.filters.get("company"), "default_currency")
+
 		# If single payment terms, no need to split the row
 		if len(payment_terms_details) == 1 and payment_terms_details[0].payment_term:
-			self.append_payment_term(row, payment_terms_details[0], original_row)
+			self.append_payment_term(row, payment_terms_details[0], original_row, company_currency)
 			return
 
 		for d in payment_terms_details:
 			term = frappe._dict(original_row)
-			self.append_payment_term(row, d, term)
+			self.append_payment_term(row, d, term, company_currency)
 
-	def append_payment_term(self, row, d, term):
-		if d.currency == d.party_account_currency:
+	def append_payment_term(self, row, d, term, company_currency):
+		invoiced = d.base_payment_amount
+		paid_amount = d.base_paid_amount
+
+		if company_currency == d.party_account_currency or self.filters.get("in_party_currency"):
 			invoiced = d.payment_amount
-		else:
-			invoiced = d.base_payment_amount
+			paid_amount = d.paid_amount
 
 		row.payment_terms.append(
 			term.update(
@@ -562,15 +566,15 @@ class ReceivablePayableReport:
 					"invoiced": invoiced,
 					"invoice_grand_total": row.invoiced,
 					"payment_term": d.description or d.payment_term,
-					"paid": d.paid_amount + d.discounted_amount,
+					"paid": paid_amount + d.discounted_amount,
 					"credit_note": 0.0,
-					"outstanding": invoiced - d.paid_amount - d.discounted_amount,
+					"outstanding": invoiced - paid_amount - d.discounted_amount,
 				}
 			)
 		)
 
-		if d.paid_amount:
-			row["paid"] -= d.paid_amount + d.discounted_amount
+		if paid_amount:
+			row["paid"] -= paid_amount + d.discounted_amount
 
 	def allocate_closing_to_term(self, row, term, key):
 		if row[key]:
@@ -729,11 +733,13 @@ class ReceivablePayableReport:
 			"company": self.filters.company,
 			"update_outstanding_for_self": 0,
 		}
+
 		or_filters = {}
-		for party_type in self.party_type:
+		if party_type := self.filters.party_type:
 			party_field = scrub(party_type)
-			if self.filters.get(party_field):
-				or_filters.update({party_field: self.filters.get(party_field)})
+			if parties := self.filters.get("party"):
+				or_filters.update({party_field: ["in", parties]})
+
 		self.return_entries = frappe._dict(
 			frappe.get_all(
 				doctype, filters=filters, or_filters=or_filters, fields=["name", "return_against"], as_list=1

erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.js

@@ -66,6 +66,7 @@ frappe.query_reports["Accounts Receivable Summary"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py

@@ -50,6 +50,7 @@ def get_group_by_asset_category_data(filters):
 			flt(row.accumulated_depreciation_as_on_from_date)
 			+ flt(row.depreciation_amount_during_the_period)
 			- flt(row.depreciation_eliminated_during_the_period)
+			- flt(row.depreciation_eliminated_via_reversal)
 		)
 
 		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
@@ -144,6 +145,130 @@ def get_asset_categories_for_grouped_by_category(filters):
 	)
 
 
+def get_assets_for_grouped_by_category(filters):
+	condition = ""
+	if filters.get("asset_category"):
+		condition = f" and a.asset_category = '{filters.get('asset_category')}'"
+	finance_book_filter = ""
+	if filters.get("finance_book"):
+		finance_book_filter += " and ifnull(gle.finance_book, '')=%(finance_book)s"
+		condition += " and exists (select 1 from `tabAsset Depreciation Schedule` ads where ads.asset = a.name and ads.finance_book = %(finance_book)s)"
+
+	# nosemgrep
+	return frappe.db.sql(
+		f"""
+		SELECT results.asset_category,
+			   sum(results.accumulated_depreciation_as_on_from_date) as accumulated_depreciation_as_on_from_date,
+			   sum(results.depreciation_eliminated_via_reversal) as depreciation_eliminated_via_reversal,
+			   sum(results.depreciation_eliminated_during_the_period) as depreciation_eliminated_during_the_period,
+			   sum(results.depreciation_amount_during_the_period) as depreciation_amount_during_the_period
+		from (SELECT a.asset_category,
+				   ifnull(sum(case when gle.posting_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
+								   gle.debit
+							  else
+								   0
+							  end), 0) as accumulated_depreciation_as_on_from_date,
+				   ifnull(sum(case when gle.posting_date <= %(to_date)s and ifnull(a.disposal_date, 0) = 0 then
+								   gle.credit
+							  else
+								   0
+							  end), 0) as depreciation_eliminated_via_reversal,
+				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
+										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
+								   gle.debit
+							  else
+								   0
+							  end), 0) as depreciation_eliminated_during_the_period,
+				   ifnull(sum(case when gle.posting_date >= %(from_date)s and gle.posting_date <= %(to_date)s
+										and (ifnull(a.disposal_date, 0) = 0 or gle.posting_date <= a.disposal_date) then
+								   gle.debit
+							  else
+								   0
+							  end), 0) as depreciation_amount_during_the_period
+			from `tabGL Entry` gle
+			join `tabAsset` a on
+				gle.against_voucher = a.name
+			join `tabAsset Category Account` aca on
+				aca.parent = a.asset_category and aca.company_name = %(company)s
+			join `tabCompany` company on
+				company.name = %(company)s
+			where
+				a.docstatus=1
+				and a.company=%(company)s
+				and a.purchase_date <= %(to_date)s
+				and gle.is_cancelled = 0
+				and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
+				{condition} {finance_book_filter}
+			group by a.asset_category
+			union
+			SELECT a.asset_category,
+				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date < %(from_date)s then
+									0
+							   else
+									a.opening_accumulated_depreciation
+							   end), 0) as accumulated_depreciation_as_on_from_date,
+				0 as depreciation_eliminated_via_reversal,
+				   ifnull(sum(case when a.disposal_date >= %(from_date)s and a.disposal_date <= %(to_date)s then
+								   a.opening_accumulated_depreciation
+							  else
+								   0
+							  end), 0) as depreciation_eliminated_during_the_period,
+				   0 as depreciation_amount_during_the_period
+			from `tabAsset` a
+			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
+			group by a.asset_category) as results
+		group by results.asset_category
+		""",
+		{
+			"to_date": filters.to_date,
+			"from_date": filters.from_date,
+			"company": filters.company,
+			"finance_book": filters.get("finance_book", ""),
+		},
+		as_dict=1,
+	)
+
+
+def get_group_by_asset_data(filters):
+	data = []
+
+	asset_details = get_asset_details_for_grouped_by_category(filters)
+	assets = get_assets_for_grouped_by_asset(filters)
+
+	for asset_detail in asset_details:
+		row = frappe._dict()
+		row.update(asset_detail)
+
+		row.value_as_on_to_date = (
+			flt(row.value_as_on_from_date)
+			+ flt(row.value_of_new_purchase)
+			- flt(row.value_of_sold_asset)
+			- flt(row.value_of_scrapped_asset)
+			- flt(row.value_of_capitalized_asset)
+		)
+
+		row.update(next(asset for asset in assets if asset["asset"] == asset_detail.get("name", "")))
+
+		row.accumulated_depreciation_as_on_to_date = (
+			flt(row.accumulated_depreciation_as_on_from_date)
+			+ flt(row.depreciation_amount_during_the_period)
+			- flt(row.depreciation_eliminated_during_the_period)
+			- flt(row.depreciation_eliminated_via_reversal)
+		)
+
+		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
+			row.accumulated_depreciation_as_on_from_date
+		)
+
+		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
+			row.accumulated_depreciation_as_on_to_date
+		)
+
+		data.append(row)
+
+	return data
+
+
 def get_asset_details_for_grouped_by_category(filters):
 	condition = ""
 	if filters.get("asset"):
@@ -223,123 +348,6 @@ def get_asset_details_for_grouped_by_category(filters):
 	)
 
 
-def get_group_by_asset_data(filters):
-	data = []
-
-	asset_details = get_asset_details_for_grouped_by_category(filters)
-	assets = get_assets_for_grouped_by_asset(filters)
-
-	for asset_detail in asset_details:
-		row = frappe._dict()
-		row.update(asset_detail)
-
-		row.value_as_on_to_date = (
-			flt(row.value_as_on_from_date)
-			+ flt(row.value_of_new_purchase)
-			- flt(row.value_of_sold_asset)
-			- flt(row.value_of_scrapped_asset)
-			- flt(row.value_of_capitalized_asset)
-		)
-
-		row.update(next(asset for asset in assets if asset["asset"] == asset_detail.get("name", "")))
-
-		row.accumulated_depreciation_as_on_to_date = (
-			flt(row.accumulated_depreciation_as_on_from_date)
-			+ flt(row.depreciation_amount_during_the_period)
-			- flt(row.depreciation_eliminated_during_the_period)
-		)
-
-		row.net_asset_value_as_on_from_date = flt(row.value_as_on_from_date) - flt(
-			row.accumulated_depreciation_as_on_from_date
-		)
-
-		row.net_asset_value_as_on_to_date = flt(row.value_as_on_to_date) - flt(
-			row.accumulated_depreciation_as_on_to_date
-		)
-
-		data.append(row)
-
-	return data
-
-
-def get_assets_for_grouped_by_category(filters):
-	condition = ""
-	if filters.get("asset_category"):
-		condition = f" and a.asset_category = '{filters.get('asset_category')}'"
-	finance_book_filter = ""
-	if filters.get("finance_book"):
-		finance_book_filter += " and ifnull(gle.finance_book, '')=%(finance_book)s"
-		condition += " and exists (select 1 from `tabAsset Depreciation Schedule` ads where ads.asset = a.name and ads.finance_book = %(finance_book)s)"
-
-	# nosemgrep
-	return frappe.db.sql(
-		f"""
-		SELECT results.asset_category,
-			   sum(results.accumulated_depreciation_as_on_from_date) as accumulated_depreciation_as_on_from_date,
-			   sum(results.depreciation_eliminated_during_the_period) as depreciation_eliminated_during_the_period,
-			   sum(results.depreciation_amount_during_the_period) as depreciation_amount_during_the_period
-		from (SELECT a.asset_category,
-				   ifnull(sum(case when gle.posting_date < %(from_date)s and (ifnull(a.disposal_date, 0) = 0 or a.disposal_date >= %(from_date)s) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
-										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   ifnull(sum(case when gle.posting_date >= %(from_date)s and gle.posting_date <= %(to_date)s
-										and (ifnull(a.disposal_date, 0) = 0 or gle.posting_date <= a.disposal_date) then
-								   gle.debit
-							  else
-								   0
-							  end), 0) as depreciation_amount_during_the_period
-			from `tabGL Entry` gle
-			join `tabAsset` a on
-				gle.against_voucher = a.name
-			join `tabAsset Category Account` aca on
-				aca.parent = a.asset_category and aca.company_name = %(company)s
-			join `tabCompany` company on
-				company.name = %(company)s
-			where
-				a.docstatus=1
-				and a.company=%(company)s
-				and a.purchase_date <= %(to_date)s
-				and gle.debit != 0
-				and gle.is_cancelled = 0
-				and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
-				{condition} {finance_book_filter}
-			group by a.asset_category
-			union
-			SELECT a.asset_category,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and (a.disposal_date < %(from_date)s or a.disposal_date > %(to_date)s) then
-									0
-							   else
-									a.opening_accumulated_depreciation
-							   end), 0) as accumulated_depreciation_as_on_from_date,
-				   ifnull(sum(case when a.disposal_date >= %(from_date)s and a.disposal_date <= %(to_date)s then
-								   a.opening_accumulated_depreciation
-							  else
-								   0
-							  end), 0) as depreciation_eliminated_during_the_period,
-				   0 as depreciation_amount_during_the_period
-			from `tabAsset` a
-			where a.docstatus=1 and a.company=%(company)s and a.purchase_date <= %(to_date)s {condition}
-			group by a.asset_category) as results
-		group by results.asset_category
-		""",
-		{
-			"to_date": filters.to_date,
-			"from_date": filters.from_date,
-			"company": filters.company,
-			"finance_book": filters.get("finance_book", ""),
-		},
-		as_dict=1,
-	)
-
-
 def get_assets_for_grouped_by_asset(filters):
 	condition = ""
 	if filters.get("asset"):
@@ -354,6 +362,7 @@ def get_assets_for_grouped_by_asset(filters):
 		f"""
 		SELECT results.name as asset,
 			   sum(results.accumulated_depreciation_as_on_from_date) as accumulated_depreciation_as_on_from_date,
+			   sum(results.depreciation_eliminated_via_reversal) as depreciation_eliminated_via_reversal,
 			   sum(results.depreciation_eliminated_during_the_period) as depreciation_eliminated_during_the_period,
 			   sum(results.depreciation_amount_during_the_period) as depreciation_amount_during_the_period
 		from (SELECT a.name as name,
@@ -362,6 +371,11 @@ def get_assets_for_grouped_by_asset(filters):
 							  else
 								   0
 							  end), 0) as accumulated_depreciation_as_on_from_date,
+				   ifnull(sum(case when gle.posting_date <= %(to_date)s and ifnull(a.disposal_date, 0) = 0 then
+								   gle.credit
+							  else
+								   0
+							  end), 0) as depreciation_eliminated_via_reversal,
 				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date >= %(from_date)s
 										and a.disposal_date <= %(to_date)s and gle.posting_date <= a.disposal_date then
 								   gle.debit
@@ -385,18 +399,18 @@ def get_assets_for_grouped_by_asset(filters):
 				a.docstatus=1
 				and a.company=%(company)s
 				and a.purchase_date <= %(to_date)s
-				and gle.debit != 0
 				and gle.is_cancelled = 0
 				and gle.account = ifnull(aca.depreciation_expense_account, company.depreciation_expense_account)
 				{finance_book_filter} {condition}
 			group by a.name
 			union
 			SELECT a.name as name,
-				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and (a.disposal_date < %(from_date)s or a.disposal_date > %(to_date)s) then
+				   ifnull(sum(case when ifnull(a.disposal_date, 0) != 0 and a.disposal_date < %(from_date)s then
 									0
 							   else
 									a.opening_accumulated_depreciation
 							   end), 0) as accumulated_depreciation_as_on_from_date,
+				   0 as depreciation_as_on_from_date_credit,
 				   ifnull(sum(case when a.disposal_date >= %(from_date)s and a.disposal_date <= %(to_date)s then
 								   a.opening_accumulated_depreciation
 							  else
@@ -503,6 +517,12 @@ def get_columns(filters):
 			"fieldtype": "Currency",
 			"width": 270,
 		},
+		{
+			"label": _("Depreciation eliminated via reversal"),
+			"fieldname": "depreciation_eliminated_via_reversal",
+			"fieldtype": "Currency",
+			"width": 270,
+		},
 		{
 			"label": _("Net Asset value as on") + " " + formatdate(filters.day_before_from_date),
 			"fieldname": "net_asset_value_as_on_from_date",

erpnext/accounts/report/billed_items_to_be_received/billed_items_to_be_received.py

@@ -27,6 +27,7 @@ def get_report_filters(report_filters):
 		["Purchase Invoice", "docstatus", "=", 1],
 		["Purchase Invoice", "per_received", "<", 100],
 		["Purchase Invoice", "update_stock", "=", 0],
+		["Purchase Invoice", "is_opening", "!=", "Yes"],
 	]
 
 	if report_filters.get("purchase_invoice"):

erpnext/accounts/report/budget_variance_report/budget_variance_report.js

@@ -91,6 +91,7 @@ function get_filters() {
 			fieldname: "budget_against_filter",
 			label: __("Dimension Filter"),
 			fieldtype: "MultiSelectList",
+			options: "budget_against",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/budget_variance_report/budget_variance_report.py

@@ -263,6 +263,7 @@ def get_actual_details(name, filters):
 				and ba.account=gl.account
 				and b.{budget_against} = gl.{budget_against}
 				and gl.fiscal_year between %s and %s
+				and gl.is_cancelled = 0
 				and b.{budget_against} = %s
 				and exists(
 					select

erpnext/accounts/report/deferred_revenue_and_expense/deferred_revenue_and_expense.py

@@ -307,6 +307,7 @@ class Deferred_Revenue_and_Expense_Report:
 			.where(
 				(inv.docstatus == 1)
 				& (deferred_flag_field == 1)
+				& (inv.company == self.filters.company)
 				& (
 					(
 						(self.period_list[0].from_date >= inv_item.service_start_date)

erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.js

@@ -2,5 +2,27 @@
 // For license information, please see license.txt
 
 frappe.query_reports["Delivered Items To Be Billed"] = {
-	filters: [],
+	filters: [
+		{
+			label: __("Company"),
+			fieldname: "company",
+			fieldtype: "Link",
+			options: "Company",
+			reqd: 1,
+			default: frappe.defaults.get_default("Company"),
+		},
+		{
+			label: __("As on Date"),
+			fieldname: "posting_date",
+			fieldtype: "Date",
+			reqd: 1,
+			default: frappe.datetime.get_today(),
+		},
+		{
+			label: __("Delivery Note"),
+			fieldname: "delivery_note",
+			fieldtype: "Link",
+			options: "Delivery Note",
+		},
+	],
 };

erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py

@@ -3,6 +3,7 @@
 
 
 from frappe import _
+from pypika import Order
 
 from erpnext.accounts.report.non_billed_report import get_ordered_to_be_billed_data
 
@@ -10,7 +11,7 @@ from erpnext.accounts.report.non_billed_report import get_ordered_to_be_billed_d
 def execute(filters=None):
 	columns = get_column()
 	args = get_args()
-	data = get_ordered_to_be_billed_data(args)
+	data = get_ordered_to_be_billed_data(args, filters)
 	return columns, data
 
 
@@ -76,13 +77,6 @@ def get_column():
 			"options": "Project",
 			"width": 120,
 		},
-		{
-			"label": _("Company"),
-			"fieldname": "company",
-			"fieldtype": "Link",
-			"options": "Company",
-			"width": 120,
-		},
 	]
 
 
@@ -92,5 +86,6 @@ def get_args():
 		"party": "customer",
 		"date": "posting_date",
 		"order": "name",
-		"order_by": "desc",
+		"order_by": Order.desc,
+		"reference_field": "delivery_note",
 	}

erpnext/accounts/report/financial_statements.py

@@ -630,7 +630,7 @@ def get_cost_centers_with_children(cost_centers):
 def get_columns(periodicity, period_list, accumulated_values=1, company=None, cash_flow=False):
 	columns = [
 		{
-			"fieldname": "account",
+			"fieldname": "account" if not cash_flow else "section",
 			"label": _("Account") if not cash_flow else _("Section"),
 			"fieldtype": "Link",
 			"options": "Account",

erpnext/accounts/report/general_ledger/general_ledger.js

@@ -73,6 +73,7 @@ frappe.query_reports["General Ledger"] = {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 
@@ -151,6 +152,7 @@ frappe.query_reports["General Ledger"] = {
 			fieldname: "cost_center",
 			label: __("Cost Center"),
 			fieldtype: "MultiSelectList",
+			options: "Cost Center",
 			get_data: function (txt) {
 				return frappe.db.get_link_options("Cost Center", txt, {
 					company: frappe.query_report.get_filter_value("company"),
@@ -161,6 +163,7 @@ frappe.query_reports["General Ledger"] = {
 			fieldname: "project",
 			label: __("Project"),
 			fieldtype: "MultiSelectList",
+			options: "Project",
 			get_data: function (txt) {
 				return frappe.db.get_link_options("Project", txt, {
 					company: frappe.query_report.get_filter_value("company"),

erpnext/accounts/report/general_ledger/general_ledger.py

@@ -534,6 +534,7 @@ def get_accountwise_gle(filters, accounting_dimensions, gl_entries, gle_map, tot
 					for dim in accounting_dimensions:
 						keylist.append(gle.get(dim))
 					keylist.append(gle.get("cost_center"))
+					keylist.append(gle.get("project"))
 
 				key = tuple(keylist)
 				if key not in consolidated_gle:
@@ -679,10 +680,11 @@ def get_columns(filters):
 		{"label": _("Against Account"), "fieldname": "against", "width": 120},
 		{"label": _("Party Type"), "fieldname": "party_type", "width": 100},
 		{"label": _("Party"), "fieldname": "party", "width": 100},
-		{"label": _("Project"), "options": "Project", "fieldname": "project", "width": 100},
 	]
 
 	if filters.get("include_dimensions"):
+		columns.append({"label": _("Project"), "options": "Project", "fieldname": "project", "width": 100})
+
 		for dim in get_accounting_dimensions(as_list=False):
 			columns.append(
 				{"label": _(dim.label), "options": dim.label, "fieldname": dim.fieldname, "width": 100}

erpnext/accounts/report/gross_profit/gross_profit.js

@@ -67,6 +67,7 @@ frappe.query_reports["Gross Profit"] = {
 			fieldname: "cost_center",
 			label: __("Cost Center"),
 			fieldtype: "MultiSelectList",
+			options: "Cost Center",
 			get_data: function (txt) {
 				return frappe.db.get_link_options("Cost Center", txt, {
 					company: frappe.query_report.get_filter_value("company"),
@@ -77,6 +78,7 @@ frappe.query_reports["Gross Profit"] = {
 			fieldname: "project",
 			label: __("Project"),
 			fieldtype: "MultiSelectList",
+			options: "Project",
 			get_data: function (txt) {
 				return frappe.db.get_link_options("Project", txt, {
 					company: frappe.query_report.get_filter_value("company"),

erpnext/accounts/report/gross_profit/gross_profit.json

@@ -1,5 +1,5 @@
 {
- "add_total_row": 1,
+ "add_total_row": 0,
  "columns": [],
  "creation": "2013-02-25 17:03:34",
  "disable_prepared_report": 0,
@@ -9,7 +9,7 @@
  "filters": [],
  "idx": 3,
  "is_standard": "Yes",
- "modified": "2022-02-11 10:18:36.956558",
+ "modified": "2025-01-27 18:40:24.493829",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Gross Profit",

erpnext/accounts/report/gross_profit/gross_profit.py

@@ -178,7 +178,14 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 	# removing Item Code and Item Name columns
 	del columns[4:6]
 
+	total_base_amount = 0
+	total_buying_amount = 0
+
 	for src in gross_profit_data.si_list:
+		if src.indent == 1:
+			total_base_amount += src.base_amount or 0.0
+			total_buying_amount += src.buying_amount or 0.0
+
 		row = frappe._dict()
 		row.indent = src.indent
 		row.parent_invoice = src.parent_invoice
@@ -189,17 +196,57 @@ def get_data_when_grouped_by_invoice(columns, gross_profit_data, filters, group_
 
 		data.append(row)
 
+	total_gross_profit = total_base_amount - total_buying_amount
+	data.append(
+		frappe._dict(
+			{
+				"sales_invoice": "Total",
+				"qty": None,
+				"avg._selling_rate": None,
+				"valuation_rate": None,
+				"selling_amount": total_base_amount,
+				"buying_amount": total_buying_amount,
+				"gross_profit": total_gross_profit,
+				"gross_profit_%": flt(
+					(total_gross_profit / total_base_amount) * 100.0,
+					cint(frappe.db.get_default("currency_precision")) or 3,
+				)
+				if total_base_amount
+				else 0,
+			}
+		)
+	)
+
 
 def get_data_when_not_grouped_by_invoice(gross_profit_data, filters, group_wise_columns, data):
-	for src in gross_profit_data.grouped_data:
-		row = []
-		for col in group_wise_columns.get(scrub(filters.group_by)):
-			row.append(src.get(col))
+	total_base_amount = 0
+	total_buying_amount = 0
 
-		row.append(filters.currency)
+	group_columns = group_wise_columns.get(scrub(filters.group_by))
+
+	for src in gross_profit_data.grouped_data:
+		total_base_amount += src.base_amount or 0.00
+		total_buying_amount += src.buying_amount or 0.00
+
+		row = [src.get(col) for col in group_columns] + [filters.currency]
 
 		data.append(row)
 
+	total_gross_profit = total_base_amount - total_buying_amount
+	currency_precision = cint(frappe.db.get_default("currency_precision")) or 3
+	gross_profit_percent = (total_gross_profit / total_base_amount * 100.0) if total_base_amount else 0
+
+	total_row = {
+		group_columns[0]: "Total",
+		"base_amount": total_base_amount,
+		"buying_amount": total_buying_amount,
+		"gross_profit": total_gross_profit,
+		"gross_profit_percent": flt(gross_profit_percent, currency_precision),
+	}
+
+	total_row = [total_row.get(col, None) for col in [*group_columns, "currency"]]
+	data.append(total_row)
+
 
 def get_columns(group_wise_columns, filters):
 	columns = []

erpnext/accounts/report/gross_profit/test_gross_profit.py

@@ -605,3 +605,33 @@ class TestGrossProfit(FrappeTestCase):
 		item_from_sinv2 = [x for x in data if x.parent_invoice == sinv2.name]
 		self.assertEqual(len(item_from_sinv2), 1)
 		self.assertEqual(1800, item_from_sinv2[0].valuation_rate)
+
+	def test_gross_profit_groupby_invoices(self):
+		create_sales_invoice(
+			qty=1,
+			rate=100,
+			company=self.company,
+			customer=self.customer,
+			item_code=self.item,
+			item_name=self.item,
+			cost_center=self.cost_center,
+			warehouse=self.warehouse,
+			debit_to=self.debit_to,
+			parent_cost_center=self.cost_center,
+			update_stock=0,
+			currency="INR",
+			income_account=self.income_account,
+			expense_account=self.expense_account,
+		)
+
+		filters = frappe._dict(
+			company=self.company, from_date=nowdate(), to_date=nowdate(), group_by="Invoice"
+		)
+
+		_, data = execute(filters=filters)
+		total = data[-1]
+
+		self.assertEqual(total.selling_amount, 100.0)
+		self.assertEqual(total.buying_amount, 0.0)
+		self.assertEqual(total.gross_profit, 100.0)
+		self.assertEqual(total.get("gross_profit_%"), 100.0)

erpnext/accounts/report/non_billed_report.py

@@ -4,11 +4,12 @@
 
 import frappe
 from frappe.model.meta import get_field_precision
+from frappe.query_builder.functions import IfNull, Round
 
 from erpnext import get_default_currency
 
 
-def get_ordered_to_be_billed_data(args):
+def get_ordered_to_be_billed_data(args, filters=None):
 	doctype, party = args.get("doctype"), args.get("party")
 	child_tab = doctype + " Item"
 	precision = (
@@ -18,47 +19,57 @@ def get_ordered_to_be_billed_data(args):
 		or 2
 	)
 
-	project_field = get_project_field(doctype, party)
+	doctype = frappe.qb.DocType(doctype)
+	child_doctype = frappe.qb.DocType(child_tab)
 
-	return frappe.db.sql(
-		"""
-		Select
-			`{parent_tab}`.name, `{parent_tab}`.{date_field},
-			`{parent_tab}`.{party}, `{parent_tab}`.{party}_name,
-			`{child_tab}`.item_code,
-			`{child_tab}`.base_amount,
-			(`{child_tab}`.billed_amt * ifnull(`{parent_tab}`.conversion_rate, 1)),
-			(`{child_tab}`.base_rate * ifnull(`{child_tab}`.returned_qty, 0)),
-			(`{child_tab}`.base_amount -
-			(`{child_tab}`.billed_amt * ifnull(`{parent_tab}`.conversion_rate, 1)) -
-			(`{child_tab}`.base_rate * ifnull(`{child_tab}`.returned_qty, 0))),
-			`{child_tab}`.item_name, `{child_tab}`.description,
-			{project_field}, `{parent_tab}`.company
-		from
-			`{parent_tab}`, `{child_tab}`
-		where
-			`{parent_tab}`.name = `{child_tab}`.parent and `{parent_tab}`.docstatus = 1
-			and `{parent_tab}`.status not in ('Closed', 'Completed')
-			and `{child_tab}`.amount > 0
-			and (`{child_tab}`.base_amount -
-			round(`{child_tab}`.billed_amt * ifnull(`{parent_tab}`.conversion_rate, 1), {precision}) -
-			(`{child_tab}`.base_rate * ifnull(`{child_tab}`.returned_qty, 0))) > 0
-		order by
-			`{parent_tab}`.{order} {order_by}
-		""".format(
-			parent_tab="tab" + doctype,
-			child_tab="tab" + child_tab,
-			precision=precision,
-			party=party,
-			date_field=args.get("date"),
-			project_field=project_field,
-			order=args.get("order"),
-			order_by=args.get("order_by"),
+	docname = filters.get(args.get("reference_field"), None)
+	project_field = get_project_field(doctype, child_doctype, party)
+
+	query = (
+		frappe.qb.from_(doctype)
+		.inner_join(child_doctype)
+		.on(doctype.name == child_doctype.parent)
+		.select(
+			doctype.name,
+			doctype[args.get("date")].as_("date"),
+			doctype[party],
+			doctype[party + "_name"],
+			child_doctype.item_code,
+			child_doctype.base_amount.as_("amount"),
+			(child_doctype.billed_amt * IfNull(doctype.conversion_rate, 1)).as_("billed_amount"),
+			(child_doctype.base_rate * IfNull(child_doctype.returned_qty, 0)).as_("returned_amount"),
+			(
+				child_doctype.base_amount
+				- (child_doctype.billed_amt * IfNull(doctype.conversion_rate, 1))
+				- (child_doctype.base_rate * IfNull(child_doctype.returned_qty, 0))
+			).as_("pending_amount"),
+			child_doctype.item_name,
+			child_doctype.description,
+			project_field,
 		)
+		.where(
+			(doctype.docstatus == 1)
+			& (doctype.status.notin(["Closed", "Completed"]))
+			& (doctype.company == filters.get("company"))
+			& (doctype.posting_date <= filters.get("posting_date"))
+			& (child_doctype.amount > 0)
+			& (
+				child_doctype.base_amount
+				- Round(child_doctype.billed_amt * IfNull(doctype.conversion_rate, 1), precision)
+				- (child_doctype.base_rate * IfNull(child_doctype.returned_qty, 0))
+			)
+			> 0
+		)
+		.orderby(doctype[args.get("order")], order=args.get("order_by"))
 	)
 
+	if docname:
+		query = query.where(doctype.name == docname)
 
-def get_project_field(doctype, party):
+	return query.run(as_dict=True)
+
+
+def get_project_field(doctype, child_doctype, party):
 	if party == "supplier":
-		doctype = doctype + " Item"
-	return "`tab%s`.project" % (doctype)
+		return child_doctype.project
+	return doctype.project

erpnext/accounts/report/payment_ledger/payment_ledger.js

@@ -50,6 +50,7 @@ function get_filters() {
 			fieldname: "party",
 			label: __("Party"),
 			fieldtype: "MultiSelectList",
+			options: "party_type",
 			get_data: function (txt) {
 				if (!frappe.query_report.filters) return;
 

erpnext/accounts/report/received_items_to_be_billed/received_items_to_be_billed.js

@@ -2,5 +2,27 @@
 // For license information, please see license.txt
 
 frappe.query_reports["Received Items To Be Billed"] = {
-	filters: [],
+	filters: [
+		{
+			label: __("Company"),
+			fieldname: "company",
+			fieldtype: "Link",
+			options: "Company",
+			reqd: 1,
+			default: frappe.defaults.get_default("Company"),
+		},
+		{
+			label: __("As on Date"),
+			fieldname: "posting_date",
+			fieldtype: "Date",
+			reqd: 1,
+			default: frappe.datetime.get_today(),
+		},
+		{
+			label: __("Purchase Receipt"),
+			fieldname: "purchase_receipt",
+			fieldtype: "Link",
+			options: "Purchase Receipt",
+		},
+	],
 };

erpnext/accounts/report/received_items_to_be_billed/received_items_to_be_billed.py

@@ -3,6 +3,7 @@
 
 
 from frappe import _
+from pypika import Order
 
 from erpnext.accounts.report.non_billed_report import get_ordered_to_be_billed_data
 
@@ -10,7 +11,7 @@ from erpnext.accounts.report.non_billed_report import get_ordered_to_be_billed_d
 def execute(filters=None):
 	columns = get_column()
 	args = get_args()
-	data = get_ordered_to_be_billed_data(args)
+	data = get_ordered_to_be_billed_data(args, filters)
 	return columns, data
 
 
@@ -76,13 +77,6 @@ def get_column():
 			"options": "Project",
 			"width": 120,
 		},
-		{
-			"label": _("Company"),
-			"fieldname": "company",
-			"fieldtype": "Link",
-			"options": "Company",
-			"width": 120,
-		},
 	]
 
 
@@ -92,5 +86,6 @@ def get_args():
 		"party": "supplier",
 		"date": "posting_date",
 		"order": "name",
-		"order_by": "desc",
+		"order_by": Order.desc,
+		"reference_field": "purchase_receipt",
 	}