test: reuse BootStrapTestData master data in Cash Flow report tests

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.github/POSTGRES_COMPATIBILITY.md

@@ -0,0 +1,183 @@
+# PostgreSQL compatibility — review guide
+
+ERPNext targets **both MariaDB and PostgreSQL from a single codebase**. The full server
+test suite passes on both, but the PostgreSQL CI job is **label-gated** (it does not run on
+every PR), so until it is required this guide is the always-on guard. Greptile loads it as
+review context (`.greptile/config.json`).
+
+When reviewing a PR, flag any **new or changed query** (raw `frappe.db.sql`, `frappe.qb`,
+`frappe.get_all/get_list/get_value`, report SQL) that would **error on PostgreSQL** or
+**return different results on the two engines**.
+
+## The one rule that governs everything
+
+**MariaDB behaviour must not change; PostgreSQL is brought into line with MariaDB — never the
+reverse.** A "fix" that changes the value, row count, or ordering MariaDB produced is a
+regression, even if the new behaviour looks more correct. The only accepted MariaDB-output
+change is replacing a genuinely *undefined/arbitrary* result with a deterministic one (row
+count preserved) — and that should be called out explicitly.
+
+There are two failure modes to watch for:
+1. **Hard breaks** — PostgreSQL raises an exception; MariaDB is green. Easy to catch in CI,
+   but the gated job may not run.
+2. **Silent divergences** — both engines succeed but return *different* results. CI on one
+   engine stays green; the bug only shows on a PostgreSQL site. These are the dangerous ones.
+
+---
+
+## 1. Hard breaks — would error on PostgreSQL
+
+Flag a changed query that uses any of these:
+
+- **Loose `GROUP BY`** — selecting/ordering a column that is neither in `GROUP BY` nor wrapped
+  in an aggregate. MariaDB tolerates it; PostgreSQL errors (`must appear in the GROUP BY
+  clause or be used in an aggregate function`). This **also covers an aggregate (`Sum`/`Count`/…)
+  selected alongside bare columns with NO `.groupby()` at all** — MariaDB silently collapses
+  every row into one arbitrary-valued row (often a *wrong-output* bug there too), PostgreSQL
+  errors. Fix: add the bare column to `GROUP BY` **if it is functionally dependent on the group
+  key**, otherwise wrap it in `Max()`/`Min()`. **See §3 — the row-count trap — before suggesting
+  "add it to GROUP BY".**
+- **MySQL-only functions** — `TIMESTAMP(date,time)`, `TIMEDIFF`, `STR_TO_DATE`, `DATE_FORMAT`,
+  `DATE_ADD/SUB`, `GROUP_CONCAT`, `PERIOD_DIFF`, SQL `IF(cond,a,b)`. Use the portable
+  `frappe.query_builder.functions` equivalents (`CombineDatetime`, `DateDiff`, `Case`,
+  `GroupConcat`, …) or a precomputed column (e.g. `posting_datetime`).
+- **`UPDATE … JOIN`** — not valid on PostgreSQL. Rewrite as `UPDATE … WHERE name IN (subquery)`.
+- **`HAVING` referencing a `SELECT` alias** — PostgreSQL rejects output-column aliases in
+  `HAVING` (regardless of whether the query has a `GROUP BY`; MariaDB allows them). Repeat the
+  underlying expression in `HAVING`, or move a non-aggregate predicate into `WHERE`.
+- **`SELECT DISTINCT … ORDER BY <expr not in the select list>`** — add the expr to the select.
+- **Single-quoted column alias** `AS 'x'` — PostgreSQL reads `'x'` as a string literal. Use an
+  unquoted (or double-quoted) alias.
+- **`varchar | varchar`** (bitwise OR misused as a coalesce) — errors on PostgreSQL. Use
+  `Coalesce(...)`.
+- **Capital-cased identifiers** used as column/field names in `get_value(dt, dn, "Status")`,
+  `get_all(dt, fields=["Account"])`, and similar — PostgreSQL quotes the identifier and matches
+  it case-sensitively; a stored column named `status`/`account` won't match `"Status"`/`"Account"`
+  (`column "Account" does not exist`). Use the exact stored (lower-case) fieldname.
+- **Boolean passed where an integer column is expected** — `frappe.db.set_value(dt, dn,
+  check_field, True)`, `doc.db_set(field, False)`, or `frappe.qb.update(dt).set(check_field, True)`
+  emit `SET col = true`, which PostgreSQL rejects on a `smallint`/`Check` column
+  (`column is of type smallint but expression is of type boolean`). Pass `1`/`0`.
+- **`.like()`/`.ilike()` (or raw `LIKE`) on a NON-text column** — `idx`, `docstatus`, a date, etc.
+  frappe maps `.like()` → `ILIKE`, and PostgreSQL has no `bigint ILIKE text` operator (`operator
+  does not exist: bigint ~~* unknown`). Cast the column to text first — **`Cast_(col, "varchar")`**,
+  not `Cast(col, "char")` (see below). MariaDB coerces the int implicitly, so the cast is a no-op there.
+- **`CAST(… AS CHAR)` / `Cast(x, "char")`** — on PostgreSQL bare `CHAR` is `character(1)`, so
+  `CAST(12 AS CHAR)` → `'1'` (silently truncates multi-digit values); MariaDB gives the full string.
+  Use `VARCHAR` / `Cast_(x, "varchar")`.
+- **`.rlike()` / raw `RLIKE`** — frappe rewrites `REGEXP` → `~*` on PostgreSQL but does **not**
+  translate `RLIKE` (no such PostgreSQL operator). Use `.regexp()` (or `.like()` for a simple prefix).
+- **`IfNull`/`Coalesce` of a typed column with a different-typed literal** — `IfNull(asset.disposal_date, 0)`
+  renders `COALESCE("disposal_date", 0)`, coalescing a **DATE** with an **integer**. PostgreSQL requires
+  `COALESCE` args to share a type (`DatatypeMismatch: COALESCE types date and integer cannot be matched`);
+  MariaDB's `IFNULL` is permissive. The common shape is `IfNull(date_col, 0) != 0 / == 0` as a presence test —
+  replace with `date_col.isnotnull()` / `date_col.isnull()` (identical, and valid on both). Otherwise coalesce
+  to a **same-type** default (`Coalesce(date_col, '1900-01-01')`, `Coalesce(text_col, '')`).
+- **Division by a possibly-zero divisor** — `Sum(a) / Sum(b)`, `x / col`, etc. where the
+  divisor can be `0`/empty. MariaDB returns `NULL` for division by zero; PostgreSQL raises
+  `division by zero` and aborts the query. Wrap the divisor in `NullIf(divisor, 0)` — that
+  yields `NULL` on both engines, matching MariaDB's value. (Only the *literal* `/ 0` is a parse
+  constant; the trap is a divisor that is an aggregate or column the data can drive to zero.)
+
+---
+
+## 2. Silent divergences — succeeds on both, returns different results
+
+These don't error, so a one-engine CI stays green. Flag them:
+
+- **Case sensitivity on text equality** — `==`, `.isin()`, `Strpos`/`Locate` on free-text
+  columns are case-**sensitive** on PostgreSQL but case-**insensitive** under MariaDB's default
+  collation. `Lower()` both sides. *(Not `.like()`/`["like", …]` — those already render as
+  `ILIKE` on PostgreSQL; see §4.)*
+- **Case sensitivity in a doc-`name` lookup** — lower-casing a value then using it as a
+  document name in `get_value`/`get_doc`/`exists` misses on PostgreSQL (names are
+  case-sensitive). Keep original case for the identifier; lower-case only comparison operands.
+- **Empty string vs NULL** — PostgreSQL stores a blank link/data field as `NULL` on some paths
+  while MariaDB keeps `''`; `Concat`/`Concat_ws` then diverge. Prefer the stored full value, or
+  `Coalesce(col, '')` per argument.
+- **NULL ordering** — MariaDB sorts `NULL` first, PostgreSQL sorts it last. For
+  `ORDER BY … LIMIT 1`/`[0]` on a nullable column, guard with `Coalesce`/`isnotnull()`.
+- **`ORDER BY … LIMIT 1` with no unique tiebreaker** — when rows tie on the ordered column the
+  two engines may pick different rows. Add a `creation`/`name` tiebreaker **only if it does not
+  change MariaDB's current pick** (see §4).
+- **Integer division** — `int / int` truncates on PostgreSQL but is decimal on MariaDB, e.g.
+  `COUNT(...) / COUNT(...) * 100` → `0`, or `manufacturing_time_in_mins / 1440` flooring a
+  lead-time to whole days. Force float: multiply by `100.0`, or make a literal a float
+  (`/ 1440` → `/ 1440.0`), or cast an operand. (Only SQL-level `/` on integer **columns/literals**
+  — Python `/` is already float.)
+- **`DISTINCT` list ordering** — `frappe.get_all(distinct=True, order_by=…)` /
+  `SELECT DISTINCT … ORDER BY`: frappe's `db_query` **silently drops `ORDER BY` for distinct
+  queries on PostgreSQL**, so the result is unordered there. Sort in Python instead — and use
+  `key=str.casefold`, because bare `sorted()` is case-sensitive (ASCII) while MariaDB's
+  collation is case-insensitive, so a plain sort reorders MariaDB's output.
+- **Engine-specific function rewrites** — e.g. a PostgreSQL `regexp_replace` branch
+  reimplementing MariaDB's `CAST(SUBSTRING_INDEX(name,' ',-1) AS UNSIGNED)` (leading digits of
+  the last whitespace token). Verify the rewrite matches MariaDB on edge cases (`"X - 3a"→3`,
+  `"X - 1.5"→1`) by diffing both engines on literal rows.
+- **`UnixTimestamp(date)` / date→epoch** is timezone-dependent (midnight in the DB session TZ),
+  so a strict `epoch <= now` bound is flaky on PostgreSQL.
+
+---
+
+## 3. The `GROUP BY` row-count trap (the single most important rule)
+
+When making a loose `GROUP BY` PostgreSQL-valid, **do not add a non-functionally-dependent
+column to the `GROUP BY` just to satisfy PostgreSQL** — that turns one group row into N and
+**changes the MariaDB row count** (a regression). The classic traps are adding the **child/row
+primary key** or an **editable per-row field**. Instead **`Max()`/`Min()`-wrap** the offending
+column: the row count is preserved and the value goes from arbitrary (MariaDB's old loose pick)
+to deterministic.
+
+**Judge functional dependence by the source table, not the column name:**
+- A column from a **master joined on the group key** (`t3.x` where `t1.key = t3.name`) is FD →
+  safe to keep in `GROUP BY`.
+- A descriptive field on the **transaction** table (`t1.supplier_name`, `t1.territory`,
+  `t1.item_name` — fetched/editable, can differ across historical rows for the same key) is
+  **not** FD even though it looks master-derived → `Max()`-wrap it.
+
+Conversely, do **not** suggest changing a `Max()`/`Min()`-wrapped column to `Sum()` (or vice
+versa) to make a number "more correct" — that changes the MariaDB value. The wrap reproduces
+MariaDB's prior one-value-per-group output; a different aggregate is a product change, out of
+scope for a portability fix.
+
+---
+
+## 4. False positives — do NOT flag these
+
+These are auto-handled by the framework and are **not** breaks:
+
+- **`.like()` / `["like", …]`** already renders as `ILIKE` on PostgreSQL — not a
+  case-sensitivity bug. *(Exception: `.like()` on a **non-text** column — `idx`, `docstatus` —
+  is a hard break, `bigint ILIKE`; see §1.)*
+- **Raw `ifnull(...)`** inside `frappe.db.sql()` is rewritten to `coalesce(...)` on all engines.
+- **Backticks**, **`LOCATE`**, **`REGEXP`** / **`.regexp()`** in raw SQL are auto-translated on
+  PostgreSQL (`REGEXP` → `~*`). **But `RLIKE` / `.rlike()` is NOT translated** — that one is a
+  hard break (see §1).
+- **An `ORDER BY … LIMIT 1` tie where the two engines already agree**, or where adding a
+  tiebreaker would *change* MariaDB's current pick — leave it; "fixing" it would either change
+  MariaDB or has no observable effect.
+
+---
+
+## 5. Transaction / runtime (not query-shape, still PostgreSQL-only)
+
+- **Catch-and-continue inserts** — on PostgreSQL a failed `insert()` aborts the **whole
+  transaction**, so code that swallows a duplicate and keeps going dies on the next statement
+  with `InFailedSqlTransaction` (frappe dropped its blanket per-statement savepoint in
+  frappe#40075). Such a handler must wrap the fallible insert in `frappe.db.savepoint(name)` +
+  `rollback(save_point=name)` — unless it re-`throw`s with no DB call before the throw, or the
+  insert uses `ignore_if_duplicate=True` / `autoname="hash"` (→ `ON CONFLICT DO NOTHING`).
+
+---
+
+## How to review
+
+For every changed query: does it (a) use a construct from §1 (would error on PostgreSQL), or
+(b) match a divergence in §2/§3 (different result across engines)? If so, comment with the
+portable fix and confirm it leaves **MariaDB output unchanged**. Skip the §4 false positives.
+Prefer a comment that names the rule (e.g. "loose GROUP BY — Max()-wrap, don't add to GROUP BY:
+splits the row count") so the fix is unambiguous.
+
+The static pre-commit checker (`.github/helper/postgres_compat.py`) catches the *mechanical*
+§1 breaks; the **semantic** §2/§3 divergences are exactly what a reviewer (and this guide) must
+cover, because no static check can see them.

.github/helper/hydrate.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+#
+# Hydrate a test shard from the setup job's artifact.
+#
+# The bench (apps, venv, node_modules, sites) is already on disk at ~/frappe-bench — the
+# workflow untar'd it from the artifact the setup job built. So there is NO bench init, no
+# asset build, and no reinstall here: just bring the DB up on the baked datadir and start redis
+# so tests can run. The whole point is that the expensive work happened ONCE in the setup job.
+#
+set -e
+
+ci_user="${ERPNEXT_CI_USER:-frappe}"
+db_host="${DB_HOST:-127.0.0.1}"
+
+# Re-exec as the ci user (uid 1001) so bench/cache ownership matches the artifact, same as
+# install.sh. The workflow untar'd as root with -p, so the files are already owned by ci.
+if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
+    exec su -m "$ci_user" -s /bin/bash -c \
+        "ERPNEXT_CI_USER='$ci_user' DB_HOST='$db_host' DB='${DB:-}' bash '$0'"
+fi
+
+cd ~/frappe-bench
+
+# Start the DB on the datadir baked into the artifact. It's already populated (the setup job
+# reinstalled into this very datadir), so there is NO restore — the server comes up on the
+# existing files. This is what replaces the per-shard SQL replay.
+bash ~/frappe-bench/start-db.sh
+
+# Bring up redis (lightmode unit tests need cache + queue). In the self-hosted container we use the
+# full `bench start` (web/workers too, like install.sh). On the bare GitHub Postgres shard
+# `bench start` (honcho) lagged — it blocks the redis procs behind web/worker procs the lightmode
+# suite never uses, so the wait below burned its full timeout (~4m). There, start the two redis
+# instances directly: fast and deterministic.
+if [ "${DB:-mariadb}" = "postgres" ]; then
+    # Start redis directly as daemons — reliable and persists across steps. Do NOT route it through
+    # `bench start`: honcho tears the whole process group down if any one Procfile proc dies on the
+    # bare shard, which took redis with it (redis @ 13000 refused in Run Tests). Keeping redis
+    # independent is what makes it survive. The web server (for PDF tests) is NOT started here — a
+    # backgrounded server doesn't survive into the next step; it's started inside the Run Tests step.
+    for conf in redis_cache redis_queue; do
+        [ -f ~/frappe-bench/config/$conf.conf ] && redis-server ~/frappe-bench/config/$conf.conf --daemonize yes
+    done
+else
+    bench start >> ~/frappe-bench/bench_start.log 2>&1 &
+fi
+
+# Wait for redis, failing fast instead of silently burning minutes if it never comes up.
+cfg=~/frappe-bench/sites/common_site_config.json
+if [ -f "$cfg" ]; then
+    ports=$(python - "$cfg" <<'PY'
+import json, re, sys
+try:
+    cfg = json.load(open(sys.argv[1]))
+except Exception:
+    sys.exit(0)
+for key in ("redis_cache", "redis_queue"):
+    m = re.search(r":(\d+)", str(cfg.get(key, "")))
+    if m:
+        print(m.group(1))
+PY
+)
+    for port in $ports; do
+        up=0
+        for _ in $(seq 1 60); do
+            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then exec 3>&- 3<&-; up=1; break; fi
+            sleep 1
+        done
+        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; exit 1; }
+    done
+fi
+
+echo "Hydrated: DB up on baked datadir, redis up — ready for tests."

.github/helper/install.sh

@@ -4,75 +4,360 @@ set -e
 
 cd ~ || exit
 
-sudo apt update
-sudo apt remove mysql-server mysql-client
-sudo apt install libcups2-dev redis-server mariadb-client libmariadb-dev
-
-pip install frappe-bench
-
 githubbranch=${GITHUB_BASE_REF:-${GITHUB_REF##*/}}
 frappeuser=${FRAPPE_USER:-"frappe"}
 frappecommitish=${FRAPPE_BRANCH:-$githubbranch}
+db_host=${DB_HOST:-"127.0.0.1"}
+db_user_host=${DB_USER_HOST:-"localhost"}
+wkhtmltox_deb=${WKHTMLTOX_DEB:-"/tmp/wkhtmltox.deb"}
+bench_cache_dir=${BENCH_CACHE_DIR:-}
+
+run_as_ci_user_if_needed() {
+    if [ "$(id -u)" != "0" ] || [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ] || [ "${ERPNEXT_CI_NON_ROOT:-0}" = "1" ]; then
+        return
+    fi
+
+    local missing_packages=()
+    if ! command -v pkg-config >/dev/null 2>&1; then
+        missing_packages+=("pkg-config")
+    fi
+    if ! command -v mariadb_config >/dev/null 2>&1 && ! command -v mysql_config >/dev/null 2>&1; then
+        missing_packages+=("libmariadb-dev")
+    fi
+    if ! command -v crontab >/dev/null 2>&1; then
+        missing_packages+=("cron")
+    fi
+
+    if [ "${#missing_packages[@]}" -gt 0 ]; then
+        apt-get update
+        apt-get install -y --no-install-recommends "${missing_packages[@]}"
+    fi
+
+    local ci_user="${ERPNEXT_CI_USER:-frappe}"
+
+    if ! id "$ci_user" >/dev/null 2>&1; then
+        useradd --home-dir "$HOME" --no-create-home --shell /bin/bash "$ci_user"
+    fi
+
+    rm -rf ~/frappe ~/frappe-bench
+
+    local ci_dirs=(
+        "$HOME"
+        "$GITHUB_WORKSPACE"
+        "$HOME/.cache"
+        "${PIP_CACHE_DIR:-$HOME/.cache/pip}"
+        "${npm_config_cache:-$HOME/.npm}"
+        "${YARN_CACHE_FOLDER:-$HOME/.cache/yarn}"
+        "$HOME/.yarn"
+        "${UV_CACHE_DIR:-$HOME/.cache/uv}"
+        "$(dirname "$wkhtmltox_deb")"
+    )
+    if [ -n "$bench_cache_dir" ]; then
+        ci_dirs+=("$bench_cache_dir")
+    fi
+
+    # Create + own (non-recursively) the home/cache/workspace dirs before dropping to
+    # the ci user. We deliberately do NOT wipe the yarn/uv caches here so a persistent
+    # cache (mounted volume or baked image layer) stays warm across runs.
+    mkdir -p "${ci_dirs[@]}" "$HOME/.yarn"
+    chown "$ci_user:$ci_user" "${ci_dirs[@]}" "$HOME/.yarn"
+
+    export ERPNEXT_CI_NON_ROOT=1
+    exec su -m "$ci_user" -s /bin/bash -c "cd '$HOME' && bash '$GITHUB_WORKSPACE/.github/helper/install.sh'"
+}
+
+run_as_ci_user_if_needed
+
+run_ci_step() {
+    local label=$1
+    shift
+
+    echo "::group::${label}"
+    date -u
+    local exit_code=0
+    timeout --foreground "${CI_INSTALL_STEP_TIMEOUT:-1800}" "$@" || exit_code=$?
+    date -u
+    echo "::endgroup::"
+    return "$exit_code"
+}
+
+if [ -n "${GITHUB_WORKSPACE:-}" ]; then
+    git config --global --add safe.directory "$GITHUB_WORKSPACE" || true
+    git config --global --add safe.directory "$GITHUB_WORKSPACE/.git" || true
+fi
+
+rm -rf ~/frappe ~/frappe-bench
+
+# ---------------------------------------------------------------------------
+# Phase 1 — parallelise the three slow, independent setup steps:
+#   a) system packages   b) frappe-bench pip install   c) frappe git fetch
+# ---------------------------------------------------------------------------
+
+if [ "${SKIP_SYSTEM_SETUP:-0}" != "1" ]; then
+    sudo apt-get update
+
+    # apt remove/install must run sequentially but can overlap with pip and git.
+    sudo apt-get remove -y mysql-server mysql-client
+    sudo apt-get install -y libcups2-dev redis-server mariadb-client libmariadb-dev &
+    apt_pid=$!
+
+    pip install frappe-bench &
+    pip_pid=$!
+else
+    apt_pid=
+    pip_pid=
+fi
 
 mkdir frappe
+(
+  cd frappe
+  git init
+  git remote add origin "https://github.com/${frappeuser}/frappe"
+  git fetch origin "${frappecommitish}" --depth 1
+) &
+clone_pid=$!
+
+if [ -n "$apt_pid" ]; then wait $apt_pid; fi
+if [ -n "$pip_pid" ]; then wait $pip_pid; fi
+wait $clone_pid
+
 pushd frappe
-git init
-git remote add origin "https://github.com/${frappeuser}/frappe"
-git fetch origin "${frappecommitish}" --depth 1
 git checkout FETCH_HEAD
 popd
+frappe_sha=$(git -C frappe rev-parse HEAD)
 
-bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
+get_bench_cache_archive() {
+    if [ -z "$bench_cache_dir" ]; then
+        return
+    fi
 
-mkdir ~/frappe-bench/sites/test_site
+    mkdir -p "$bench_cache_dir"
+
+    # Keyed on tool versions only (NOT the frappe SHA): any recent base bench works, because
+    # restore_warm_bench fast-forwards it to the exact live develop SHA. This is what lets a
+    # constantly-moving develop still hit the cache.
+    local cache_key
+    cache_key=$(
+        {
+            uname -m
+            python --version
+            node --version
+            bench --version
+        } | sha256sum | awk '{print $1}'
+    )
+
+    echo "${bench_cache_dir}/frappe-bench-base-${cache_key}.tar.zst"
+}
+
+restore_warm_bench() {
+    bench_cache_archive=$(get_bench_cache_archive)
+    [ -n "$bench_cache_archive" ] && [ -f "$bench_cache_archive" ] || return 1
+
+    echo "Restoring base bench from ${bench_cache_archive}"
+    tar --use-compress-program=unzstd -xf "$bench_cache_archive" -C ~ || return 1
+    [ -d ~/frappe-bench/apps/frappe/.git ] || return 1
+    mkdir -p ~/frappe-bench/sites ~/frappe-bench/logs
+    [ -f ~/frappe-bench/sites/apps.txt ] || printf "frappe\n" > ~/frappe-bench/sites/apps.txt
+    [ -f ~/frappe-bench/sites/common_site_config.json ] || printf "{}\n" > ~/frappe-bench/sites/common_site_config.json
+
+    # Fast-forward the restored frappe to the EXACT live develop SHA fetched in phase 1, then
+    # rebuild only what changed. The editable install means the venv tracks the new code with
+    # no reinstall. Any failure returns non-zero so the caller falls back to a full bench init.
+    if ! (
+        cd ~/frappe-bench/apps/frappe || exit 1
+        # Phase 1 already fetched ~/frappe to the exact live develop SHA. Fetch that commit
+        # straight from it (bench init names the remote 'upstream', not 'origin', and points
+        # it at this local clone — so a plain `git fetch origin` does not work).
+        git fetch --no-tags "$HOME/frappe" HEAD || exit 1
+        git checkout --force FETCH_HEAD || exit 1
+    ); then
+        echo "Fast-forward to ${frappe_sha} failed; falling back to full init"
+        rm -rf ~/frappe-bench
+        return 1
+    fi
+
+    # Pick up any frappe dependency changes since the base was built (cached → fast if none),
+    # so a develop commit that bumped requirements doesn't leave a stale venv.
+    if ! ~/frappe-bench/env/bin/python -m pip install -q -e ~/frappe-bench/apps/frappe; then
+        echo "frappe dependency refresh failed; falling back to full init"
+        rm -rf ~/frappe-bench
+        return 1
+    fi
+
+    ( cd ~/frappe-bench && CI=Yes bench build --app frappe ) || { rm -rf ~/frappe-bench; return 1; }
+    return 0
+}
+
+save_warm_bench() {
+    if [ -z "${bench_cache_archive:-}" ] || [ -f "$bench_cache_archive" ]; then
+        return
+    fi
+
+    if [ -n "$bench_cache_dir" ] && [ ! -w "$bench_cache_dir" ]; then
+        echo "Skipping warm bench save because ${bench_cache_dir} is not writable"
+        return
+    fi
+
+    local tmp_archive
+    tmp_archive="${bench_cache_archive}.${$}.tmp"
+
+    echo "Saving warm bench to ${bench_cache_archive}"
+    # Keep sites/common_site_config.json (the redis ports live there — dropping it makes the
+    # restore path fall back to a default redis port that bench start never bound, so reinstall
+    # fails with "redis ... connection refused"). Only the rebuildable sites/assets is excluded;
+    # restore_warm_bench runs `bench build` to regenerate it.
+    tar \
+        --use-compress-program="zstd -T0 -3" \
+        --exclude="frappe-bench/logs" \
+        --exclude="frappe-bench/sites/assets" \
+        -cf "$tmp_archive" \
+        -C ~ frappe-bench
+    mv "$tmp_archive" "$bench_cache_archive"
+}
+
+# ---------------------------------------------------------------------------
+# Phase 2 — bench init and site setup
+# ---------------------------------------------------------------------------
+
+install_whktml() {
+    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
+    if [ ! -f "$wkhtmltox_deb" ]; then
+        wget -O "$wkhtmltox_deb" https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
+    fi
+    sudo apt-get install -y "$wkhtmltox_deb"
+}
+if [ "${SKIP_WKHTMLTOX_SETUP:-0}" != "1" ]; then
+    install_whktml &
+    wkpid=$!
+else
+    wkpid=
+fi
+
+if ! restore_warm_bench; then
+    bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
+
+    cd ~/frappe-bench || exit
+
+    sed -i 's/watch:/# watch:/g' Procfile
+    sed -i 's/schedule:/# schedule:/g' Procfile
+    sed -i 's/socketio:/# socketio:/g' Procfile
+    sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
+
+    CI=Yes bench build --app frappe
+    save_warm_bench
+fi
+
+if [ -n "$wkpid" ]; then wait $wkpid; fi
+
+mkdir -p ~/frappe-bench/sites/test_site
 
 if [ "$DB" == "mariadb" ];then
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_mariadb.json" ~/frappe-bench/sites/test_site/site_config.json
+    if [ "$db_host" != "127.0.0.1" ]; then
+        sed -i "s/\"db_host\": \"127.0.0.1\"/\"db_host\": \"${db_host}\"/" ~/frappe-bench/sites/test_site/site_config.json
+    fi
 else
     cp -r "${GITHUB_WORKSPACE}/.github/helper/site_config_postgres.json" ~/frappe-bench/sites/test_site/site_config.json
 fi
 
 
 if [ "$DB" == "mariadb" ];then
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
+    for _ in {1..60}; do
+        if mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent; then
+            break
+        fi
+        sleep 1
+    done
+    mariadb-admin ping --host "$db_host" --port 3306 -u root -proot --silent
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'localhost' IDENTIFIED BY 'test_frappe'"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'localhost'"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL character_set_server = 'utf8mb4'"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL collation_server = 'utf8mb4_unicode_ci'"
 
-    mariadb --host 127.0.0.1 --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
+    # Throwaway-DB durability tuning at runtime. (innodb_doublewrite is read-only on MariaDB
+    # 10.6, so it can't be disabled here — would need a server startup flag.)
+    mariadb --host "$db_host" --port 3306 -u root -proot \
+        -e "SET GLOBAL innodb_flush_log_at_trx_commit=0; SET GLOBAL sync_binlog=0;"
+
+    # Opt-in DDL speedup: a shared tablespace avoids a create+fsync per DocType table during
+    # reinstall — a big win under disk contention. But ROW_FORMAT=DYNAMIC must be accepted in
+    # the system tablespace on this MariaDB. Enable with CI_INNODB_SHARED_TABLESPACE=1; if
+    # reinstall then errors on table creation, unset it (off by default — zero risk).
+    if [ "${CI_INNODB_SHARED_TABLESPACE:-0}" = "1" ]; then
+        mariadb --host "$db_host" --port 3306 -u root -proot -e "SET GLOBAL innodb_file_per_table=0;"
+    fi
+
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE USER 'test_frappe'@'${db_user_host}' IDENTIFIED BY 'test_frappe'"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "CREATE DATABASE test_frappe"
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "GRANT ALL PRIVILEGES ON \`test_frappe\`.* TO 'test_frappe'@'${db_user_host}'"
+
+    mariadb --host "$db_host" --port 3306 -u root -proot -e "FLUSH PRIVILEGES"
 fi
 
 if [ "$DB" == "postgres" ];then
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE DATABASE test_frappe" -U postgres;
     echo "travis" | psql -h 127.0.0.1 -p 5432 -c "CREATE USER test_frappe WITH PASSWORD 'test_frappe'" -U postgres;
+
+    # Disposable CI DB: durability off for speed (postgres fsyncs every commit by default, which
+    # dominates a commit-heavy suite). All reloadable, no restart. The postgres workflow runs a
+    # service-container DB and never calls start-db.sh, so the flags must be applied here.
+    echo "travis" | psql -h 127.0.0.1 -p 5432 -U postgres \
+        -c "ALTER SYSTEM SET synchronous_commit = 'off'" \
+        -c "ALTER SYSTEM SET fsync = 'off'" \
+        -c "ALTER SYSTEM SET full_page_writes = 'off'" \
+        -c "SELECT pg_reload_conf()";
 fi
 
-
-install_whktml() {
-    wget -O /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
-    sudo apt install /tmp/wkhtmltox.deb
-
-}
-install_whktml &
-wkpid=$!
-
-
 cd ~/frappe-bench || exit
 
-sed -i 's/watch:/# watch:/g' Procfile
-sed -i 's/schedule:/# schedule:/g' Procfile
-sed -i 's/socketio:/# socketio:/g' Procfile
-sed -i 's/redis_socketio:/# redis_socketio:/g' Procfile
+run_ci_step "Get payments app" bench get-app payments --branch develop
 
-bench get-app payments --branch develop
-bench get-app erpnext "${GITHUB_WORKSPACE}"
+# Opt-in: skip building erpnext's frontend assets. Server tests don't need them, but PDF
+# tests (print formats) do — they pass only if the PDF renderer ignores missing assets.
+# Enable with CI_SKIP_ERPNEXT_ASSETS=1 to test; if PDF tests fail, unset it.
+erpnext_get_app_args=()
+if [ "${CI_SKIP_ERPNEXT_ASSETS:-0}" = "1" ]; then erpnext_get_app_args=(--skip-assets); fi
+run_ci_step "Get erpnext app" bench get-app erpnext "${GITHUB_WORKSPACE}" "${erpnext_get_app_args[@]}"
 
-if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
+if [ "$TYPE" == "server" ]; then run_ci_step "Setup dev requirements" bench setup requirements --dev; fi
 
-wait $wkpid
+bench start >> ~/frappe-bench/bench_start.log 2>&1 &
 
-bench start &>> ~/frappe-bench/bench_start.log &
-CI=Yes bench build --app frappe &
-bench --site test_site reinstall --yes
+# Under heavy concurrency, gunicorn's startup can delay redis coming up. reinstall and the
+# tests need redis, so wait for it (best-effort, bounded) instead of racing — contention
+# then slows the job rather than failing it.
+wait_for_redis() {
+    local cfg=~/frappe-bench/sites/common_site_config.json
+    [ -f "$cfg" ] || return 0
+    local ports port
+    ports=$(python - "$cfg" <<'PY'
+import json, re, sys
+try:
+    cfg = json.load(open(sys.argv[1]))
+except Exception:
+    sys.exit(0)
+for key in ("redis_cache", "redis_queue"):
+    match = re.search(r":(\d+)", str(cfg.get(key, "")))
+    if match:
+        print(match.group(1))
+PY
+)
+    for port in $ports; do
+        local up=0
+        for _ in $(seq 1 120); do
+            if (exec 3<>"/dev/tcp/127.0.0.1/$port") 2>/dev/null; then
+                exec 3>&- 3<&-; up=1
+                break
+            fi
+            sleep 1
+        done
+        # Fail clearly instead of letting reinstall die later on a vague socket-connection error
+        # when redis never bound.
+        [ "$up" = "1" ] || { echo "redis did not come up on port $port"; return 1; }
+    done
+}
+wait_for_redis
+
+# Site setup: build the schema (~1000 DocTypes) into the DB. This is the single-threaded-Python
+# bottleneck, but the fan-out amortises it — it runs once here in the setup job, and the test
+# shards start the DB on the baked datadir instead of repeating the reinstall.
+run_ci_step "Reinstall test site" bench --site test_site reinstall --yes

.github/helper/postgres_compat.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Static guard against MySQL-only SQL that breaks on PostgreSQL.
+
+The Postgres test job is label-gated, so it does not run on every PR. This pre-commit
+hook is the always-on first line of defence: it flags the *mechanical* Postgres breaks
+that static analysis can catch reliably with a low false-positive rate.
+
+It deliberately does NOT try to catch the *semantic* divergences (loose GROUP BY,
+case-sensitive ==/IN, NULL ordering, ORDER BY ... LIMIT 1 tiebreakers, integer-division
+intent, division by a possibly-zero divisor, savepoint discipline) — those genuinely need
+the test suite or a human/Greptile reviewer. Run the full suite on a Postgres site for those.
+
+Escape hatch: put `# pg-ok` anywhere on the offending statement's line span (e.g. on a
+`SHOW INDEX` query that lives inside an `if frappe.db.db_type == "mariadb":` branch).
+
+Usage: postgres_compat.py <file.py> [<file.py> ...]   (pre-commit passes staged files)
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+import sys
+
+IGNORE = "pg-ok"
+
+# Strings are only scanned for the patterns below when they have real SQL *structure*
+# (not just an English word like "select" or "from"), to keep false positives near zero.
+SQL_HINT = re.compile(
+	r"\bselect\b[\s\S]{0,800}\bfrom\b"        # SELECT ... FROM
+	r"|\bupdate\b[\s\S]{0,400}\bset\b"         # UPDATE ... SET
+	r"|\bdelete\s+from\b"
+	r"|\binsert\s+into\b"
+	r"|\bshow\s+(?:index|tables|columns)\b"
+	r"|\bfrom\s+[\"'`]?tab",                   # FROM `tabDocType`
+	re.I,
+)
+
+# MySQL-only constructs with NO frappe auto-translation. (frappe.db.sql already rewrites
+# ifnull->coalesce on all engines and backtick/locate/REGEXP on Postgres, and .like()
+# renders ILIKE — so those are NOT listed here; flagging them would be false positives.)
+SQL_PATTERNS: list[tuple[re.Pattern, str]] = [
+	(re.compile(r"\btimestamp\s*\(\s*[^,()]+,", re.I),
+	 "timestamp(date, time) is MySQL-only -> use CombineDatetime() or a precomputed datetime column"),
+	(re.compile(r"\btimediff\s*\(", re.I),
+	 "timediff() is MySQL-only -> compute the delta in Python"),
+	(re.compile(r"\bstr_to_date\s*\(", re.I),
+	 "str_to_date() is MySQL-only -> parse in Python and pass a real date"),
+	(re.compile(r"\bdate_format\s*\(", re.I),
+	 "date_format() is MySQL-only -> filter on a date range instead"),
+	(re.compile(r"\bdate_(add|sub)\s*\(", re.I),
+	 "date_add()/date_sub() are MySQL-only -> use Python date math or interval arithmetic"),
+	(re.compile(r"\bgroup_concat\s*\(", re.I),
+	 "group_concat() is MySQL-only -> use GroupConcat (string_agg) or aggregate in Python"),
+	(re.compile(r"\bperiod_diff\s*\(", re.I),
+	 "period_diff() is MySQL-only -> compute in Python"),
+	(re.compile(r"\bshow\s+index\b", re.I),
+	 "SHOW INDEX is MySQL-only -> use frappe.db.has_index() / get_column_index()"),
+	(re.compile(r"\bshow\s+(tables|columns)\b", re.I),
+	 "SHOW TABLES/COLUMNS is MySQL-only -> use frappe.db.get_tables()/table_columns / information-schema helpers"),
+	(re.compile(r"\bas\s+'[^']+'", re.I),
+	 "single-quoted column alias breaks on Postgres -> use a bare or double-quoted alias"),
+	(re.compile(r"\bif\s*\(", re.I),
+	 "SQL IF() is MySQL-only -> use CASE WHEN ... THEN ... ELSE ... END (frappe.qb.Case())"),
+	(re.compile(r"\brlike\b", re.I),
+	 "RLIKE is MySQL-only -> frappe rewrites REGEXP->~* on Postgres but NOT RLIKE; use REGEXP / .regexp() / ~"),
+	(re.compile(r"\bcast\s*\(.+?\bas\s+char\b", re.I | re.S),  # .+? spans nested parens, e.g. CAST(ABS(x) AS CHAR)
+	 "CAST(... AS CHAR) is character(1) on Postgres and truncates -> CAST AS VARCHAR (frappe Cast_(x, 'varchar'))"),
+]
+
+# UPDATE ... JOIN: both keywords in the same SQL string.
+UPDATE_JOIN = (re.compile(r"\bupdate\b", re.I), re.compile(r"\bjoin\b", re.I))
+
+MYSQL_RESULT_KEYS = {"Column_name", "Key_name", "Seq_in_index", "Non_unique", "Index_type"}
+
+SET_BOOL_FUNCS = {"set_value", "db_set"}
+
+# query-builder cast helpers: pypika Cast / frappe Cast_. A "char" target type is character(1)
+# on Postgres (truncates); "varchar" is the full-length cast.
+CAST_FUNCS = {"Cast", "Cast_"}
+
+# frappe.get_all / get_list: frappe's db_query SILENTLY drops ORDER BY for `distinct` queries on
+# Postgres (the ORDER BY column must appear in the SELECT-DISTINCT list), so `distinct=True` together
+# with a literal `order_by` is a no-op on PG and the result comes back unordered.
+DISTINCT_ORDER_FUNCS = {"get_all", "get_list"}
+
+
+def _docstring_ids(tree: ast.AST) -> set[int]:
+	"""ids of Constant nodes that are docstrings (so prose describing the rules isn't flagged)."""
+	ids: set[int] = set()
+	for node in ast.walk(tree):
+		if isinstance(node, (ast.Module, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+			body = getattr(node, "body", None)
+			if body and isinstance(body[0], ast.Expr) and isinstance(body[0].value, ast.Constant) and isinstance(body[0].value.value, str):
+				ids.add(id(body[0].value))
+	return ids
+
+
+class Visitor(ast.NodeVisitor):
+	def __init__(self, lines: list[str], docstrings: set[int]):
+		self.lines = lines
+		self.docstrings = docstrings
+		self.violations: list[tuple[int, str]] = []
+
+	def _ignored(self, node: ast.AST) -> bool:
+		start = getattr(node, "lineno", 1)
+		end = getattr(node, "end_lineno", start) or start
+		# honour `# pg-ok` anywhere on the node's line span, the line just above (the enclosing
+		# call, e.g. `frappe.db.sql(  # pg-ok`), or the line just below (a multi-line call's `)  # pg-ok`).
+		lo = max(0, start - 2)
+		return any(IGNORE in self.lines[i] for i in range(lo, min(end + 1, len(self.lines))))
+
+	def _flag(self, node: ast.AST, msg: str) -> None:
+		if not self._ignored(node):
+			self.violations.append((getattr(node, "lineno", 1), msg))
+
+	def _scan_sql(self, text: str, node: ast.AST) -> None:
+		if not SQL_HINT.search(text):
+			return
+		for pattern, msg in SQL_PATTERNS:
+			if pattern.search(text):
+				self._flag(node, msg)
+		if UPDATE_JOIN[0].search(text) and UPDATE_JOIN[1].search(text):
+			self._flag(node, "UPDATE ... JOIN is MySQL-only -> use a correlated subquery (WHERE ... IN/EXISTS)")
+
+	def visit_Constant(self, node: ast.Constant) -> None:
+		# plain string literals, incl. `"...".format()` and `"..." % (...)` templates
+		if isinstance(node.value, str) and id(node) not in self.docstrings:
+			self._scan_sql(node.value, node)
+		self.generic_visit(node)
+
+	def visit_JoinedStr(self, node: ast.JoinedStr) -> None:
+		# f-string: scan its STATIC text (interpolated values become a placeholder) so MySQL-isms
+		# in dynamic SQL are caught, without flagging safe interpolation of identifiers.
+		text = "".join(
+			v.value if isinstance(v, ast.Constant) and isinstance(v.value, str) else " ? "
+			for v in node.values
+		)
+		self._scan_sql(text, node)
+		# don't recurse: child literal chunks would otherwise be re-scanned individually
+
+	def visit_Call(self, node: ast.Call) -> None:
+		fn = node.func
+		name = fn.attr if isinstance(fn, ast.Attribute) else (fn.id if isinstance(fn, ast.Name) else "")
+
+		# row.get("Column_name") — MySQL SHOW INDEX result key
+		if name == "get" and node.args and isinstance(node.args[0], ast.Constant) and node.args[0].value in MYSQL_RESULT_KEYS:
+			self._flag(node, f'"{node.args[0].value}" is a MySQL SHOW INDEX result key -> use frappe.db.has_index()/get_column_index()')
+
+		# set_value(..., True) / db_set("field", True) on a Check (int) column.
+		# Only the field *value* arg carries bool->smallint risk — NOT trailing flags like
+		# update_modified. db_set(field, value, update_modified, ...) -> value at args[1] (or a dict
+		# at args[0]); set_value(dt, dn, field, value, ...) -> value at args[3] (or a dict at args[2]).
+		if name in SET_BOOL_FUNCS:
+			value_idx, dict_idx = (1, 0) if name == "db_set" else (3, 2)
+			dict_arg = (
+				node.args[dict_idx]
+				if len(node.args) > dict_idx and isinstance(node.args[dict_idx], ast.Dict)
+				else None
+			)
+			if dict_arg is not None:
+				for v in dict_arg.values:
+					if isinstance(v, ast.Constant) and isinstance(v.value, bool):
+						self._flag(node, f"{name}(...) sets an int/Check column with a bool in a dict -> pass 1/0 (Postgres rejects bool->smallint)")
+			elif len(node.args) > value_idx:
+				a = node.args[value_idx]
+				if isinstance(a, ast.Constant) and isinstance(a.value, bool):
+					self._flag(node, f"{name}(..., {a.value}) sets an int/Check column with a bool -> pass 1/0 (Postgres rejects bool->smallint)")
+
+		# frappe.get_all/get_list(..., distinct=True, order_by="<col>") -> ORDER BY is silently dropped
+		# for distinct queries on Postgres, so the result is unordered there. Sort in python instead
+		# (e.g. sorted(frappe.get_all(..., distinct=True), key=str.casefold)). An empty order_by="" (the
+		# explicit "suppress the injected default" idiom) and a dynamic/variable order_by are not flagged.
+		if name in DISTINCT_ORDER_FUNCS:
+			has_distinct = any(
+				kw.arg == "distinct" and isinstance(kw.value, ast.Constant) and kw.value.value
+				for kw in node.keywords
+			)
+			order_kw = next((kw for kw in node.keywords if kw.arg == "order_by"), None)
+			has_literal_order = (
+				order_kw is not None
+				and isinstance(order_kw.value, ast.Constant)
+				and isinstance(order_kw.value.value, str)
+				and order_kw.value.value.strip()
+			)
+			if has_distinct and has_literal_order:
+				self._flag(node, f"{name}(distinct=True, order_by=...) -> frappe drops ORDER BY for distinct queries on Postgres; sort in python instead, e.g. sorted(..., key=str.casefold)")
+
+		# query-builder .rlike(...): pypika emits the MySQL-only RLIKE operator, which frappe does
+		# NOT translate for Postgres (it rewrites only REGEXP -> ~*).
+		if name == "rlike":
+			self._flag(node, ".rlike() emits MySQL-only RLIKE (not translated on Postgres) -> use .regexp() (rewritten to ~*) or .like()")
+
+		# Cast(col, "char") / Cast_(col, "char"): on Postgres a bare CHAR is character(1) and truncates
+		# (e.g. CAST(12 AS CHAR) -> '1'); use "varchar" for a full-length string cast.
+		if name in CAST_FUNCS:
+			for arg in (*node.args, *(kw.value for kw in node.keywords)):
+				if isinstance(arg, ast.Constant) and isinstance(arg.value, str) and arg.value.strip().lower() == "char":
+					self._flag(node, f"{name}(..., 'char') is character(1) on Postgres and truncates -> use 'varchar'")
+
+		self.generic_visit(node)
+
+	def visit_Subscript(self, node: ast.Subscript) -> None:
+		key = node.slice
+		if isinstance(key, ast.Constant) and key.value in MYSQL_RESULT_KEYS:
+			self._flag(node, f'"{key.value}" is a MySQL SHOW INDEX result key -> use frappe.db.has_index()/get_column_index()')
+		self.generic_visit(node)
+
+
+def check_file(path: str) -> list[str]:
+	try:
+		# nosemgrep: frappe-semgrep-rules.rules.security.frappe-security-file-traversal -- dev-only lint tool; `path` is a source file supplied by pre-commit, not user input
+		src = open(path, encoding="utf-8").read()
+	except (OSError, UnicodeDecodeError):
+		return []
+	try:
+		tree = ast.parse(src, filename=path)
+	except SyntaxError:
+		return []  # check-ast hook reports real syntax errors
+	v = Visitor(src.splitlines(), _docstring_ids(tree))
+	v.visit(tree)
+	return [f"{path}:{line}: [pg-compat] {msg}" for line, msg in sorted(set(v.violations))]
+
+
+def main(argv: list[str]) -> int:
+	out: list[str] = []
+	for path in argv:
+		if path.endswith(".py"):
+			out.extend(check_file(path))
+	if out:
+		print("\n".join(out))
+		print(
+			f"\n{len(out)} PostgreSQL-incompatibility issue(s). Fix them, or add `# pg-ok` to a "
+			"line that is intentionally MariaDB-only (e.g. inside an `if frappe.db.db_type == 'mariadb':` branch)."
+		)
+		return 1
+	return 0
+
+
+if __name__ == "__main__":
+	raise SystemExit(main(sys.argv[1:]))

.github/helper/site_config_postgres.json

@@ -13,6 +13,6 @@
  "root_login": "postgres",
  "root_password": "travis",
  "host_name": "http://test_site:8000",
- "install_apps": ["erpnext"],
+ "install_apps": ["payments", "erpnext"],
  "throttle_user_limit": 100
 }

.github/helper/start-db.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+#
+# Run MariaDB INSIDE the runner container, on a datadir we control. Because the datadir can be
+# packaged into the bench artifact, test shards start an already-loaded server instead of
+# replaying a SQL dump (the ~60s hydrate restore). Each shard gets its own copy → isolation kept.
+#
+# CI_DB_DATADIR picks the path:
+#   - setup job:  /home/ci/db-data  (OUTSIDE the bench, so install.sh's `rm -rf ~/frappe-bench`
+#                 doesn't wipe it; it's moved into the bench just before packaging)
+#   - test shard: ~/frappe-bench/mariadb-data  (where the artifact untar'd it)
+#
+# Idempotent: inits a fresh datadir if absent (setup), else starts on the existing one (shards).
+#
+set -e
+
+ci_user="${ERPNEXT_CI_USER:-frappe}"
+
+# Re-exec as the ci user so mariadbd and the datadir are owned consistently (root mariadbd is
+# refused anyway). Mirrors install.sh's user switch.
+if [ "$(id -u)" = "0" ] && [ "${SKIP_SYSTEM_SETUP:-0}" = "1" ] && [ "$ci_user" != "root" ]; then
+    exec su -m "$ci_user" -s /bin/bash -c \
+        "ERPNEXT_CI_USER='$ci_user' CI_DB_DATADIR='${CI_DB_DATADIR:-}' DB='${DB:-}' bash '$0'"
+fi
+
+# --- PostgreSQL (GitHub-hosted CI): run in-runner on a PGDATA so it bakes into the artifact,
+# same idea as the mariadb datadir. Trust auth (throwaway CI) skips password setup; durability
+# off for speed. Postgres is preinstalled on ubuntu-latest under /usr/lib/postgresql/<ver>/bin.
+if [ "${DB:-mariadb}" = "postgres" ]; then
+    PG_BIN=$(ls -d /usr/lib/postgresql/*/bin 2>/dev/null | sort -V | tail -1)
+    [ -n "$PG_BIN" ] && export PATH="$PG_BIN:$PATH"
+    PGDATA="${CI_DB_DATADIR:-$HOME/frappe-bench/pgdata}"
+    if [ ! -d "$PGDATA/base" ]; then
+        initdb -D "$PGDATA" -U postgres --auth-local=trust --auth-host=trust >/dev/null
+        echo "host all all 127.0.0.1/32 trust" >> "$PGDATA/pg_hba.conf"
+    fi
+    pg_ctl -D "$PGDATA" -w -o "-p 5432 -c listen_addresses=127.0.0.1 -c unix_socket_directories=$PGDATA -c fsync=off -c synchronous_commit=off -c full_page_writes=off" start
+    echo "PostgreSQL up in-runner (pgdata=$PGDATA)"
+    exit 0
+fi
+
+# --- MariaDB ---
+DATADIR="${CI_DB_DATADIR:-$HOME/frappe-bench/mariadb-data}"
+SOCK="$DATADIR/mysqld.sock"
+fresh=0
+
+if [ ! -d "$DATADIR/mysql" ]; then
+    mkdir -p "$DATADIR"
+    mariadb-install-db --no-defaults --datadir="$DATADIR" \
+        --auth-root-authentication-method=normal --skip-test-db >/dev/null 2>&1
+    fresh=1
+fi
+
+# Throwaway-CI durability off; bind TCP 127.0.0.1:3306 so bench/install.sh connect as usual.
+mariadbd --no-defaults --datadir="$DATADIR" --socket="$SOCK" --pid-file="$DATADIR/mysqld.pid" \
+    --port=3306 --bind-address=127.0.0.1 \
+    --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --skip-log-bin \
+    > "$HOME/mariadb.log" 2>&1 &
+
+up=0
+for _ in $(seq 1 60); do
+    if mariadb-admin --socket="$SOCK" ping --silent 2>/dev/null; then up=1; break; fi
+    sleep 1
+done
+# Fail loudly instead of letting the loop fall through (exit 0 of the last `sleep`) into SQL that
+# would error with a vague socket-connection failure.
+[ "$up" = "1" ] || { echo "mariadbd did not come up on $SOCK"; cat "$HOME/mariadb.log" 2>/dev/null; exit 1; }
+
+if [ "$fresh" = "1" ]; then
+    # A fresh datadir has only a password-less root@localhost. Give it the password install.sh
+    # uses, plus a TCP-reachable root@127.0.0.1, so the rest of install.sh works unchanged.
+    mariadb --no-defaults --socket="$SOCK" -u root <<'SQL'
+ALTER USER 'root'@'localhost' IDENTIFIED BY 'root';
+CREATE USER IF NOT EXISTS 'root'@'127.0.0.1' IDENTIFIED BY 'root';
+GRANT ALL PRIVILEGES ON *.* TO 'root'@'127.0.0.1' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+SQL
+fi
+
+echo "MariaDB up in-container (datadir=$DATADIR, fresh=$fresh)"

.github/workflows/patch.yml

@@ -65,6 +65,19 @@ jobs:
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
+      # The v14 baseline backup is a fixed published file — cache it instead of re-downloading
+      # ~100MB from frappe.io every run.
+      - name: Cache erpnext v14 backup
+        id: cache-v14
+        uses: actions/cache@v4
+        with:
+          path: ~/erpnext-v14.sql.gz
+          key: erpnext-v14-sql-gz
+
+      - name: Download erpnext v14 backup
+        if: steps.cache-v14.outputs.cache-hit != 'true'
+        run: wget -O ~/erpnext-v14.sql.gz https://frappe.io/files/erpnext-v14.sql.gz
+
       - name: Cache pip
         uses: actions/cache@v4
         with:
@@ -113,12 +126,20 @@ jobs:
           jq 'del(.install_apps)' ~/frappe-bench/sites/test_site/site_config.json > tmp.json
           mv tmp.json ~/frappe-bench/sites/test_site/site_config.json
 
-          wget https://frappe.io/files/erpnext-v14.sql.gz
-          bench --site test_site --force restore ~/frappe-bench/erpnext-v14.sql.gz
+          bench --site test_site --force restore ~/erpnext-v14.sql.gz
 
           git -C "apps/frappe" remote set-url upstream https://github.com/frappe/frappe.git
           git -C "apps/erpnext" remote set-url upstream https://github.com/frappe/erpnext.git
 
+          # Start every bench process except the background workers. If workers run during a
+          # migrate, they pick up the orphan-link cleanup jobs it enqueues and race its schema
+          # changes, which fails with MySQL 1412 "Table definition has changed". Redis and the
+          # other services stay up; the queued jobs simply wait and are harmless here.
+          function start_bench_without_workers() {
+            local procs
+            procs=$(awk -F: '/^[a-z_]+:/ && $1 !~ /worker/ {print $1}' ~/frappe-bench/Procfile)
+            honcho start -f ~/frappe-bench/Procfile $procs &>> ~/frappe-bench/bench_start.log &
+          }
 
           function update_to_version() {
             version=$1
@@ -134,10 +155,11 @@ jobs:
 
             # Resetup env and install apps
             pgrep honcho | xargs kill
+            sleep 10
             rm -rf ~/frappe-bench/env
             bench -v setup env --python python$2
             bench pip install -e ./apps/erpnext
-            bench start &>> ~/frappe-bench/bench_start.log &
+            start_bench_without_workers
 
             bench --site test_site migrate
           }
@@ -154,7 +176,7 @@ jobs:
           rm -rf ~/frappe-bench/env
           bench -v setup env
           bench pip install -e ./apps/erpnext
-          bench start &>> ~/frappe-bench/bench_start.log &
+          start_bench_without_workers
 
           bench --site test_site migrate
 

.github/workflows/review-translation-changes.yaml

@@ -0,0 +1,25 @@
+name: Review translation PRs
+description: "Posts review comments with relevant translation changes that are hard to inspect in the diff view."
+
+on:
+  pull_request_target:
+    types: [opened, reopened, synchronize, ready_for_review]
+    paths:
+      - "**/*.po"
+      - "**/*.pot"
+
+concurrency:
+  group: po-review-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  review-po-pr:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write
+      pull-requests: write
+
+    steps:
+      - uses: alyf-de/po-review-action@v1.1.0

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

@@ -31,47 +31,49 @@ on:
 
 permissions:
   contents: read
+  packages: read
 
 concurrency:
   group: server-mariadb-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
   cancel-in-progress: true
 
+# Shared across both jobs. Both run in the SAME CI image so the bench lives at the identical
+# path (/home/ci/frappe-bench) on the setup runner and the test shards — that's what makes the
+# packaged Python venv portable between them.
+env:
+  TZ: 'Asia/Kolkata'
+  DEBIAN_FRONTEND: noninteractive
+  NODE_ENV: "production"
+  WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
+  ERPNEXT_CI_USER: ci
+  PIP_CACHE_DIR: /home/ci/.cache/pip
+  npm_config_cache: /home/ci/.cache/npm
+  YARN_CACHE_FOLDER: /home/ci/.cache/yarn
+  UV_CACHE_DIR: /home/ci/.cache/uv
+
 jobs:
-  test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    env:
-      TZ: 'Asia/Kolkata'
-      NODE_ENV: "production"
-      WITH_COVERAGE: ${{ github.event_name != 'pull_request' }}
-
-    strategy:
-      fail-fast: false
-
-      matrix:
-        container: [1, 2, 3, 4]
-
-    name: Python Unit Tests
-
-    services:
-      mysql:
-        image: mariadb:10.6
-        env:
-          TZ: 'Asia/Kolkata'
-          MARIADB_ROOT_PASSWORD: 'root'
-        ports:
-          - 3306:3306
-        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
-
+  # Build the bench (clone + pip + yarn + assets) and reinstall test_site ONCE, on a free
+  # GitHub-hosted runner, then publish the whole bench (with a DB dump baked in) as an artifact.
+  # The expensive, non-parallelisable work happens here exactly once instead of on every shard.
+  setup:
+    name: Build & reinstall (setup)
+    # Dedicated scale set (fat cpu request) so the build+reinstall runs at full speed, uncontended
+    # by the many thin test shards. Same CI image + /home/ci path + 127.0.0.1 DB as the shards,
+    # so the packaged bench (and its venv) transplants cleanly.
+    runs-on: erpnext-arc-setup
+    timeout-minutes: 40
+    container:
+      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
+      credentials:
+        username: ${{ secrets.GHCR_USERNAME || github.actor }}
+        password: ${{ secrets.GHCR_TOKEN || github.token }}
+    defaults:
+      run:
+        shell: bash
     steps:
       - name: Clone
         uses: actions/checkout@v6
 
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: '3.14'
-
       - name: Check for valid Python & Merge Conflicts
         run: |
           python -m compileall -fq "${GITHUB_WORKSPACE}"
@@ -80,47 +82,17 @@ jobs:
               exit 1
           fi
 
-      - name: Setup Node
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          check-latest: true
-
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      - name: Cache pip
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
-            ${{ runner.os }}-
-
-      - name: Cache node modules
-        uses: actions/cache@v4
+      # MariaDB runs in-container on a datadir OUTSIDE the bench, because install.sh's next step
+      # does `rm -rf ~/frappe-bench`. After the reinstall, the datadir is moved into the bench so
+      # it ships in the artifact — test shards then start an already-loaded server (no restore).
+      - name: Start DB
+        run: bash ${GITHUB_WORKSPACE}/.github/helper/start-db.sh
         env:
-          cache-name: cache-node-modules
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
-
-      - uses: actions/cache@v4
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          SKIP_SYSTEM_SETUP: "1"
+          CI_DB_DATADIR: /home/ci/db-data
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
@@ -129,26 +101,107 @@ jobs:
           TYPE: server
           FRAPPE_USER: ${{ github.event.inputs.user }}
           FRAPPE_BRANCH: ${{ github.event.client_payload.sha || github.event.inputs.branch }}
+          DB_HOST: 127.0.0.1
+          DB_USER_HOST: '%'
+          WKHTMLTOX_DEB: /tmp/wkhtmltox.deb
+          SKIP_SYSTEM_SETUP: "1"
+          SKIP_WKHTMLTOX_SETUP: "1"
+
+      # Clean shutdown (consistent InnoDB datadir), then stage it inside the bench for packaging.
+      - name: Stop DB and stage datadir
+        run: |
+          mariadb-admin -h 127.0.0.1 -P 3306 -u root -proot shutdown || true
+          for _ in $(seq 1 30); do [ -f /home/ci/db-data/mysqld.pid ] || break; sleep 1; done
+          # Don't bake a dirty datadir — fail if mariadbd didn't finish stopping, rather than ship
+          # an inconsistent datadir the shards would have to crash-recover.
+          [ -f /home/ci/db-data/mysqld.pid ] && { echo "mariadbd did not shut down cleanly"; exit 1; }
+          mv /home/ci/db-data /home/ci/frappe-bench/mariadb-data
+
+      # Package the whole bench (apps, venv, node_modules, sites, the DB dump, and hydrate.sh)
+      # into one artifact for the test shards to consume.
+      # Single-node hand-off: stage the bench on a node-local hostPath instead of round-tripping
+      # through GitHub artifact storage (~60s/shard). Setup and shards share the same disk, so
+      # the shards just untar it locally. NOTE: this assumes one node — a shard on a different
+      # node could not read this path (then you'd need GitHub artifacts or an NFS/RWX volume).
+      - name: Stage bench on node (hostPath)
+        run: |
+          cp "${GITHUB_WORKSPACE}/.github/helper/hydrate.sh" /home/ci/frappe-bench/hydrate.sh
+          cp "${GITHUB_WORKSPACE}/.github/helper/start-db.sh" /home/ci/frappe-bench/start-db.sh
+          mkdir -p /opt/ci-bench-staging
+          # self-clean: drop bench tars from runs older than 2h
+          find /opt/ci-bench-staging -maxdepth 1 -name '*.tar.gz' -mmin +120 -delete 2>/dev/null || true
+          # Exclude .git/node_modules; the mariadb-data datadir IS included (the pre-loaded DB).
+          tar czpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci \
+            --exclude='.git' --exclude='node_modules' frappe-bench
+          ls -lh "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz"
+
+  # Fan-out: each shard downloads the bench, untars it, starts MariaDB on the baked datadir, and
+  # runs its slice of the suite. No clone, no build, no reinstall, no DB dump restore on the shards.
+  test:
+    name: Python Unit Tests
+    needs: setup
+    runs-on: erpnext-arc
+    timeout-minutes: 60
+    container:
+      image: ghcr.io/frappe/erpnext-ci-mariadb:py3.14-node24
+      credentials:
+        username: ${{ secrets.GHCR_USERNAME || github.actor }}
+        password: ${{ secrets.GHCR_TOKEN || github.token }}
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        container: [1, 2, 3, 4]
+
+    steps:
+      - name: Add to Hosts
+        run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
+
+      # Read the bench straight from the node-local hostPath the setup job staged it on — no
+      # GitHub download. -p preserves the ci (uid 1001) ownership so bench runs as ci cleanly.
+      - name: Untar bench from node (hostPath)
+        run: |
+          tar xzpf "/opt/ci-bench-staging/${GITHUB_RUN_ID}.tar.gz" -C /home/ci
+          ls -ld /home/ci/frappe-bench
+
+      - name: Hydrate (start DB on baked datadir + bench start)
+        run: bash /home/ci/frappe-bench/hydrate.sh
+        env:
+          DB_HOST: 127.0.0.1
+          SKIP_SYSTEM_SETUP: "1"
 
       - name: Run Tests
-        run: 'cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --lightmode --app erpnext --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }} --with-coverage'
+        run: |
+          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
+          cd ~/frappe-bench/
+          coverage_flag=""
+          if [ "$WITH_COVERAGE" = "true" ]; then coverage_flag="--with-coverage"; fi
+          bench --site test_site run-parallel-tests --lightmode --app erpnext \
+            --total-builds ${{ strategy.job-total }} \
+            --build-number ${{ matrix.container }} \
+            $coverage_flag
+          EOF
         env:
           TYPE: server
 
-
       - name: Show bench output
         if: ${{ always() }}
         run: cat ~/frappe-bench/bench_start.log || true
 
       - name: Upload coverage data
+        if: ${{ env.WITH_COVERAGE == 'true' }}
         uses: actions/upload-artifact@v4
         with:
           name: coverage-${{ matrix.container }}
-          path: /home/runner/frappe-bench/sites/coverage.xml
+          path: /home/ci/frappe-bench/sites/coverage.xml
 
   coverage:
     name: Coverage Wrap Up
-    needs: test
+    needs: [test]
+    if: ${{ github.event_name != 'pull_request' }}
     runs-on: ubuntu-latest
     steps:
       - name: Clone

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

@@ -1,7 +1,12 @@
 name: Server (Postgres)
 
 on:
+  schedule:
+    # 03:00 AM IST daily (21:30 UTC the previous day)
+    - cron: "30 21 * * *"
   pull_request:
+    # 'labeled' so adding the 'postgres' label to an already-open PR re-triggers the run.
+    types: [opened, reopened, synchronize, labeled]
     paths-ignore:
       - '**.js'
       - '**.md'
@@ -9,7 +14,7 @@ on:
       - 'crowdin.yml'
       - '.coderabbit.yml'
       - '.mergify.yml'
-    types: [opened, labelled, synchronize, reopened]
+  workflow_dispatch:
 
 concurrency:
   group: server-postgres-develop-${{ github.event_name }}-${{ github.event.number || github.event_name == 'workflow_dispatch' && github.run_id || '' }}
@@ -18,41 +23,31 @@ concurrency:
 permissions:
   contents: read
 
+# Postgres CI stays on GitHub-hosted (free, full-speed VM per shard) but follows the same fan-out
+# we built for MariaDB: build the bench + reinstall ONCE in the setup job, bake the PostgreSQL
+# PGDATA into the artifact, and have 4 test shards start Postgres on that datadir — no per-shard
+# clone/build/reinstall/restore. Python is pinned so the venv transplants between VMs.
+env:
+  TZ: 'Asia/Kolkata'
+  NODE_ENV: "production"
+  PYTHON_VERSION: '3.14'
+
 jobs:
-  test:
-    if: ${{ contains(github.event.pull_request.labels.*.name, 'postgres') }}
+  setup:
+    name: Build & reinstall (setup)
     runs-on: ubuntu-latest
-    timeout-minutes: 60
-
-    strategy:
-      fail-fast: false
-      matrix:
-       container: [1]
-
-    name: Python Unit Tests
-
-    services:
-      postgres:
-        image: postgres:13.3
-        env:
-          POSTGRES_PASSWORD: travis
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          - 5432:5432
-
+    # Runs on the daily schedule (and workflow_dispatch). On PRs it runs ONLY when the PR carries
+    # the 'postgres' label — the test job needs setup, so it's skipped too when this is.
+    if: github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'postgres')
+    timeout-minutes: 40
     steps:
-
       - name: Clone
         uses: actions/checkout@v6
 
       - name: Setup Python
         uses: actions/setup-python@v6
         with:
-          python-version: '3.14'
+          python-version: ${{ env.PYTHON_VERSION }}
 
       - name: Check for valid Python & Merge Conflicts
         run: |
@@ -71,48 +66,124 @@ jobs:
       - name: Add to Hosts
         run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
 
-      - name: Cache pip
+      - name: Cache deps (uv/pip/npm/yarn)
         uses: actions/cache@v4
         with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-pip-
-            ${{ runner.os }}-
+          path: |
+            ~/.cache/uv
+            ~/.cache/pip
+            ~/.npm
+            ~/.cache/yarn
+          key: ${{ runner.os }}-deps-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml', '**/yarn.lock') }}
+          restore-keys: ${{ runner.os }}-deps-
 
-      - name: Cache node modules
+      # Warm-bench cache (the big one): install.sh saves the built base bench — frappe + env +
+      # node_modules + assets — here as frappe-bench-base-*.tar.zst. Later runs restore it and only
+      # fast-forward to the live develop SHA + rebuild the delta, so the bench BUILD is near-free and
+      # only the test_site reinstall (per-run DB, uncacheable) stays slow — matching the self-hosted
+      # box. The first run after a deps change populates it; every run after that is fast.
+      - name: Cache warm bench (base build)
         uses: actions/cache@v4
+        with:
+          path: ~/bench-cache
+          key: ${{ runner.os }}-warmbench-v2-${{ hashFiles('**/*requirements.txt', '**/pyproject.toml', '**/yarn.lock') }}
+          restore-keys: ${{ runner.os }}-warmbench-v2-
+
+      # Postgres runs in-runner on a PGDATA OUTSIDE the bench (install.sh wipes ~/frappe-bench);
+      # after the reinstall it's moved into the bench so it ships in the artifact.
+      - name: Start DB
+        run: bash ${GITHUB_WORKSPACE}/.github/helper/start-db.sh
         env:
-          cache-name: cache-node-modules
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
-
-      - uses: actions/cache@v4
-        id: yarn-cache
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
+          DB: postgres
+          CI_DB_DATADIR: /home/runner/pgdata
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
         env:
           DB: postgres
           TYPE: server
+          FRAPPE_BRANCH: develop
+          BENCH_CACHE_DIR: /home/runner/bench-cache
+
+      - name: Stop DB and stage datadir
+        run: |
+          PG_BIN=$(ls -d /usr/lib/postgresql/*/bin | sort -V | tail -1)
+          "$PG_BIN/pg_ctl" -D /home/runner/pgdata -m fast -w stop || true
+          mv /home/runner/pgdata /home/runner/frappe-bench/pgdata
+
+      - name: Package bench for test shards
+        run: |
+          cp "${GITHUB_WORKSPACE}/.github/helper/hydrate.sh" /home/runner/frappe-bench/hydrate.sh
+          cp "${GITHUB_WORKSPACE}/.github/helper/start-db.sh" /home/runner/frappe-bench/start-db.sh
+          tar czpf "${GITHUB_WORKSPACE}/bench.tar.gz" -C /home/runner \
+            --exclude='.git' --exclude='node_modules' frappe-bench
+          ls -lh "${GITHUB_WORKSPACE}/bench.tar.gz"
+
+      - name: Upload bench artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: bench-pg
+          path: bench.tar.gz
+          retention-days: 1
+          compression-level: 0
+
+  test:
+    name: Python Unit Tests (PG)
+    needs: setup
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        container: [1, 2, 3, 4]
+    steps:
+      - name: Download bench artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: bench-pg
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Add to Hosts
+        run: echo "127.0.0.1 test_site" | sudo tee -a /etc/hosts
+
+      # The bench CLI (frappe-bench) and redis are global/system tools — not in the bench tarball.
+      # The setup runner got them via install.sh; the MariaDB shards get them from the arc5 image.
+      # GitHub-hosted PG shards install them here (cheap vs the build+reinstall that setup did once).
+      - name: Install shard runtime (bench CLI + redis + wkhtmltopdf)
+        run: |
+          pip install frappe-bench
+          command -v redis-server >/dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq redis-server; }
+          # wkhtmltopdf (patched-qt build) for print-format / PDF tests — same .deb install.sh uses.
+          if ! command -v wkhtmltopdf >/dev/null; then
+            wget -qO /tmp/wkhtmltox.deb https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
+            sudo apt-get install -y -qq /tmp/wkhtmltox.deb
+          fi
+
+      - name: Untar bench
+        run: |
+          tar xzpf "${GITHUB_WORKSPACE}/bench.tar.gz" -C /home/runner
+          ls -ld /home/runner/frappe-bench
+
+      - name: Hydrate (start Postgres on the baked datadir)
+        run: bash /home/runner/frappe-bench/hydrate.sh
+        env:
+          DB: postgres
+          DB_HOST: 127.0.0.1
 
       - name: Run Tests
-        run: cd ~/frappe-bench/ && bench --site test_site run-parallel-tests --app erpnext --use-orchestrator
+        run: |
+          cd ~/frappe-bench/
+          # print-format / PDF tests are engine-independent (they exercise wkhtmltopdf rendering,
+          # not postgres SQL — the MariaDB CI already covers them). They only fetch the static asset
+          # bundles from http://test_site:8000/assets/..., so a plain static file server over sites/
+          # satisfies wkhtmltopdf without the frappe web server (which never bound on a bare runner).
+          ( cd ~/frappe-bench/sites && nohup python3 -m http.server 8000 --bind 127.0.0.1 > ~/frappe-bench/web.log 2>&1 & )
+          for _ in $(seq 1 15); do (exec 3<>/dev/tcp/127.0.0.1/8000) 2>/dev/null && { exec 3>&- 3<&-; break; }; sleep 1; done
+          bench --site test_site run-parallel-tests --lightmode --app erpnext \
+            --total-builds ${{ strategy.job-total }} --build-number ${{ matrix.container }}
         env:
           TYPE: server
-          CI_BUILD_ID: ${{ github.run_id }}
-          ORCHESTRATOR_URL: http://test-orchestrator.frappe.io

.github/workflows/sync-hotfix-translations.yml

@@ -16,6 +16,10 @@ on:
     - cron: "0 10 * * 1"
   workflow_dispatch:
 
+# The runner dispatch uses RELEASE_TOKEN (a PAT), not the default GITHUB_TOKEN,
+# so no GITHUB_TOKEN permissions are required.
+permissions: {}
+
 jobs:
   trigger-runners:
     name: Trigger sync → ${{ matrix.hotfix_branch }}

.pre-commit-config.yaml

@@ -66,6 +66,18 @@ repos:
       - id: ruff-format
         name: "Run ruff formatter"
 
+  - repo: local
+    hooks:
+      - id: postgres-compat
+        name: "PostgreSQL compatibility (static check)"
+        description: "Flags MySQL-only SQL that breaks on Postgres; the label-gated PG test job is the backstop for semantic divergences."
+        entry: .github/helper/postgres_compat.py
+        language: script
+        files: ^erpnext/.*\.py$
+        # patches/ are historical, version-gated migrations (skipped on fresh Postgres installs);
+        # out of scope for the always-on gate.
+        exclude: ^erpnext/patches/
+
 ci:
     autoupdate_schedule: weekly
     skip: []

banking/package.json

@@ -48,7 +48,7 @@
     "tailwindcss": "^4.3.0",
     "tw-animate-css": "^1.4.0",
     "usehooks-ts": "^3.1.1",
-    "vite": "^8.0.11"
+    "vite": "^8.0.16"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",

banking/src/components/features/BankReconciliation/BankBalance.tsx

@@ -250,7 +250,7 @@ const ClosingBalanceForm = ({ defaultBalance, date, bankAccount, onClose }: { de
                     {_("Enter the closing balance you see in your bank statement for {0} as of the {1}", [bankAccount?.account_name ?? bankAccount?.name ?? '', formatDate(date, 'Do MMM YYYY')])}
                 </DialogDescription>
             </DialogHeader>
-            {error && <ErrorBanner error={error} />}
+            {error && <div className="py-2"><ErrorBanner error={error} /></div>}
             <div className="py-4">
                 <CurrencyFormField
                     name="balance"

banking/src/components/features/BankStatementImporter/CSV/CSVImport.tsx

@@ -2,9 +2,7 @@ import CSVRawDataPreview from './CSVRawDataPreview'
 import StatementDetails from './StatementDetails'
 import { GetStatementDetailsResponse } from '../import_utils'
 
-const CSVImport = ({ data }: { data: { message: GetStatementDetailsResponse } }) => {
-
-
+const CSVImport = ({ data, mutate }: { data: { message: GetStatementDetailsResponse }, mutate: () => void }) => {
 
     return (
         <div className="w-full flex">
@@ -12,7 +10,7 @@ const CSVImport = ({ data }: { data: { message: GetStatementDetailsResponse } })
                 <StatementDetails data={data.message} />
             </div>
             <div className="w-[50%] border-s border-t pe-1 ps-0 border-outline-gray-2 h-[calc(100vh-72px)] overflow-scroll">
-                <CSVRawDataPreview data={data.message} />
+                <CSVRawDataPreview data={data.message} mutate={mutate} />
             </div>
         </div>
     )

banking/src/components/features/BankStatementImporter/CSV/CSVRawDataPreview.tsx

@@ -1,151 +1,104 @@
-import { Table, TableBody, TableCell, TableHead, TableRow } from "@/components/ui/table"
-import { cn } from "@/lib/utils"
-import { ArrowDownRightIcon, ArrowUpDownIcon, ArrowUpRightIcon, BanknoteIcon, CalendarIcon, DollarSignIcon, FileTextIcon, ListIcon, ReceiptIcon } from "lucide-react"
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
+import { useEffect, useRef, useState } from "react"
+import { toast } from "sonner"
 import _ from "@/lib/translate"
-import { GetStatementDetailsResponse } from "../import_utils"
-import { useMemo } from "react"
+import RawTableGrid from "../RawTableGrid"
+import {
+    applyColumnMappingChange,
+    ColumnMapsTo,
+    GetStatementDetailsResponse,
+    useSetHeaderIndex,
+    useUpdateColumnMapping,
+} from "../import_utils"
 import { BankStatementImportLogColumnMap } from "@/types/Accounts/BankStatementImportLogColumnMap"
 
+type Mapping = Pick<BankStatementImportLogColumnMap, "index" | "maps_to" | "header_text" | "variable">
 
-const CSVRawDataPreview = ({ data }: { data: GetStatementDetailsResponse }) => {
+const toMapping = (columns?: BankStatementImportLogColumnMap[]): Mapping[] =>
+    (columns ?? []).map((c) => ({
+        index: c.index,
+        maps_to: c.maps_to,
+        header_text: c.header_text,
+        variable: c.variable,
+    }))
 
-    const column_mapping: Record<StandardColumnTypes, number> = useMemo(() => {
+const headerToState = (index?: number) => (index != null && index >= 0 ? index : null)
 
-        const col_map: Record<string, number> = {}
+const CSVRawDataPreview = ({
+    data,
+    mutate,
+}: {
+    data: GetStatementDetailsResponse
+    mutate: () => void
+}) => {
+    const isCompleted = data.doc.status === "Completed"
 
-        data.doc.column_mapping?.forEach(col => {
-            if (col.maps_to && col.maps_to !== "Do not import") {
-                col_map[col.maps_to] = col.index;
-            }
-        })
+    const [mapping, setMapping] = useState<Mapping[]>(() => toMapping(data.doc.column_mapping))
+    const [headerIndex, setHeaderIndex] = useState<number | null>(() =>
+        headerToState(data.doc.detected_header_index),
+    )
 
-        return col_map
+    const { call: updateMapping, loading: savingMapping } = useUpdateColumnMapping()
+    const { call: setHeader, loading: savingHeader } = useSetHeaderIndex()
 
-    }, [data])
+    const mappingRef = useRef(mapping)
+    const saveTimer = useRef<ReturnType<typeof setTimeout>>(undefined)
 
-    const validColumns = Object.values(column_mapping)
+    useEffect(() => () => clearTimeout(saveTimer.current), [])
 
-    // Reverse the column mapping to get a map of column index to variable name
-    const columnIndexMap: Record<number, StandardColumnTypes> = Object.fromEntries(Object.entries(column_mapping).map(([variable, columnIndex]) => [columnIndex, variable as StandardColumnTypes]))
+    const columnMappingRecord: Record<number, ColumnMapsTo> = {}
+    mapping.forEach((c) => {
+        if (c.maps_to) columnMappingRecord[c.index] = c.maps_to as ColumnMapsTo
+    })
+
+    const commitMapping = (next: Mapping[]) => {
+        mappingRef.current = next
+        setMapping(next)
+    }
+
+    // Persist mapping edits (debounced) so the transaction preview updates in realtime.
+    const scheduleSaveMapping = () => {
+        if (isCompleted) return
+        clearTimeout(saveTimer.current)
+        saveTimer.current = setTimeout(() => {
+            updateMapping({ statement_import_id: data.doc.name, column_mapping: mappingRef.current })
+                .then(() => mutate())
+                .catch(() => toast.error(_("Could not save the column mapping.")))
+        }, 500)
+    }
+
+    const onChangeMapping = (columnIndex: number, mapsTo: ColumnMapsTo) => {
+        if (isCompleted) return
+        commitMapping(applyColumnMappingChange(mappingRef.current, columnIndex, mapsTo))
+        scheduleSaveMapping()
+    }
+
+    const onSetHeader = (rowIndex: number | null) => {
+        if (isCompleted) return
+        setHeaderIndex(rowIndex)
+        setHeader({ statement_import_id: data.doc.name, header_index: rowIndex ?? -1 })
+            .then((res) => {
+                // The backend re-derives the mapping for the new header; sync local state.
+                const doc = res?.message?.doc
+                if (doc) {
+                    commitMapping(toMapping(doc.column_mapping))
+                    setHeaderIndex(headerToState(doc.detected_header_index))
+                }
+                mutate()
+            })
+            .catch(() => toast.error(_("Could not update the header row.")))
+    }
 
-    // Loop over the contents of the CSV file and show a preview - highlight the header row and the transaction rows
     return (
-        <Table containerClassName="rounded-none">
-            <TableBody>
-                {data.raw_data.map((row, index) => {
-
-                    const isHeaderRow = index === data.doc.detected_header_index;
-                    const isTransactionRow = index >= (data.doc.detected_transaction_starting_index ?? 0) && index <= (data.doc.detected_transaction_ending_index ?? 0);
-
-                    return <TableRow key={index}
-                        title={isHeaderRow ? "Header Row" : ""}
-                        className={cn({
-                            // "bg-yellow-100": isHeaderRow,
-                            // "hover:bg-yellow-100": isHeaderRow,
-                            "bg-green-50 hover:bg-green-50 dark:bg-green-700 dark:hover:bg-green-700": isTransactionRow,
-                            "text-ink-gray-5/70": !isTransactionRow && !isHeaderRow,
-                        })}>
-                        {isHeaderRow ? <TableHead className="bg-yellow-100 hover:bg-yellow-100 dark:bg-yellow-400 text-center font-semibold text-ink-gray-8">
-                            {index + 1}
-                        </TableHead> :
-                            <TableCell className="text-center px-1 py-0.5">
-                                {index + 1}
-                            </TableCell>
-                        }
-                        {row.map((cell, cellIndex) => {
-
-                            const isValidColumn = validColumns.includes(cellIndex);
-                            const columnType = columnIndexMap[cellIndex];
-                            const isAmountColumn = ["Amount", "Withdrawal", "Deposit", "Balance"].includes(columnType);
-
-                            if (isHeaderRow) {
-                                return <TableHead key={cellIndex} className={cn("max-w-[250px] w-fit overflow-hidden text-ellipsis py-0.5",
-                                    isValidColumn ? "bg-yellow-100 hover:bg-yellow-100 dark:bg-yellow-400" : "bg-surface-gray-2",
-                                )}>
-                                    <div className={cn("flex items-center text-xs gap-1 px-1 text-ink-gray-8 font-medium", {
-                                        "justify-end": isAmountColumn && isValidColumn
-                                    })}>
-                                        {columnType && <Tooltip>
-                                            <TooltipTrigger>
-                                                <ColumnHeaderIcon columnType={columnType} />
-                                            </TooltipTrigger>
-                                            <TooltipContent>
-                                                {_(columnType)}
-                                            </TooltipContent>
-                                        </Tooltip>
-                                        }
-                                        {cell}
-                                    </div>
-                                </TableHead>
-                            } else {
-                                return <TableCell key={cellIndex} className={cn("max-w-[200px] w-fit overflow-hidden text-ellipsis py-0.5",
-                                    {
-                                        "bg-green-100 dark:bg-green-400 hover:bg-green-100 dark:hover:bg-green-400": isValidColumn && isTransactionRow,
-                                        "text-ink-gray-5": !isValidColumn && isTransactionRow,
-                                    }
-                                )} >
-                                    <div className={cn("min-h-5 flex items-center text-xs px-1", {
-                                        "justify-end": isAmountColumn && isValidColumn && isTransactionRow
-                                    })} title={cell}>
-                                        {cell}
-                                    </div>
-                                </TableCell>
-                            }
-                        }
-
-                        )}
-                    </TableRow>
-                })}
-            </TableBody>
-        </Table >
+        <RawTableGrid
+            rows={data.raw_data}
+            columnMapping={columnMappingRecord}
+            headerIndex={headerIndex}
+            editable={!isCompleted}
+            disabled={isCompleted || savingMapping || savingHeader}
+            onChangeMapping={onChangeMapping}
+            onSetHeader={onSetHeader}
+        />
     )
 }
 
-type StandardColumnTypes = BankStatementImportLogColumnMap['maps_to'];
-
-const ColumnHeaderIcon = ({ columnType }: { columnType?: StandardColumnTypes }) => {
-    if (!columnType) {
-        return null
-    }
-
-    if (columnType === 'Amount') {
-        return <DollarSignIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Withdrawal') {
-        return <ArrowUpRightIcon className="w-4 h-4 text-ink-red-3" />
-    }
-
-    if (columnType === 'Deposit') {
-        return <ArrowDownRightIcon className="w-4 h-4 text-ink-green-3" />
-    }
-
-    if (columnType === 'Balance') {
-        return <BanknoteIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Date') {
-        return <CalendarIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Description') {
-        return <FileTextIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Reference') {
-        return <ReceiptIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Transaction Type') {
-        return <ListIcon className="w-4 h-4" />
-    }
-
-    if (columnType === 'Debit/Credit') {
-        return <ArrowUpDownIcon className="w-4 h-4" />
-    }
-
-    return null
-}
-
-export default CSVRawDataPreview
+export default CSVRawDataPreview

banking/src/components/features/BankStatementImporter/CSV/StatementDetails.tsx

@@ -142,11 +142,16 @@ const StatementDetails = ({ data }: Props) => {
                             <TableCell>
                                 <div className='flex items-center gap-2'>
                                     <BankLogo bank={bank} />
-                                    <span className="tracking-tight text-sm font-medium">{bank?.account_name}</span>
-                                    <span title="GL Account" className="text-sm">{bank?.account}</span>
+                                    <span className="text-sm">{bank?.account_name}</span>
                                 </div>
                             </TableCell>
                         </TableRow>
+                        <TableRow>
+                            <TableHead>{_("Account")}</TableHead>
+                            <TableCell>
+                                <span title="GL Account" className="text-sm">{bank?.account}</span>
+                            </TableCell>
+                        </TableRow>
                         <TableRow>
                             <TableHead>{_("Statement File")}</TableHead>
                             <TableCell>
@@ -158,7 +163,11 @@ const StatementDetails = ({ data }: Props) => {
                         </TableRow>
                         <TableRow>
                             <TableHead>{_("Transaction Dates")}</TableHead>
-                            <TableCell>{_("{0} to {1}", [formatDate(data.doc.start_date, "Do MMMM YYYY"), formatDate(data.doc.end_date, "Do MMMM YYYY")])}</TableCell>
+                            {data.doc.start_date && data.doc.end_date ? (
+                                <TableCell>{_("{0} to {1}", [formatDate(data.doc.start_date, "Do MMMM YYYY"), formatDate(data.doc.end_date, "Do MMMM YYYY")])}</TableCell>
+                            ) : (
+                                <TableCell>-</TableCell>
+                            )}
                         </TableRow>
                         <TableRow>
                             <TableHead>{_("Number of Transactions")}</TableHead>

banking/src/components/features/BankStatementImporter/PDF/BBoxOverlay.tsx

@@ -0,0 +1,129 @@
+import { RefObject, useEffect, useRef, useState } from 'react'
+import { cn } from '@/lib/utils'
+
+type Bbox = [number, number, number, number]
+
+const MIN_SIZE = 8 // PDF points
+
+// Keep the box valid: normalise flipped edges, enforce a min size, clamp to the page.
+const clampBbox = (bbox: Bbox, pageWidth: number, pageHeight: number): Bbox => {
+    let [x0, top, x1, bottom] = bbox
+    if (x1 < x0) [x0, x1] = [x1, x0]
+    if (bottom < top) [top, bottom] = [bottom, top]
+    x0 = Math.max(0, Math.min(x0, pageWidth - MIN_SIZE))
+    top = Math.max(0, Math.min(top, pageHeight - MIN_SIZE))
+    x1 = Math.min(pageWidth, Math.max(x1, x0 + MIN_SIZE))
+    bottom = Math.min(pageHeight, Math.max(bottom, top + MIN_SIZE))
+    return [x0, top, x1, bottom]
+}
+
+const HANDLES = [
+    { id: 'nw', className: 'left-0 top-0 -translate-x-1/2 -translate-y-1/2 cursor-nwse-resize' },
+    { id: 'ne', className: 'right-0 top-0 translate-x-1/2 -translate-y-1/2 cursor-nesw-resize' },
+    { id: 'sw', className: 'left-0 bottom-0 -translate-x-1/2 translate-y-1/2 cursor-nesw-resize' },
+    { id: 'se', className: 'right-0 bottom-0 translate-x-1/2 translate-y-1/2 cursor-nwse-resize' },
+]
+
+type Props = {
+    bbox: Bbox
+    pageWidth: number
+    pageHeight: number
+    color: { border: string; bg: string; swatch: string }
+    label: string
+    included: boolean
+    disabled?: boolean
+    containerRef: RefObject<HTMLDivElement | null>
+    onCommit: (bbox: Bbox) => void
+}
+
+/** A draggable + corner-resizable rectangle over a rendered PDF page. Coordinates are in PDF
+ *  points (top-left origin); pixel deltas are converted using the container's rendered size. */
+const BBoxOverlay = ({ bbox, pageWidth, pageHeight, color, label, included, disabled, containerRef, onCommit }: Props) => {
+    const [draft, setDraft] = useState<Bbox>(bbox)
+    const draftRef = useRef<Bbox>(bbox)
+    const drag = useRef<{ mode: string; startX: number; startY: number; start: Bbox } | null>(null)
+
+    // Reset to the authoritative bbox whenever it changes (e.g. after a server re-extract).
+    useEffect(() => {
+        setDraft(bbox)
+        draftRef.current = bbox
+    }, [bbox])
+
+    const apply = (next: Bbox) => {
+        draftRef.current = next
+        setDraft(next)
+    }
+
+    const onPointerDown = (e: React.PointerEvent) => {
+        if (disabled) return
+        e.preventDefault()
+        e.stopPropagation()
+        const mode = (e.target as HTMLElement).dataset.handle ?? 'move'
+        ;(e.currentTarget as HTMLElement).setPointerCapture(e.pointerId)
+        drag.current = { mode, startX: e.clientX, startY: e.clientY, start: draftRef.current }
+    }
+
+    const onPointerMove = (e: React.PointerEvent) => {
+        if (!drag.current || !containerRef.current) return
+        const rect = containerRef.current.getBoundingClientRect()
+        const dx = ((e.clientX - drag.current.startX) / rect.width) * pageWidth
+        const dy = ((e.clientY - drag.current.startY) / rect.height) * pageHeight
+        let [x0, top, x1, bottom] = drag.current.start
+        const m = drag.current.mode
+        if (m === 'move') {
+            x0 += dx
+            x1 += dx
+            top += dy
+            bottom += dy
+        } else {
+            if (m.includes('w')) x0 += dx
+            if (m.includes('e')) x1 += dx
+            if (m.includes('n')) top += dy
+            if (m.includes('s')) bottom += dy
+        }
+        apply(clampBbox([x0, top, x1, bottom], pageWidth, pageHeight))
+    }
+
+    const onPointerUp = (e: React.PointerEvent) => {
+        if (!drag.current) return
+        ;(e.currentTarget as HTMLElement).releasePointerCapture(e.pointerId)
+        drag.current = null
+        onCommit(draftRef.current)
+    }
+
+    const [x0, top, x1, bottom] = draft
+
+    return (
+        <div
+            className={cn(
+                'absolute touch-none border-2',
+                color.border,
+                included ? color.bg : 'opacity-40',
+                disabled ? 'pointer-events-none' : 'cursor-move',
+            )}
+            style={{
+                left: `${(x0 / pageWidth) * 100}%`,
+                top: `${(top / pageHeight) * 100}%`,
+                width: `${((x1 - x0) / pageWidth) * 100}%`,
+                height: `${((bottom - top) / pageHeight) * 100}%`,
+            }}
+            onPointerDown={onPointerDown}
+            onPointerMove={onPointerMove}
+            onPointerUp={onPointerUp}
+        >
+            <span className={cn('pointer-events-none absolute -top-5 left-0 rounded px-1 text-[10px] font-medium text-white', color.swatch)}>
+                {label}
+            </span>
+            {!disabled &&
+                HANDLES.map((handle) => (
+                    <span
+                        key={handle.id}
+                        data-handle={handle.id}
+                        className={cn('absolute size-2.5 rounded-sm border border-white', color.swatch, handle.className)}
+                    />
+                ))}
+        </div>
+    )
+}
+
+export default BBoxOverlay

banking/src/components/features/BankStatementImporter/PDF/PDFImport.tsx

@@ -0,0 +1,23 @@
+import StatementDetails from '../CSV/StatementDetails'
+import PDFTableEditor from './PDFTableEditor'
+import { GetStatementDetailsResponse } from '../import_utils'
+
+type Props = {
+    data: { message: GetStatementDetailsResponse }
+    mutate: () => void
+}
+
+const PDFImport = ({ data, mutate }: Props) => {
+    return (
+        <div className="w-full flex">
+            <div className="w-[45%] p-4 h-[calc(100vh-72px)] overflow-scroll">
+                <StatementDetails data={data.message} />
+            </div>
+            <div className="w-[55%] border-s pe-1 ps-0 border-outline-gray-2 h-[calc(100vh-72px)] overflow-scroll">
+                <PDFTableEditor data={data.message} mutate={mutate} />
+            </div>
+        </div>
+    )
+}
+
+export default PDFImport

banking/src/components/features/BankStatementImporter/PDF/PDFTableEditor.tsx

@@ -0,0 +1,362 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { toast } from 'sonner'
+import { ChevronDownIcon, ChevronLeftIcon, ChevronRightIcon, FileTextIcon, Loader2Icon, TableIcon } from 'lucide-react'
+import _ from '@/lib/translate'
+import { cn } from '@/lib/utils'
+import { Button } from '@/components/ui/button'
+import { Switch } from '@/components/ui/switch'
+import { Label } from '@/components/ui/label'
+import { H3, Paragraph } from '@/components/ui/typography'
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import ErrorBanner from '@/components/ui/error-banner'
+import RawTableGrid from '../RawTableGrid'
+import BBoxOverlay from './BBoxOverlay'
+import {
+    applyColumnMappingChange,
+    ColumnMapsTo,
+    GetStatementDetailsResponse,
+    PDFTable,
+    useReextractPDFTable,
+    useSetPDFTableHeader,
+    useUpdatePDFTables,
+} from '../import_utils'
+
+type Props = {
+    data: GetStatementDetailsResponse
+    mutate: () => void
+}
+
+// Distinct overlay colours per table on a page.
+const OVERLAY_COLORS = [
+    { border: 'border-blue-500', bg: 'bg-blue-500/10', swatch: 'bg-blue-500' },
+    { border: 'border-purple-500', bg: 'bg-purple-500/10', swatch: 'bg-purple-500' },
+    { border: 'border-amber-500', bg: 'bg-amber-500/10', swatch: 'bg-amber-500' },
+    { border: 'border-teal-500', bg: 'bg-teal-500/10', swatch: 'bg-teal-500' },
+]
+
+const columnMappingRecord = (table: PDFTable): Record<number, ColumnMapsTo> => {
+    const map: Record<number, ColumnMapsTo> = {}
+    table.column_mapping?.forEach((col) => {
+        map[col.index] = col.maps_to
+    })
+    return map
+}
+
+const PDFTableEditor = ({ data, mutate }: Props) => {
+    const isCompleted = data.doc.status === 'Completed'
+
+    const [tables, setTables] = useState<PDFTable[]>(() => data.pdf_tables ?? [])
+    const [viewMode, setViewMode] = useState<'pdf' | 'table'>('pdf')
+    const [pageIndex, setPageIndex] = useState(0)
+    const [collapsed, setCollapsed] = useState<Set<number>>(new Set())
+
+    const toggleCollapsed = (tableIndex: number) =>
+        setCollapsed((prev) => {
+            const next = new Set(prev)
+            if (next.has(tableIndex)) {
+                next.delete(tableIndex)
+            } else {
+                next.add(tableIndex)
+            }
+            return next
+        })
+
+    const { call, loading, error } = useUpdatePDFTables()
+    const { call: reextract, loading: reextracting } = useReextractPDFTable()
+    const { call: setHeaderCall, loading: settingHeader } = useSetPDFTableHeader()
+    const busy = loading || reextracting || settingHeader
+
+    // Persist edits automatically (debounced) so the transaction preview updates in realtime.
+    const tablesRef = useRef(tables)
+    const saveTimer = useRef<ReturnType<typeof setTimeout>>(undefined)
+    const reextractTimer = useRef<ReturnType<typeof setTimeout>>(undefined)
+
+    const scheduleSave = () => {
+        if (isCompleted) return
+        clearTimeout(saveTimer.current)
+        saveTimer.current = setTimeout(() => {
+            call({ statement_import_id: data.doc.name, tables: tablesRef.current })
+                .then(() => mutate())
+                .catch(() => toast.error(_('Could not save the table settings.')))
+        }, 500)
+    }
+
+    // After a bbox change, re-extract that table's rows from the new region (debounced).
+    // The target is read inside the timeout so it always reflects the committed bbox.
+    const scheduleReextract = (tableIndex: number) => {
+        if (isCompleted) return
+        clearTimeout(reextractTimer.current)
+        reextractTimer.current = setTimeout(() => {
+            const target = tablesRef.current[tableIndex]
+            reextract({
+                statement_import_id: data.doc.name,
+                page: target.page,
+                table_index: target.table_index,
+                bbox: target.bbox,
+            })
+                .then((res) => {
+                    commitTables(res?.message?.pdf_tables ?? [])
+                    mutate()
+                })
+                .catch(() => toast.error(_('Could not re-extract the table.')))
+        }, 500)
+    }
+
+    useEffect(() => () => {
+        clearTimeout(saveTimer.current)
+        clearTimeout(reextractTimer.current)
+    }, [])
+
+    const pages = useMemo(() => Array.from(new Set(tables.map((t) => t.page))).sort((a, b) => a - b), [tables])
+    const currentPage = pages[pageIndex]
+    // Keep the table's position in the flat array so edits target the right one.
+    const pageTables = useMemo(
+        () => tables.map((table, index) => ({ table, index })).filter((t) => t.table.page === currentPage),
+        [tables, currentPage],
+    )
+
+    // Keep tablesRef in sync synchronously so the debounced save/re-extract never read stale state.
+    const commitTables = (next: PDFTable[]) => {
+        tablesRef.current = next
+        setTables(next)
+    }
+
+    const updateTable = (tableIndex: number, updater: (table: PDFTable) => PDFTable) => {
+        commitTables(tablesRef.current.map((t, i) => (i === tableIndex ? updater(t) : t)))
+        scheduleSave()
+    }
+
+    const onChangeMapping = (tableIndex: number, columnIndex: number, mapsTo: ColumnMapsTo) => {
+        updateTable(tableIndex, (table) => ({
+            ...table,
+            column_mapping: applyColumnMappingChange(table.column_mapping, columnIndex, mapsTo),
+        }))
+    }
+
+    const onToggleIncluded = (tableIndex: number, included: boolean) =>
+        updateTable(tableIndex, (table) => ({ ...table, included }))
+
+    const onBboxCommit = (tableIndex: number, bbox: [number, number, number, number]) => {
+        commitTables(tablesRef.current.map((t, i) => (i === tableIndex ? { ...t, bbox } : t)))
+        scheduleReextract(tableIndex)
+    }
+
+    // Set/clear the header row of a table; the backend re-derives the column mapping.
+    const onSetHeader = (tableIndex: number, headerIndex: number | null) => {
+        commitTables(tablesRef.current.map((t, i) => (i === tableIndex ? { ...t, header_index: headerIndex } : t)))
+        const target = tablesRef.current[tableIndex]
+        setHeaderCall({
+            statement_import_id: data.doc.name,
+            page: target.page,
+            table_index: target.table_index,
+            header_index: headerIndex ?? -1,
+        })
+            .then((res) => {
+                commitTables(res?.message?.pdf_tables ?? [])
+                mutate()
+            })
+            .catch(() => toast.error(_('Could not update the header row.')))
+    }
+
+    if (tables.length === 0) {
+        return (
+            <div className="p-4">
+                <Paragraph className="text-p-sm text-ink-gray-5">
+                    {_('No tables were extracted from this PDF.')}
+                </Paragraph>
+            </div>
+        )
+    }
+
+    return (
+        <div className="flex flex-col gap-3 p-4">
+            <div className="flex flex-col gap-1">
+                <H3 className="text-base border-0 p-0">{_('Detected Tables')}</H3>
+                <Paragraph className="text-p-sm">
+                    {_('Review each page. In the Table view, map each column, click a row number to set/clear the header row, and exclude anything that is not transactions (ads, summaries).')}
+                </Paragraph>
+            </div>
+
+            {error && <ErrorBanner error={error} />}
+
+            <div className="flex items-center justify-between gap-2">
+                <Tabs value={viewMode} onValueChange={(v) => setViewMode(v as 'pdf' | 'table')}>
+                    <TabsList variant="subtle">
+                        <TabsTrigger value="pdf"><FileTextIcon />{_('PDF')}</TabsTrigger>
+                        <TabsTrigger value="table"><TableIcon />{_('Table')}</TabsTrigger>
+                    </TabsList>
+                </Tabs>
+
+                <div className="flex items-center gap-1">
+                    {busy && (
+                        <span className="flex items-center gap-1 pe-1 text-xs text-ink-gray-5">
+                            <Loader2Icon className="size-3 animate-spin" />
+                            {reextracting ? _('Re-extracting') : _('Saving')}
+                        </span>
+                    )}
+                    <Button
+                        variant="ghost"
+                        isIconButton
+                        disabled={pageIndex === 0}
+                        onClick={() => setPageIndex((i) => Math.max(0, i - 1))}
+                    >
+                        <ChevronLeftIcon />
+                    </Button>
+                    <span className="min-w-24 text-center text-sm text-ink-gray-7">
+                        {_('Page {0} of {1}', [currentPage.toString(), pages.length.toString()])}
+                    </span>
+                    <Button
+                        variant="ghost"
+                        isIconButton
+                        disabled={pageIndex >= pages.length - 1}
+                        onClick={() => setPageIndex((i) => Math.min(pages.length - 1, i + 1))}
+                    >
+                        <ChevronRightIcon />
+                    </Button>
+                </div>
+            </div>
+
+            {viewMode === 'pdf' ? (
+                <PageView
+                    pageTables={pageTables}
+                    disabled={isCompleted}
+                    onToggleIncluded={onToggleIncluded}
+                    onBboxCommit={onBboxCommit}
+                />
+            ) : (
+                <div className="flex flex-col gap-4">
+                    {pageTables.map(({ table, index }, position) => {
+                        const isCollapsed = collapsed.has(index)
+                        return (
+                            <div
+                                key={index}
+                                className={cn('flex flex-col rounded border border-outline-gray-2', !table.included && 'opacity-60')}
+                            >
+                                <div className="flex items-center justify-between p-2">
+                                    <span className="ps-1 text-sm font-medium text-ink-gray-8">
+                                        {_('Table {0}', [(position + 1).toString()])}
+                                    </span>
+                                    <div className="flex items-center gap-2">
+                                        <IncludeToggle
+                                            id={`tbl-${index}`}
+                                            checked={table.included}
+                                            disabled={isCompleted}
+                                            onCheckedChange={(c) => onToggleIncluded(index, c)}
+                                        />
+                                        <Button variant="ghost" size="sm" isIconButton onClick={() => toggleCollapsed(index)}>
+                                            <ChevronDownIcon className={cn('transition-transform', isCollapsed && '-rotate-90')} />
+                                        </Button>
+                                    </div>
+                                </div>
+                                {!isCollapsed && (
+                                    <div className="overflow-auto border-t border-outline-gray-2">
+                                        <RawTableGrid
+                                            rows={table.rows}
+                                            columnMapping={columnMappingRecord(table)}
+                                            headerIndex={table.header_index}
+                                            editable
+                                            disabled={isCompleted}
+                                            onChangeMapping={(columnIndex, mapsTo) => onChangeMapping(index, columnIndex, mapsTo)}
+                                            onSetHeader={(rowIndex) => onSetHeader(index, rowIndex)}
+                                        />
+                                    </div>
+                                )}
+                            </div>
+                        )
+                    })}
+                </div>
+            )}
+        </div>
+    )
+}
+
+type PageViewProps = {
+    pageTables: { table: PDFTable; index: number }[]
+    disabled: boolean
+    onToggleIncluded: (tableIndex: number, included: boolean) => void
+    onBboxCommit: (tableIndex: number, bbox: [number, number, number, number]) => void
+}
+
+const PageView = ({ pageTables, disabled, onToggleIncluded, onBboxCommit }: PageViewProps) => {
+    const containerRef = useRef<HTMLDivElement>(null)
+    const pageImage = pageTables[0]?.table.page_image
+    const pageWidth = pageTables[0]?.table.page_width ?? 1
+    const pageHeight = pageTables[0]?.table.page_height ?? 1
+
+    if (!pageImage) {
+        return (
+            <Paragraph className="text-p-sm text-ink-gray-5">
+                {_('No page image is available for this page.')}
+            </Paragraph>
+        )
+    }
+
+    return (
+        <div className="flex flex-col gap-3">
+            {!disabled && (
+                <Paragraph className="text-xs text-ink-gray-5">
+                    {_('Drag a box to move it, or drag a corner to resize. The table is re-read from the new region automatically.')}
+                </Paragraph>
+            )}
+            <div ref={containerRef} className="relative w-full overflow-auto rounded border border-outline-gray-2 bg-surface-gray-1">
+                <img src={pageImage} alt={_('Page preview')} className="w-full" />
+                {pageTables.map(({ table, index }, position) => {
+                    const color = OVERLAY_COLORS[position % OVERLAY_COLORS.length]
+                    return (
+                        <BBoxOverlay
+                            key={index}
+                            bbox={table.bbox}
+                            pageWidth={pageWidth}
+                            pageHeight={pageHeight}
+                            color={color}
+                            label={_('Table {0}', [(position + 1).toString()])}
+                            included={table.included}
+                            disabled={disabled}
+                            containerRef={containerRef}
+                            onCommit={(bbox) => onBboxCommit(index, bbox)}
+                        />
+                    )
+                })}
+            </div>
+
+            <div className="flex flex-col gap-1.5">
+                {pageTables.map(({ table, index }, position) => {
+                    const color = OVERLAY_COLORS[position % OVERLAY_COLORS.length]
+                    return (
+                        <div key={index} className="flex items-center justify-between rounded border border-outline-gray-2 px-2 py-1.5">
+                            <div className="flex items-center gap-2">
+                                <span className={cn('size-3 rounded-sm', color.swatch)} />
+                                <span className="text-xs">{_('Table {0}', [(position + 1).toString()])}</span>
+                            </div>
+                            <IncludeToggle
+                                id={`pdf-tbl-${index}`}
+                                checked={table.included}
+                                disabled={disabled}
+                                onCheckedChange={(c) => onToggleIncluded(index, c)}
+                            />
+                        </div>
+                    )
+                })}
+            </div>
+        </div>
+    )
+}
+
+const IncludeToggle = ({
+    id,
+    checked,
+    disabled,
+    onCheckedChange,
+}: {
+    id: string
+    checked: boolean
+    disabled: boolean
+    onCheckedChange: (checked: boolean) => void
+}) => (
+    <div className="flex items-center gap-2">
+        <Label htmlFor={id} className="text-xs text-ink-gray-6">{_('Include')}</Label>
+        <Switch id={id} checked={checked} disabled={disabled} onCheckedChange={onCheckedChange} />
+    </div>
+)
+
+export default PDFTableEditor

banking/src/components/features/BankStatementImporter/RawTableGrid.tsx

@@ -0,0 +1,222 @@
+import { useMemo } from 'react'
+import {
+    ArrowDownRightIcon,
+    ArrowUpDownIcon,
+    ArrowUpRightIcon,
+    BanknoteIcon,
+    CalendarIcon,
+    DollarSignIcon,
+    FileTextIcon,
+    ListIcon,
+    ReceiptIcon,
+} from 'lucide-react'
+import _ from '@/lib/translate'
+import { cn } from '@/lib/utils'
+import { Table, TableBody, TableCell, TableHead, TableRow } from '@/components/ui/table'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { COLUMN_MAPS_TO_OPTIONS, ColumnMapsTo } from './import_utils'
+
+const AMOUNT_COLUMNS: ColumnMapsTo[] = ['Amount', 'Withdrawal', 'Deposit', 'Balance']
+const DATE_LIKE = /\d{1,4}[/\-.\s]\d{1,2}[/\-.\s]\d{1,4}|\d{1,2}[\s-][a-z]{3}/i
+
+type Props = {
+    rows: string[][]
+    /** Column index -> mapped field */
+    columnMapping: Record<number, ColumnMapsTo>
+    headerIndex: number | null
+    editable?: boolean
+    disabled?: boolean
+    onChangeMapping?: (columnIndex: number, mapsTo: ColumnMapsTo) => void
+    /** Set the header row (or null to mark the table as having no header). */
+    onSetHeader?: (rowIndex: number | null) => void
+}
+
+/**
+ * A preview of extracted rows with CSV-style colour coding: the header row is highlighted,
+ * detected transaction rows are green, and mapped columns are emphasised. When `editable`, a
+ * compact row of column -> field dropdowns sits at the top, and row numbers can be clicked to
+ * set/clear the header row.
+ */
+const RawTableGrid = ({ rows, columnMapping, headerIndex, editable, disabled, onChangeMapping, onSetHeader }: Props) => {
+    // Tabular (XLSX) cells can be numbers/dates, not strings - coerce so .trim()/render are safe.
+    const stringRows = useMemo(
+        () => rows.map((row) => row.map((cell) => (cell == null ? '' : String(cell)))),
+        [rows],
+    )
+    const numColumns = useMemo(() => stringRows.reduce((max, row) => Math.max(max, row.length), 0), [stringRows])
+
+    const validColumns = useMemo(
+        () => Object.entries(columnMapping).filter(([, m]) => m && m !== 'Do not import').map(([i]) => Number(i)),
+        [columnMapping],
+    )
+    const dateColumn = useMemo(() => Object.entries(columnMapping).find(([, m]) => m === 'Date')?.[0], [columnMapping])
+    const amountColumns = useMemo(
+        () => Object.entries(columnMapping).filter(([, m]) => ['Amount', 'Withdrawal', 'Deposit'].includes(m)).map(([i]) => Number(i)),
+        [columnMapping],
+    )
+
+    // Approximate the backend's transaction-row detection so the highlighting tracks edits live.
+    const transactionRows = useMemo(() => {
+        const set = new Set<number>()
+        if (dateColumn === undefined) return set
+        const dateIdx = Number(dateColumn)
+        stringRows.forEach((row, index) => {
+            if (index === headerIndex) return
+            const dateCell = (row[dateIdx] ?? '').trim()
+            if (!dateCell || !DATE_LIKE.test(dateCell)) return
+            if (amountColumns.some((c) => (row[c] ?? '').trim() !== '')) set.add(index)
+        })
+        return set
+    }, [stringRows, headerIndex, dateColumn, amountColumns])
+
+    return (
+        <Table containerClassName="rounded-none">
+            <TableBody>
+                {editable && (
+                    <TableRow className="border-b border-outline-gray-2 bg-surface-white hover:bg-surface-white">
+                        <TableHead className="w-8 p-1" />
+                        {Array.from({ length: numColumns }).map((_unused, columnIndex) => (
+                            <TableHead key={columnIndex} className="p-1 align-top">
+                                <Select
+                                    disabled={disabled}
+                                    value={columnMapping[columnIndex] ?? 'Do not import'}
+                                    onValueChange={(value) => onChangeMapping?.(columnIndex, value as ColumnMapsTo)}
+                                >
+                                    <SelectTrigger variant="outline" inputSize="sm" className="h-7 w-full">
+                                        <SelectValue />
+                                    </SelectTrigger>
+                                    <SelectContent>
+                                        {COLUMN_MAPS_TO_OPTIONS.map((option) => (
+                                            <SelectItem key={option} value={option}>
+                                                <span className="flex items-center gap-1.5">
+                                                    <ColumnHeaderIcon columnType={option} />
+                                                    {_(option)}
+                                                </span>
+                                            </SelectItem>
+                                        ))}
+                                    </SelectContent>
+                                </Select>
+                            </TableHead>
+                        ))}
+                    </TableRow>
+                )}
+
+                {stringRows.map((row, index) => {
+                    const isHeaderRow = index === headerIndex
+                    const isTransactionRow = transactionRows.has(index)
+
+                    return (
+                        <TableRow
+                            key={index}
+                            className={cn({
+                                'bg-green-50 hover:bg-green-50 dark:bg-green-700 dark:hover:bg-green-700': isTransactionRow,
+                                'bg-yellow-100 hover:bg-yellow-100 dark:bg-yellow-400': isHeaderRow,
+                                'text-ink-gray-5/70': !isTransactionRow && !isHeaderRow,
+                            })}
+                        >
+                            {editable && onSetHeader ? (
+                                <TableCell className="h-px w-8 p-0 text-center">
+                                    <Tooltip>
+                                        <TooltipTrigger asChild>
+                                            <button
+                                                type="button"
+                                                disabled={disabled}
+                                                onClick={() => onSetHeader(isHeaderRow ? null : index)}
+                                                className={cn(
+                                                    'flex h-full w-full items-center justify-center px-1 text-ink-gray-6 hover:bg-surface-gray-3',
+                                                    isHeaderRow && 'font-semibold text-ink-gray-8',
+                                                )}
+                                            >
+                                                {index + 1}
+                                            </button>
+                                        </TooltipTrigger>
+                                        <TooltipContent>
+                                            {isHeaderRow
+                                                ? _('This is the header row. Click to mark the table as having no header.')
+                                                : _('Click to set this as the header row.')}
+                                        </TooltipContent>
+                                    </Tooltip>
+                                </TableCell>
+                            ) : (
+                                <TableCell className="w-8 px-1 py-0.5 text-center text-ink-gray-6">{index + 1}</TableCell>
+                            )}
+
+                            {Array.from({ length: numColumns }).map((_unused, cellIndex) => {
+                                const columnType = columnMapping[cellIndex]
+                                const isValidColumn = validColumns.includes(cellIndex)
+                                const isAmountColumn = AMOUNT_COLUMNS.includes(columnType)
+                                const cellText = row[cellIndex] ?? ''
+
+                                // Read-only header row: icon + label.
+                                if (isHeaderRow) {
+                                    return (
+                                        <TableCell key={cellIndex} className="max-w-[200px] overflow-hidden text-ellipsis py-1">
+                                            <div className="flex items-center gap-1 px-1 text-xs font-medium text-ink-gray-8">
+                                                {columnType && (
+                                                    <Tooltip>
+                                                        <TooltipTrigger>
+                                                            <ColumnHeaderIcon columnType={columnType} />
+                                                        </TooltipTrigger>
+                                                        <TooltipContent>{_(columnType)}</TooltipContent>
+                                                    </Tooltip>
+                                                )}
+                                                {cellText}
+                                            </div>
+                                        </TableCell>
+                                    )
+                                }
+
+                                return (
+                                    <TableCell
+                                        key={cellIndex}
+                                        className={cn('max-w-[200px] overflow-hidden text-ellipsis py-0.5', {
+                                            'bg-green-100 dark:bg-green-400 hover:bg-green-100 dark:hover:bg-green-400': isValidColumn && isTransactionRow,
+                                            'text-ink-gray-5': !isValidColumn && isTransactionRow,
+                                        })}
+                                    >
+                                        <div
+                                            className={cn('min-h-5 flex items-center px-1 text-xs', {
+                                                'justify-end': isAmountColumn && isValidColumn && isTransactionRow,
+                                            })}
+                                            title={cellText}
+                                        >
+                                            {cellText}
+                                        </div>
+                                    </TableCell>
+                                )
+                            })}
+                        </TableRow>
+                    )
+                })}
+            </TableBody>
+        </Table>
+    )
+}
+
+const ColumnHeaderIcon = ({ columnType }: { columnType?: ColumnMapsTo }) => {
+    switch (columnType) {
+        case 'Amount':
+            return <DollarSignIcon className="size-4" />
+        case 'Withdrawal':
+            return <ArrowUpRightIcon className="size-4 text-ink-red-3" />
+        case 'Deposit':
+            return <ArrowDownRightIcon className="size-4 text-ink-green-3" />
+        case 'Balance':
+            return <BanknoteIcon className="size-4" />
+        case 'Date':
+            return <CalendarIcon className="size-4" />
+        case 'Description':
+            return <FileTextIcon className="size-4" />
+        case 'Reference':
+            return <ReceiptIcon className="size-4" />
+        case 'Transaction Type':
+            return <ListIcon className="size-4" />
+        case 'Debit/Credit':
+            return <ArrowUpDownIcon className="size-4" />
+        default:
+            return null
+    }
+}
+
+export default RawTableGrid

banking/src/components/features/BankStatementImporter/import_utils.ts

@@ -1,6 +1,97 @@
 import { BankStatementImportLog } from "@/types/Accounts/BankStatementImportLog"
-import { useFrappeGetCall } from "frappe-react-sdk"
+import { useFrappeGetCall, useFrappePostCall } from "frappe-react-sdk"
 
+export type ColumnMapsTo =
+    | "Do not import"
+    | "Date"
+    | "Withdrawal"
+    | "Deposit"
+    | "Amount"
+    | "Description"
+    | "Reference"
+    | "Transaction Type"
+    | "Debit/Credit"
+    | "Balance"
+    | "Included Fee"
+    | "Excluded Fee"
+    | "Party Name/Account Holder"
+    | "Party Account No."
+    | "Party IBAN"
+
+export type ColumnMappingEntry = {
+    index: number
+    maps_to: ColumnMapsTo | string
+    header_text?: string
+    variable?: string
+}
+
+/** Apply a column mapping change, clearing the same mapping from any other column. */
+export function applyColumnMappingChange<T extends ColumnMappingEntry>(
+    columns: T[],
+    columnIndex: number,
+    mapsTo: ColumnMapsTo,
+): T[] {
+    const previous = columns.find((c) => c.index === columnIndex)
+    const cleared =
+        mapsTo === "Do not import"
+            ? columns
+            : columns.map((c) =>
+                  c.index !== columnIndex && c.maps_to === mapsTo
+                      ? { ...c, maps_to: "Do not import" as ColumnMapsTo }
+                      : c,
+              )
+
+    return [
+        ...cleared.filter((c) => c.index !== columnIndex),
+        {
+            index: columnIndex,
+            maps_to: mapsTo,
+            header_text: previous?.header_text ?? "",
+            variable: previous?.variable ?? `column_${columnIndex}`,
+        } as T,
+    ].sort((a, b) => a.index - b.index)
+}
+
+export const COLUMN_MAPS_TO_OPTIONS: ColumnMapsTo[] = [
+    "Do not import",
+    "Date",
+    "Description",
+    "Reference",
+    "Withdrawal",
+    "Deposit",
+    "Amount",
+    "Balance",
+    "Debit/Credit",
+    "Transaction Type",
+    "Included Fee",
+    "Excluded Fee",
+    "Party Name/Account Holder",
+    "Party Account No.",
+    "Party IBAN",
+]
+
+export interface PDFTableColumn {
+    index: number
+    header_text: string
+    variable?: string
+    maps_to: ColumnMapsTo
+}
+
+export interface PDFTable {
+    page: number
+    table_index: number
+    bbox: [number, number, number, number]
+    page_width: number
+    page_height: number
+    page_image: string | null
+    render_scale: number | null
+    rows: string[][]
+    header_index: number | null
+    column_mapping: PDFTableColumn[]
+    date_format?: string
+    amount_format?: string
+    included: boolean
+}
 
 export interface GetStatementDetailsResponse {
     doc: BankStatementImportLog,
@@ -30,6 +121,7 @@ export interface GetStatementDetailsResponse {
     date_format: string,
     raw_data: Array<Array<string>>,
     currency: string,
+    pdf_tables?: PDFTable[],
 }
 
 export const useGetStatementDetails = (id: string) => {
@@ -39,4 +131,24 @@ export const useGetStatementDetails = (id: string) => {
         revalidateOnFocus: false
     })
 
+}
+
+export const useUpdatePDFTables = () => {
+    return useFrappePostCall<{ message: GetStatementDetailsResponse }>("erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log.update_pdf_tables")
+}
+
+export const useReextractPDFTable = () => {
+    return useFrappePostCall<{ message: GetStatementDetailsResponse }>("erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log.reextract_pdf_table")
+}
+
+export const useSetPDFTableHeader = () => {
+    return useFrappePostCall<{ message: GetStatementDetailsResponse }>("erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log.set_pdf_table_header")
+}
+
+export const useUpdateColumnMapping = () => {
+    return useFrappePostCall<{ message: GetStatementDetailsResponse }>("erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log.update_column_mapping")
+}
+
+export const useSetHeaderIndex = () => {
+    return useFrappePostCall<{ message: GetStatementDetailsResponse }>("erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log.set_header_index")
 }

banking/src/components/ui/file-dropzone.tsx

@@ -231,7 +231,7 @@ export const FileTypeIcon = ({
     const getTextColor = () => {
         switch (fileType.toLowerCase()) {
             case 'pdf':
-                return 'text-red-700'
+                return 'text-ink-red-3'
             case 'doc':
             case 'docx':
                 return 'text-[#1A5CBD]'

banking/src/lib/frappe.ts

@@ -33,6 +33,16 @@ export const getErrorMessages = (error?: FrappeError | null): ParsedErrorMessage
         }
     })
 
+    // @ts-expect-error - some errors have _error_message
+    if (error?._error_message) {
+        eMessages.push({
+            // @ts-expect-error - some errors have _error_message
+            message: error?._error_message,
+            title: "Error",
+            indicator: "red"
+        })
+    }
+
     if (eMessages.length === 0) {
         // Get the message from the exception by removing the exc_type
         const indexOfFirstColon = error?.exception?.indexOf(':')

banking/src/pages/BankStatementImporter.tsx

@@ -7,6 +7,7 @@ import { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, Di
 import { Empty, EmptyHeader, EmptyMedia, EmptyTitle } from "@/components/ui/empty"
 import ErrorBanner from "@/components/ui/error-banner"
 import { FileDropzone } from "@/components/ui/file-dropzone"
+import { Input } from "@/components/ui/input"
 import { Label } from "@/components/ui/label"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { H3, Paragraph } from "@/components/ui/typography"
@@ -16,7 +17,7 @@ import { flt, formatCurrency } from "@/lib/numbers"
 import _ from "@/lib/translate"
 import { cn } from "@/lib/utils"
 import { BankStatementImportLog } from "@/types/Accounts/BankStatementImportLog"
-import { useFrappeCreateDoc, useFrappeFileUpload, useFrappeGetDocList } from "frappe-react-sdk"
+import { useFrappeCreateDoc, useFrappeFileUpload, useFrappeGetDocList, useFrappeUpdateDoc } from "frappe-react-sdk"
 import { useAtom, useAtomValue } from "jotai"
 import { ListIcon, Loader2Icon } from "lucide-react"
 import { useState } from "react"
@@ -30,11 +31,15 @@ const BankStatementImporter = () => {
     const [selectedBankAccount] = useAtom(selectedBankAccountAtom)
 
     const [files, setFiles] = useState<File[]>([])
+    const [password, setPassword] = useState("")
 
     const { upload, error, loading } = useFrappeFileUpload()
 
     const navigate = useNavigate()
     const { createDoc, loading: createLoading, error: createError } = useFrappeCreateDoc<BankStatementImportLog>()
+    const { updateDoc, error: updateError } = useFrappeUpdateDoc()
+
+    const isPdf = files[0]?.name?.toLowerCase().endsWith(".pdf") ?? false
 
     const onUpload = () => {
 
@@ -44,12 +49,18 @@ const BankStatementImporter = () => {
 
         const id = `new-bank-statement-import-log-${Date.now()}`
 
-        upload(files[0], {
+        // For protected PDFs, persist the password on the Bank Account so it is reused for
+        // every statement of this account (and is available before the import doc is created).
+        const ensurePassword = isPdf && password
+            ? updateDoc("Bank Account", selectedBankAccount.name, { statement_password: password })
+            : Promise.resolve()
+
+        ensurePassword.then(() => upload(files[0], {
             isPrivate: true,
             doctype: "Bank Statement Import Log",
             docname: id,
             fieldname: 'file'
-        }).then((file) => {
+        })).then((file) => {
             return createDoc("Bank Statement Import Log",
                 // @ts-expect-error - not filling everything else
                 {
@@ -67,6 +78,7 @@ const BankStatementImporter = () => {
             <div className="w-[52%]">
                 {error && <ErrorBanner error={error} />}
                 {createError && <ErrorBanner error={createError} />}
+                {updateError && <ErrorBanner error={updateError} />}
                 <div className="py-2 flex flex-col gap-6">
                     <div className="flex flex-col gap-2">
                         <Label>{_("Company")}<span className="text-ink-red-3">*</span></Label>
@@ -89,7 +101,7 @@ const BankStatementImporter = () => {
                                     data-slot="form-description"
                                     className={cn("text-ink-gray-5 text-xs")}
                                 >
-                                    {_("Upload your bank statement file to start the import process. We support CSV, and XLSX files.")}
+                                    {_("Upload your bank statement file to start the import process. We support CSV, XLSX and PDF files.")}
                                 </p>
                             </div>
                             <div>
@@ -105,10 +117,27 @@ const BankStatementImporter = () => {
                                 'text/csv': ['.csv'],
                                 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': ['.xlsx'],
                                 'application/vnd.ms-excel': ['.xls'],
+                                'application/pdf': ['.pdf'],
                                 // 'application/xml': ['.xml'],
                             }}
                             multiple={false}
                         />
+
+                        {isPdf && <div className="flex flex-col gap-2">
+                            <Label htmlFor="pdf-password">{_("PDF Password")}</Label>
+                            <Input
+                                id="pdf-password"
+                                type="password"
+                                autoComplete="off"
+                                value={password}
+                                onChange={(e) => setPassword(e.target.value)}
+                                placeholder={_("Only if the PDF is password protected")}
+                                className="max-w-sm"
+                            />
+                            <p data-slot="form-description" className={cn("text-ink-gray-5 text-p-sm")}>
+                                {_("Leave blank to use the password already saved for this bank account (if any). It is stored encrypted and reused for future statements.")}
+                            </p>
+                        </div>}
                     </div>}
                     <div className="flex justify-end px-4">
                         <Button
@@ -137,9 +166,10 @@ const StatementInstructions = () => {
         <DialogContent className="min-w-7xl">
             <DialogHeader>
                 <DialogTitle>{_("Statement Import Instructions")}</DialogTitle>
-                <DialogDescription>{_("We support uploading CSV, XLSX and XLS files. Please make sure the file contains the correct columns.")}</DialogDescription>
+                <DialogDescription>{_("We support uploading CSV, XLSX, XLS and PDF files. Please make sure the file contains the correct columns.")}</DialogDescription>
             </DialogHeader>
             <Paragraph className="text-sm">{_("The file should contain the following columns with a distinct header row. You can upload most bank statements as is without changing the columns.")}</Paragraph>
+            <Paragraph className="text-sm text-ink-gray-6">{_("For PDF statements, we auto-detect the tables on each page. You can then confirm each detected table, map its columns, and exclude anything that is not transactions (e.g. ads or summaries). Password-protected PDFs are supported - the password is saved on the bank account and reused.")}</Paragraph>
             <Table>
                 <TableHeader>
                     <TableRow>
@@ -231,7 +261,13 @@ const StatementImportLog = () => {
                             <TableRow key={item.name} onClick={() => onViewDetails(item.name)} className="cursor-pointer hover:bg-surface-gray-2">
                                 <TableCell>{formatDate(item.creation, 'Do MMM YYYY')}</TableCell>
                                 <TableCell><Badge theme={item.status === "Completed" ? "green" : "gray"}>{item.status}</Badge></TableCell>
-                                <TableCell>{formatDate(item.start_date, 'Do MMM YYYY')} to {formatDate(item.end_date, 'Do MMM YYYY')}</TableCell>
+                                <TableCell>
+                                    {item.start_date && item.end_date ? (
+                                        <span>{formatDate(item.start_date, 'Do MMM YYYY')} to {formatDate(item.end_date, 'Do MMM YYYY')}</span>
+                                    ) : (
+                                        <span>-</span>
+                                    )}
+                                </TableCell>
                                 <TableCell className="text-end">{item.number_of_transactions}</TableCell>
                                 <TableCell className="text-end font-numeric">{formatCurrency(flt(item.closing_balance, 2))}</TableCell>
                                 <TableCell><a

banking/src/pages/ViewBankStatementImportLog.tsx

@@ -9,12 +9,13 @@ import { ChevronLeftIcon, ChevronRightIcon } from 'lucide-react'
 import { Link, useParams } from 'react-router'
 
 const CSVImport = lazy(() => import('@/components/features/BankStatementImporter/CSV/CSVImport'))
+const PDFImport = lazy(() => import('@/components/features/BankStatementImporter/PDF/PDFImport'))
 
 const ViewBankStatementImportLog = () => {
 
     const { id } = useParams<{ id: string }>()
 
-    const { data, isLoading, error } = useGetStatementDetails(id ?? "")
+    const { data, isLoading, error, mutate } = useGetStatementDetails(id ?? "")
 
     useFrappeDocumentEventListener("Bank Statement Import Log", id ?? "", () => {
     })
@@ -42,7 +43,13 @@ const ViewBankStatementImportLog = () => {
             <ErrorBanner error={error} />
         </div>
     }
-    return <CSVImport data={data} />
+    const isPdf = data.message.doc.file?.toLowerCase().endsWith('.pdf')
+
+    if (isPdf) {
+        return <PDFImport data={data} mutate={mutate} />
+    }
+
+    return <CSVImport data={data} mutate={mutate} />
 }
 
 export default ViewBankStatementImportLog

banking/src/types/Accounts/BankAccount.ts

@@ -38,6 +38,8 @@ export interface BankAccount{
 	branch_code?: string
 	/**	Bank Account No : Data	*/
 	bank_account_no?: string
+	/**	Statement PDF Password : Password - Password used to open password-protected PDF statements for this account. Stored encrypted.	*/
+	statement_password?: string
 	/**	Is Credit Card : Check	*/
 	is_credit_card?: 0 | 1
 	/**	Integration ID : Data	*/

banking/src/types/Accounts/BankStatementImportLog.ts

@@ -47,4 +47,6 @@ export interface BankStatementImportLog {
 	detected_transaction_ending_index?: number
 	/**	Column Mapping : Table - Bank Statement Import Log Column Map	*/
 	column_mapping?: BankStatementImportLogColumnMap[]
+	/**	PDF Tables : JSON - Per-table extraction data for PDF statements	*/
+	pdf_tables?: string
 }

banking/yarn.lock

@@ -358,10 +358,10 @@
   dependencies:
     "@tybys/wasm-util" "^0.10.1"
 
-"@oxc-project/types@=0.128.0":
-  version "0.128.0"
-  resolved "https://registry.yarnpkg.com/@oxc-project/types/-/types-0.128.0.tgz#efc7524f948ff9e8ab1404ecad1823849c6fe149"
-  integrity sha512-huv1Y/LzBJkBVHt3OlC7u0zHBW9qXf1FdD7sGmc1rXc2P1mTwHssYv7jyGx5KAACSCH+9B3Bhn6Z9luHRvf7pQ==
+"@oxc-project/types@=0.133.0":
+  version "0.133.0"
+  resolved "https://registry.yarnpkg.com/@oxc-project/types/-/types-0.133.0.tgz#2e282ef9e1d26e06b68ccd14b73f310a3b2cf7f8"
+  integrity sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA==
 
 "@radix-ui/number@1.1.1":
   version "1.1.1"
@@ -1042,95 +1042,95 @@
   resolved "https://registry.yarnpkg.com/@radix-ui/rect/-/rect-1.1.1.tgz#78244efe12930c56fd255d7923865857c41ac8cb"
   integrity sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==
 
-"@rolldown/binding-android-arm64@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-rc.18.tgz#3af8b2242086125934a85c1915b76e0a6a2054c1"
-  integrity sha512-lIDyUAfD7U3+BWKzdxMbJcsYHuqXqmGz40aeRqvuAm3y5TkJSYTBW2RDrn65DJFPQqVjUAUqq5uz8urzQ8aBdQ==
+"@rolldown/binding-android-arm64@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.3.tgz#54ce8f8382213f4a314a0c2f7ba83f81ffeae592"
+  integrity sha512-454rs7jHngixp/NMxd5srYD57OnzSlZ/eFTETjORQHLwJG1lRtmNOJcBerZlfu4GjKqeq8aCCIQrMdHyhI51Hw==
 
-"@rolldown/binding-darwin-arm64@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-rc.18.tgz#ae0b4467d24ecd6c6589f03d4d4699616ee9649c"
-  integrity sha512-apJq2ktnGp27nSInMR5Vcj8kY6xJzDAvfdIFlpDcAK/w4cDO58qVoi1YQsES/SKiFNge/6e4CUzgjfHduYqWpQ==
+"@rolldown/binding-darwin-arm64@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.3.tgz#388fca1566c14c00c4b446fc3928630e7f0d95fc"
+  integrity sha512-PcAhP+ynjURNyy8SKGl5DQP94aGuB/7JrXJb/t7P+hanXvQVMWzUvRRhBAcg/lNRadBhoUPqSoP4xw5tR/KBEA==
 
-"@rolldown/binding-darwin-x64@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-rc.18.tgz#23cf24b0a7b96c8990bbdd8a91e7fd3ba82b00e7"
-  integrity sha512-5Ofot8xbs+pxRHJqm9/9N/4sTQOvdrwEsmPE9pdLEEoAbdZtG6F2LMDfO1sp6ZAtXJuJV/21ew2srq3W8NXB5g==
+"@rolldown/binding-darwin-x64@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.3.tgz#53f57de1f599ecf1db13823cfc88c18fb80954ad"
+  integrity sha512-9YpfeUvSE2RS7wysJ81uOZkXJz7f7Q55H2Gvp3VEw/EsahqDtrphrZ0EwDLK5vvKOzaCrBsjF8JmnMLcUt78Gg==
 
-"@rolldown/binding-freebsd-x64@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-rc.18.tgz#a047a770f94dc451c062b729e5d1cf82e5c6f9c4"
-  integrity sha512-7h8eeOTT1eyqJyx64BFCnWZpNm486hGWt2sqeLLgDxA0xI1oGZ9H7gK1S85uNGmBhkdPwa/6reTxfFFKvIsebw==
+"@rolldown/binding-freebsd-x64@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.3.tgz#6f3fdda1b7aeaac9d268a526804b4fb96e4e35f1"
+  integrity sha512-yB1IlAsSNHncV6SCTL27/MVGR5htvQsoGxIv5KMGXALp+Ll1wYsn+x98M9MW7qa+NdSbvrrY7ANI4wLJ0n1e6g==
 
-"@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-rc.18.tgz#c0b7f346cbf50301cea669a4632bc63aabe6a72c"
-  integrity sha512-eRcm/HVt9U/JFu5RKAEKwGQYtDCKWLiaH6wOnsSEp6NMBb/3Os8LgHZlNyzMpFVNmiiMFlfb2zEnebfzJrHFmg==
+"@rolldown/binding-linux-arm-gnueabihf@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.3.tgz#d87a454bf585cc9676849377e91d6e375297326f"
+  integrity sha512-Yi30IVAAfLUCy2MseFjbB1jAMDl1VMCAas5StnYp8da9+CKvMd2H2cbEjWcw5NPaPqzvYkVIaF1nNUG+b7u/sw==
 
-"@rolldown/binding-linux-arm64-gnu@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-rc.18.tgz#af56373c7996ebe6379207cd699c9f7f705e235d"
-  integrity sha512-SOrT/cT4ukTmgnrEz/Hg3m7LBnuCLW9psDeMKrimRWY4I8DmnO7Lco8W2vtqPmMkbVu8iJ+g4GFLVLLOVjJ9DQ==
+"@rolldown/binding-linux-arm64-gnu@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.3.tgz#419fd6bf612cf348f10528cbcd94ebab9607d8d1"
+  integrity sha512-jsO7R8To+AdlYgUmN5sHSCZbfhtMBkO0WUx8iORQnPcMMdgr7qM2DQmMwgabs3GhNztdmoKkMKQFHD6DTMCIQw==
 
-"@rolldown/binding-linux-arm64-musl@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-rc.18.tgz#a8f5acd21fcffc8991aa84710e3ae603c4240ea4"
-  integrity sha512-QWjdxN1HJCpBTAcZ5N5F7wju3gVPzRzSpmGzx7na0c/1qpN9CFil+xt+l9lV/1M6/gqHSNXCiqPfwhVJPeLnug==
+"@rolldown/binding-linux-arm64-musl@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.3.tgz#fcc6918696bb76844877e1e4930a18fd0d374069"
+  integrity sha512-VWkUHwWriDciit80wleYwKILoR/KMvxh/IdwS/paX+ZgpuRpCrKLUdadJbc0NpBEiyhpYawsJ73j9aCvOH+f7Q==
 
-"@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.0-rc.18.tgz#1d4a89e040ff82141fc46e717cfab80b05f7c13f"
-  integrity sha512-ugCOyj7a4d9h3q9B+wXmf6g3a68UsjGh6dob5DHevHGMwDUbhsYNbSPxJsENcIttJZ9jv7qGM2UesLw5jqIhdg==
+"@rolldown/binding-linux-ppc64-gnu@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.0.3.tgz#32aecb7c8dae5d4f2a8cde57a058ec86991542f8"
+  integrity sha512-5f1laC0SlIR0yDbFCd8acUhvJIag6N3zC5P7oUPN6wX0aOma+uKJ0wBDH5aq7I1PVI2ttTlhJwzwRIBnLiSGEg==
 
-"@rolldown/binding-linux-s390x-gnu@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.0-rc.18.tgz#97c21feeb2ed87d07820f0b2dcc5dd663e7a7f3b"
-  integrity sha512-kKWRhbsotpXkGbcd5dllUWg5gEXcDAa8u5YnP9AV5DYNbvJHGzzuwv7dpmhc8NqKMJldl0a+x76IHbspEpEmdA==
+"@rolldown/binding-linux-s390x-gnu@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.0.3.tgz#bed9346ea81e6bb8b93cf11f5d88b77db890b763"
+  integrity sha512-Iq4ko0r4XsgbrF/LunNgHtAGLRRVE2kXonAXQ/MV0mC6jQpMOhW1SvtZja2EhC/kd05++bP78dsqBeIQyYJ6Yg==
 
-"@rolldown/binding-linux-x64-gnu@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-rc.18.tgz#06310d40fe139ccc3c433b361120d337c66ebec2"
-  integrity sha512-uCo8ElcCIAMyYAZyuIZ81oFkhTSIllNvUCHCAlbhlN4ji3uC28h7IIdlXyIvGO7HsuqnV9p3rD/bpH7XhIyhRw==
+"@rolldown/binding-linux-x64-gnu@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.3.tgz#64c2d26f75dffd9b5a1f97557a00ae77250c8cb7"
+  integrity sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg==
 
-"@rolldown/binding-linux-x64-musl@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-rc.18.tgz#6a711258841f42609b238050cfcd5db13ac136d0"
-  integrity sha512-XNOQZtuE6yUIvx4rwGemwh8kpL1xvU41FXy/s9K7T/3JVcqGzo3NfKM2HrbrGgfPYGFW42f07Wk++aOC6B9NWA==
+"@rolldown/binding-linux-x64-musl@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.3.tgz#5a45132e8a47659eeaaf3b540c2954a97c860ff3"
+  integrity sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow==
 
-"@rolldown/binding-openharmony-arm64@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-rc.18.tgz#15cb644beeafdbec930d79ed45c2a7c2573eac70"
-  integrity sha512-tSn/kzrfa7tNOXr7sEacDBN4YsIqTyLqh45IO0nHDwtpKIDNDJr+VFojt+4klSpChxB29JLyduSsE0MKEwa65A==
+"@rolldown/binding-openharmony-arm64@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.3.tgz#290513068c55e849dc8457a32afee1d7b0acb309"
+  integrity sha512-OXXS3RKJgX2uLwM+gYyuH5omcH8fL1LJs96pZGgtetVCahON57+d4SJHzTgZiOjxgGkSnpXpOsWuPDGAKAigEg==
 
-"@rolldown/binding-wasm32-wasi@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-rc.18.tgz#ca3a56d11dfd533d743711141b3bb4c1ec10110e"
-  integrity sha512-+J9YGmc+czgqlhYmwun3S3O0FIZhsH8ep2456xwjAdIOmuJxM7xz4P4PtrxU+Bz17a/5bqPA8o3HAAoX0teUdg==
+"@rolldown/binding-wasm32-wasi@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.3.tgz#3d9972dbf1a953d3c7afaa4a0f20ef2b2e39f31b"
+  integrity sha512-JTtb8BWFynicNSoPrehsCzBtOKjZ6jhMiPFEmOiuXg1Fl8dn2KHQob+GuPSGR0dryQa1PQJbzjF3dqO/whhjLg==
   dependencies:
     "@emnapi/core" "1.10.0"
     "@emnapi/runtime" "1.10.0"
     "@napi-rs/wasm-runtime" "^1.1.4"
 
-"@rolldown/binding-win32-arm64-msvc@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-rc.18.tgz#8c2117d68331d7de59d24631146d538fc203d27c"
-  integrity sha512-zsu47DgU0FQzSwi6sU9dZoEdUv7pc1AptSEz/Z8HBg54sV0Pbs3N0+CrIbTsgiu6EyoaNN9CHboqbLaz9lhOyQ==
+"@rolldown/binding-win32-arm64-msvc@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.3.tgz#a004ab607a16d6f03bcb555728ff888af75773ad"
+  integrity sha512-gEdFFEN70A/jxb2svrWsN3aDL7OUtmvlOy+6fa2jxG8K0wQ1ZbdeLGnidov6Yu5/733dI5ySfzFlQ/cb0bSz1g==
 
-"@rolldown/binding-win32-x64-msvc@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-rc.18.tgz#bb5c28df3095046778cc1b020ef52fc5ee7b7e70"
-  integrity sha512-7H+3yqGgmnlDTRRhw/xpYY9J1kf4GC681nVc4GqKhExZTDrVVrV2tsOR9kso0fvgBdcTCcQShx4SLLoHgaLwhg==
-
-"@rolldown/pluginutils@1.0.0-rc.18":
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.18.tgz#51cf2589596a179ebe8cbf313f1358c7b51a2fdc"
-  integrity sha512-CUY5Mnhe64xQBGZEEXQ5WyZwsc1JU3vAZLIxtrsBt3LO6UOb+C8GunVKqe9sT8NeWb4lqSaoJtp2xo6GxT1MNw==
+"@rolldown/binding-win32-x64-msvc@1.0.3":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.3.tgz#e2a25b34691a1cc8a1209d7de709063026dd0cdb"
+  integrity sha512-eXB7CHuaQdqmJcc3koCNtNPmT/bj2gc999kUFgBxG8Ac0NdgXc4rkCHhqrgrhN3zddvvvrgzj1e90SuSfmyIXA==
 
 "@rolldown/pluginutils@1.0.0-rc.7":
   version "1.0.0-rc.7"
   resolved "https://registry.yarnpkg.com/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.7.tgz#0414869467f0e471a6515d4f506c85fde867e022"
   integrity sha512-qujRfC8sFVInYSPPMLQByRh7zhwkGFS4+tyMQ83srV1qrxL4g8E2tyxVVyxd0+8QeBM1mIk9KbWxkegRr76XzA==
 
+"@rolldown/pluginutils@^1.0.0":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz#e3fcee093fbb5ce765e1ad088ff4de2889f6f9be"
+  integrity sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==
+
 "@socket.io/component-emitter@~3.1.0":
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz#821f8442f4175d8f0467b9daf26e3a18e2d02af2"
@@ -3031,10 +3031,10 @@ ms@^2.1.3:
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
-nanoid@^3.3.11:
-  version "3.3.11"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.11.tgz#4f4f112cefbe303202f2199838128936266d185b"
-  integrity sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==
+nanoid@^3.3.12:
+  version "3.3.12"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.12.tgz#ab3d912e217a6d0a514f00a72a16543a28982c05"
+  integrity sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==
 
 natural-compare@^1.4.0:
   version "1.4.0"
@@ -3119,22 +3119,17 @@ picocolors@^1.1.1:
   resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b"
   integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==
 
-picomatch@^4.0.3:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.3.tgz#796c76136d1eead715db1e7bad785dedd695a042"
-  integrity sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==
-
 picomatch@^4.0.4:
   version "4.0.4"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.4.tgz#fd6f5e00a143086e074dffe4c924b8fb293b0589"
   integrity sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==
 
-postcss@^8.5.14:
-  version "8.5.14"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.14.tgz#a66c2d7808fadf69ebb5b84a03f8bafd76c4919c"
-  integrity sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==
+postcss@^8.5.15:
+  version "8.5.15"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.5.15.tgz#d1eaf677a324e9ec02196da2d3fecf4a0b9a735c"
+  integrity sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==
   dependencies:
-    nanoid "^3.3.11"
+    nanoid "^3.3.12"
     picocolors "^1.1.1"
     source-map-js "^1.2.1"
 
@@ -3394,29 +3389,29 @@ resolve-from@^4.0.0:
   resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
-rolldown@1.0.0-rc.18:
-  version "1.0.0-rc.18"
-  resolved "https://registry.yarnpkg.com/rolldown/-/rolldown-1.0.0-rc.18.tgz#c597f89a4ce12e6fc918fa91e4f892b340aa92f0"
-  integrity sha512-phmyKBpuBdRYDf4hgyynGAYn/rDDe+iZXKVJ7WX5b1zQzpLkP5oJRPGsfJuHdzPMlyyEO/4sPW6yfSx2gf7lVg==
+rolldown@1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/rolldown/-/rolldown-1.0.3.tgz#db88a3008fb0e28230a00423727ce75ba32121ac"
+  integrity sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g==
   dependencies:
-    "@oxc-project/types" "=0.128.0"
-    "@rolldown/pluginutils" "1.0.0-rc.18"
+    "@oxc-project/types" "=0.133.0"
+    "@rolldown/pluginutils" "^1.0.0"
   optionalDependencies:
-    "@rolldown/binding-android-arm64" "1.0.0-rc.18"
-    "@rolldown/binding-darwin-arm64" "1.0.0-rc.18"
-    "@rolldown/binding-darwin-x64" "1.0.0-rc.18"
-    "@rolldown/binding-freebsd-x64" "1.0.0-rc.18"
-    "@rolldown/binding-linux-arm-gnueabihf" "1.0.0-rc.18"
-    "@rolldown/binding-linux-arm64-gnu" "1.0.0-rc.18"
-    "@rolldown/binding-linux-arm64-musl" "1.0.0-rc.18"
-    "@rolldown/binding-linux-ppc64-gnu" "1.0.0-rc.18"
-    "@rolldown/binding-linux-s390x-gnu" "1.0.0-rc.18"
-    "@rolldown/binding-linux-x64-gnu" "1.0.0-rc.18"
-    "@rolldown/binding-linux-x64-musl" "1.0.0-rc.18"
-    "@rolldown/binding-openharmony-arm64" "1.0.0-rc.18"
-    "@rolldown/binding-wasm32-wasi" "1.0.0-rc.18"
-    "@rolldown/binding-win32-arm64-msvc" "1.0.0-rc.18"
-    "@rolldown/binding-win32-x64-msvc" "1.0.0-rc.18"
+    "@rolldown/binding-android-arm64" "1.0.3"
+    "@rolldown/binding-darwin-arm64" "1.0.3"
+    "@rolldown/binding-darwin-x64" "1.0.3"
+    "@rolldown/binding-freebsd-x64" "1.0.3"
+    "@rolldown/binding-linux-arm-gnueabihf" "1.0.3"
+    "@rolldown/binding-linux-arm64-gnu" "1.0.3"
+    "@rolldown/binding-linux-arm64-musl" "1.0.3"
+    "@rolldown/binding-linux-ppc64-gnu" "1.0.3"
+    "@rolldown/binding-linux-s390x-gnu" "1.0.3"
+    "@rolldown/binding-linux-x64-gnu" "1.0.3"
+    "@rolldown/binding-linux-x64-musl" "1.0.3"
+    "@rolldown/binding-openharmony-arm64" "1.0.3"
+    "@rolldown/binding-wasm32-wasi" "1.0.3"
+    "@rolldown/binding-win32-arm64-msvc" "1.0.3"
+    "@rolldown/binding-win32-x64-msvc" "1.0.3"
 
 scheduler@^0.27.0:
   version "0.27.0"
@@ -3540,18 +3535,10 @@ tapable@^2.3.3:
   resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.3.3.tgz#5da7c9992c46038221267985ab28421a8879f160"
   integrity sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==
 
-tinyglobby@^0.2.15:
-  version "0.2.15"
-  resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.15.tgz#e228dd1e638cea993d2fdb4fcd2d4602a79951c2"
-  integrity sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==
-  dependencies:
-    fdir "^6.5.0"
-    picomatch "^4.0.3"
-
-tinyglobby@^0.2.16:
-  version "0.2.16"
-  resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.16.tgz#1c3b7eb953fce42b226bc5a1ee06428281aff3d6"
-  integrity sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==
+tinyglobby@^0.2.15, tinyglobby@^0.2.17:
+  version "0.2.17"
+  resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.17.tgz#562a9a6c9eb2b3b123d39719f9af5bb44fcd7631"
+  integrity sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==
   dependencies:
     fdir "^6.5.0"
     picomatch "^4.0.4"
@@ -3725,16 +3712,16 @@ vfile@^6.0.0:
     "@types/unist" "^3.0.0"
     vfile-message "^4.0.0"
 
-vite@^8.0.11:
-  version "8.0.11"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-8.0.11.tgz#d128fe82a0dd24da5127d20560735f1cd7ade0a6"
-  integrity sha512-Jz1mxtUBR5xTT65VOdJZUUeoyLtqljmFkiUXhPTLZka3RDc9vpi/xXkyrnsdRcm2lIi3l3GPMnAidTsEGIj3Ow==
+vite@^8.0.16:
+  version "8.0.16"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-8.0.16.tgz#ae073866c06563d6634a90169a496e11bd84f1a6"
+  integrity sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==
   dependencies:
     lightningcss "^1.32.0"
     picomatch "^4.0.4"
-    postcss "^8.5.14"
-    rolldown "1.0.0-rc.18"
-    tinyglobby "^0.2.16"
+    postcss "^8.5.15"
+    rolldown "1.0.3"
+    tinyglobby "^0.2.17"
   optionalDependencies:
     fsevents "~2.3.3"
 

erpnext/__init__.py

@@ -3,8 +3,6 @@ import inspect
 from typing import TypeVar
 
 import frappe
-from frappe.model.document import Document
-from frappe.utils.user import is_website_user
 
 __version__ = "17.0.0-dev"
 
@@ -155,6 +153,8 @@ def allow_regional(fn):
 
 
 def check_app_permission():
+	from frappe.utils.user import is_website_user
+
 	if frappe.session.user == "Administrator":
 		return True
 
@@ -175,6 +175,8 @@ def normalize_ctx_input(T: type) -> callable:
 	- Casting the result to the specified type T
 	"""
 
+	from frappe.model.document import Document
+
 	def decorator(func: callable):
 		# conserve annotations for frappe.utils.typing_validations
 		@functools.wraps(func, assigned=(a for a in functools.WRAPPER_ASSIGNMENTS if a != "__annotations__"))

erpnext/accounts/deferred_revenue.py

@@ -1,6 +1,7 @@
 import frappe
 from frappe import _
 from frappe.email import sendmail_to_system_managers
+from frappe.query_builder.functions import IfNull, Sum
 from frappe.utils import (
 	add_days,
 	add_months,
@@ -53,20 +54,24 @@ def validate_service_stop_date(doc):
 
 
 def build_conditions(process_type, account, company):
-	conditions = ""
-	deferred_account = (
-		"item.deferred_revenue_account" if process_type == "Income" else "item.deferred_expense_account"
-	)
+	if process_type == "Income":
+		item = frappe.qb.DocType("Sales Invoice Item")
+		parent = frappe.qb.DocType("Sales Invoice")
+		deferred_account = item.deferred_revenue_account
+	else:
+		item = frappe.qb.DocType("Purchase Invoice Item")
+		parent = frappe.qb.DocType("Purchase Invoice")
+		deferred_account = item.deferred_expense_account
 
 	if account:
-		conditions += f"AND {deferred_account}={frappe.db.escape(account)}"
+		return deferred_account == account
 	elif company:
-		conditions += f"AND p.company = {frappe.db.escape(company)}"
+		return parent.company == company
 
-	return conditions
+	return None
 
 
-def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_date=None, conditions=""):
+def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_date=None, conditions=None):
 	# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
 
 	if not start_date:
@@ -75,17 +80,25 @@ def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_d
 		end_date = add_days(today(), -1)
 
 	# check for the purchase invoice for which GL entries has to be done
-	invoices = frappe.db.sql_list(
-		f"""
-		select distinct item.parent
-		from `tabPurchase Invoice Item` item, `tabPurchase Invoice` p
-		where item.service_start_date<=%s and item.service_end_date>=%s
-		and item.enable_deferred_expense = 1 and item.parent=p.name
-		and item.docstatus = 1 and ifnull(item.amount, 0) > 0
-		{conditions}
-	""",
-		(end_date, start_date),
-	)  # nosec
+	item = frappe.qb.DocType("Purchase Invoice Item")
+	parent = frappe.qb.DocType("Purchase Invoice")
+	query = (
+		frappe.qb.from_(item)
+		.inner_join(parent)
+		.on(item.parent == parent.name)
+		.select(item.parent)
+		.distinct()
+		.where(
+			(item.service_start_date <= end_date)
+			& (item.service_end_date >= start_date)
+			& (item.enable_deferred_expense == 1)
+			& (item.docstatus == 1)
+			& (IfNull(item.amount, 0) > 0)
+		)
+	)
+	if conditions is not None:
+		query = query.where(conditions)
+	invoices = query.run(pluck=True)
 
 	# For each invoice, book deferred expense
 	for invoice in invoices:
@@ -96,7 +109,7 @@ def convert_deferred_expense_to_expense(deferred_process, start_date=None, end_d
 		send_mail(deferred_process)
 
 
-def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_date=None, conditions=""):
+def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_date=None, conditions=None):
 	# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
 
 	if not start_date:
@@ -105,17 +118,25 @@ def convert_deferred_revenue_to_income(deferred_process, start_date=None, end_da
 		end_date = add_days(today(), -1)
 
 	# check for the sales invoice for which GL entries has to be done
-	invoices = frappe.db.sql_list(
-		f"""
-		select distinct item.parent
-		from `tabSales Invoice Item` item, `tabSales Invoice` p
-		where item.service_start_date<=%s and item.service_end_date>=%s
-		and item.enable_deferred_revenue = 1 and item.parent=p.name
-		and item.docstatus = 1 and ifnull(item.amount, 0) > 0
-		{conditions}
-	""",
-		(end_date, start_date),
-	)  # nosec
+	item = frappe.qb.DocType("Sales Invoice Item")
+	parent = frappe.qb.DocType("Sales Invoice")
+	query = (
+		frappe.qb.from_(item)
+		.inner_join(parent)
+		.on(item.parent == parent.name)
+		.select(item.parent)
+		.distinct()
+		.where(
+			(item.service_start_date <= end_date)
+			& (item.service_end_date >= start_date)
+			& (item.enable_deferred_revenue == 1)
+			& (item.docstatus == 1)
+			& (IfNull(item.amount, 0) > 0)
+		)
+	)
+	if conditions is not None:
+		query = query.where(conditions)
+	invoices = query.run(pluck=True)
 
 	for invoice in invoices:
 		doc = frappe.get_doc("Sales Invoice", invoice)
@@ -136,26 +157,39 @@ def get_booking_dates(doc, item, posting_date=None, prev_posting_date=None):
 	)
 
 	if not prev_posting_date:
-		prev_gl_entry = frappe.db.sql(
-			"""
-			select name, posting_date from `tabGL Entry` where company=%s and account=%s and
-			voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
-			and is_cancelled = 0
-			order by posting_date desc limit 1
-		""",
-			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-			as_dict=True,
+		prev_gl_entry = frappe.get_all(
+			"GL Entry",
+			filters={
+				"company": doc.company,
+				"account": item.get(deferred_account),
+				"voucher_type": doc.doctype,
+				"voucher_no": doc.name,
+				"voucher_detail_no": item.name,
+				"is_cancelled": 0,
+			},
+			fields=["name", "posting_date"],
+			order_by="posting_date desc",
+			limit=1,
 		)
 
-		prev_gl_via_je = frappe.db.sql(
-			"""
-			SELECT p.name, p.posting_date FROM `tabJournal Entry` p, `tabJournal Entry Account` c
-			WHERE p.name = c.parent and p.company=%s and c.account=%s
-			and c.reference_type=%s and c.reference_name=%s
-			and c.reference_detail_no=%s and c.docstatus < 2 order by posting_date desc limit 1
-		""",
-			(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-			as_dict=True,
+		je = frappe.qb.DocType("Journal Entry")
+		jea = frappe.qb.DocType("Journal Entry Account")
+		prev_gl_via_je = (
+			frappe.qb.from_(je)
+			.inner_join(jea)
+			.on(je.name == jea.parent)
+			.select(je.name, je.posting_date)
+			.where(
+				(je.company == doc.company)
+				& (jea.account == item.get(deferred_account))
+				& (jea.reference_type == doc.doctype)
+				& (jea.reference_name == doc.name)
+				& (jea.reference_detail_no == item.name)
+				& (jea.docstatus < 2)
+			)
+			.orderby(je.posting_date, order=frappe.qb.desc)
+			.limit(1)
+			.run(as_dict=True)
 		)
 
 		if prev_gl_via_je:
@@ -277,26 +311,47 @@ def get_already_booked_amount(doc, item):
 		total_credit_debit, total_credit_debit_currency = "credit", "credit_in_account_currency"
 		deferred_account = "deferred_expense_account"
 
-	gl_entries_details = frappe.db.sql(
-		"""
-		select sum({}) as total_credit, sum({}) as total_credit_in_account_currency, voucher_detail_no
-		from `tabGL Entry` where company=%s and account=%s and voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
-		and is_cancelled = 0
-		group by voucher_detail_no
-	""".format(total_credit_debit, total_credit_debit_currency),
-		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-		as_dict=True,
+	gle = frappe.qb.DocType("GL Entry")
+	gl_entries_details = (
+		frappe.qb.from_(gle)
+		.select(
+			Sum(gle[total_credit_debit]).as_("total_credit"),
+			Sum(gle[total_credit_debit_currency]).as_("total_credit_in_account_currency"),
+			gle.voucher_detail_no,
+		)
+		.where(
+			(gle.company == doc.company)
+			& (gle.account == item.get(deferred_account))
+			& (gle.voucher_type == doc.doctype)
+			& (gle.voucher_no == doc.name)
+			& (gle.voucher_detail_no == item.name)
+			& (gle.is_cancelled == 0)
+		)
+		.groupby(gle.voucher_detail_no)
+		.run(as_dict=True)
 	)
 
-	journal_entry_details = frappe.db.sql(
-		"""
-		SELECT sum(c.{}) as total_credit, sum(c.{}) as total_credit_in_account_currency, reference_detail_no
-		FROM `tabJournal Entry` p , `tabJournal Entry Account` c WHERE p.name = c.parent and
-		p.company = %s and c.account=%s and c.reference_type=%s and c.reference_name=%s and c.reference_detail_no=%s
-		and p.docstatus < 2 group by reference_detail_no
-	""".format(total_credit_debit, total_credit_debit_currency),
-		(doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name),
-		as_dict=True,
+	je = frappe.qb.DocType("Journal Entry")
+	jea = frappe.qb.DocType("Journal Entry Account")
+	journal_entry_details = (
+		frappe.qb.from_(je)
+		.inner_join(jea)
+		.on(je.name == jea.parent)
+		.select(
+			Sum(jea[total_credit_debit]).as_("total_credit"),
+			Sum(jea[total_credit_debit_currency]).as_("total_credit_in_account_currency"),
+			jea.reference_detail_no,
+		)
+		.where(
+			(je.company == doc.company)
+			& (jea.account == item.get(deferred_account))
+			& (jea.reference_type == doc.doctype)
+			& (jea.reference_name == doc.name)
+			& (jea.reference_detail_no == item.name)
+			& (je.docstatus < 2)
+		)
+		.groupby(jea.reference_detail_no)
+		.run(as_dict=True)
 	)
 
 	already_booked_amount = gl_entries_details[0].total_credit if gl_entries_details else 0

erpnext/accounts/doctype/account/account.py

@@ -234,7 +234,7 @@ class Account(NestedSet):
 			if not frappe.db.get_value(
 				"Account", {"account_name": self.account_name, "company": ancestors[0]}, "name"
 			):
-				frappe.throw(_("Please add the account to root level Company - {}").format(ancestors[0]))
+				frappe.throw(_("Please add the account to root level Company - {0}").format(ancestors[0]))
 		elif self.parent_account:
 			descendants = get_descendants_of("Company", self.company)
 			if not descendants:
@@ -592,10 +592,12 @@ def update_account_number(
 @frappe.whitelist()
 def merge_account(old: str, new: str):
 	_ensure_idle_system()
-	# Validate properties before merging
 	new_account = frappe.get_cached_doc("Account", new)
 	old_account = frappe.get_cached_doc("Account", old)
 
+	new_account.check_permission("write")
+	old_account.check_permission("write")
+
 	if not new_account:
 		throw(_("Account {0} does not exist").format(new))
 
@@ -669,7 +671,7 @@ def _ensure_idle_system():
 	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."
+				"Last GL Entry update was done {0}. 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/account_tree.js

@@ -236,9 +236,9 @@ frappe.treeview_settings["Account"] = {
 				function () {
 					let root_company = treeview.page.fields_dict.root_company.get_value();
 					if (root_company) {
-						frappe.throw(__("Please add the account to root level Company - {0}"), [
-							root_company,
-						]);
+						frappe.throw(
+							__("Please add the account to root level Company - {0}", [root_company])
+						);
 					} else {
 						treeview.new_node();
 					}

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

@@ -137,7 +137,7 @@ def get_charts_for_country(country: str, with_standard: bool = False):
 
 	def _get_chart_name(content):
 		if content:
-			content = json.loads(content)
+			content = frappe.parse_json(content)
 			if (
 				content and content.get("disabled", "No") == "No"
 			) or frappe.local.flags.allow_unverified_charts:

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

@@ -0,0 +1,449 @@
+{
+	"country_code": "nz",
+	"name": "New Zealand - Chart of Accounts with Account Numbers",
+	"disabled": "No",
+	"tree": {
+		"Application of Funds (Assets)": {
+			"Current Assets": {
+				"Bank Accounts": {
+					"Business Transaction Account": {
+						"account_number": "11011",
+						"account_type": "Bank"
+					},
+					"Business Savings Account": {
+						"account_number": "11012",
+						"account_type": "Bank"
+					},
+					"account_number": "11010",
+					"is_group": 1
+				},
+				"Cash on Hand": {
+					"account_number": "11020",
+					"account_type": "Cash"
+				},
+				"Accounts Receivable": {
+					"Debtors": {
+						"account_number": "11210",
+						"account_type": "Receivable"
+					},
+					"Provision for Doubtful Debts": {
+						"account_number": "11220"
+					},
+					"account_number": "11200",
+					"is_group": 1
+				},
+				"Inventory": {
+					"Stock on Hand": {
+						"account_number": "11311",
+						"account_type": "Stock"
+					},
+					"Work In Progress": {
+						"account_number": "11312",
+						"account_type": "Stock"
+					},
+					"account_number": "11310",
+					"account_type": "Stock",
+					"is_group": 1
+				},
+				"Prepayments": {
+					"Prepayments": {
+						"account_number": "11411"
+					},
+					"Supplier Advances": {
+						"account_number": "11412"
+					},
+					"Deferred Expense": {
+						"account_number": "11413"
+					},
+					"account_number": "11410",
+					"is_group": 1
+				},
+				"GST Receivable": {
+					"account_number": "11510",
+					"account_type": "Tax"
+				},
+				"Income Tax Receivable": {
+					"account_number": "11520",
+					"account_type": "Tax"
+				},
+				"account_number": "11000",
+				"is_group": 1
+			},
+			"Fixed Assets": {
+				"Plant & Equipment": {
+					"Plant & Equipment": {
+						"account_number": "16011",
+						"account_type": "Fixed Asset"
+					},
+					"Accumulated Depreciation - Plant & Equipment": {
+						"account_number": "16012",
+						"account_type": "Accumulated Depreciation"
+					},
+					"account_number": "16010",
+					"is_group": 1
+				},
+				"Motor Vehicles": {
+					"Motor Vehicles": {
+						"account_number": "16021",
+						"account_type": "Fixed Asset"
+					},
+					"Accumulated Depreciation - Motor Vehicles": {
+						"account_number": "16022",
+						"account_type": "Accumulated Depreciation"
+					},
+					"account_number": "16020",
+					"is_group": 1
+				},
+				"Office Equipment": {
+					"Office Equipment": {
+						"account_number": "16031",
+						"account_type": "Fixed Asset"
+					},
+					"Accumulated Depreciation - Office Equipment": {
+						"account_number": "16032",
+						"account_type": "Accumulated Depreciation"
+					},
+					"account_number": "16030",
+					"is_group": 1
+				},
+				"Buildings": {
+					"Buildings": {
+						"account_number": "16041",
+						"account_type": "Fixed Asset"
+					},
+					"Accumulated Depreciation - Buildings": {
+						"account_number": "16042",
+						"account_type": "Accumulated Depreciation"
+					},
+					"account_number": "16040",
+					"is_group": 1
+				},
+				"Computer Equipment": {
+					"Computer Equipment": {
+						"account_number": "16051",
+						"account_type": "Fixed Asset"
+					},
+					"Accumulated Depreciation - Computer Equipment": {
+						"account_number": "16052",
+						"account_type": "Accumulated Depreciation"
+					},
+					"account_number": "16050",
+					"is_group": 1
+				},
+				"Capital Work in Progress": {
+					"account_number": "16090",
+					"account_type": "Capital Work in Progress"
+				},
+				"account_number": "16000",
+				"is_group": 1
+			},
+			"account_number": "10000",
+			"root_type": "Asset"
+		},
+		"Source of Funds (Liabilities)": {
+			"Current Liabilities": {
+				"Accounts Payable": {
+					"Creditors": {
+						"account_number": "21010",
+						"account_type": "Payable"
+					},
+					"account_number": "21000",
+					"is_group": 1
+				},
+				"Goods Received Not Invoiced": {
+					"account_number": "21100",
+					"account_type": "Stock Received But Not Billed"
+				},
+				"Asset Received Not Invoiced": {
+					"account_number": "21110",
+					"account_type": "Asset Received But Not Billed"
+				},
+				"Service Received Not Invoiced": {
+					"account_number": "21120",
+					"account_type": "Service Received But Not Billed"
+				},
+				"Accrued Expenses": {
+					"account_number": "21200"
+				},
+				"Wages Payable": {
+					"account_number": "21300"
+				},
+				"PAYE Payable": {
+					"account_number": "22010"
+				},
+				"KiwiSaver Payable": {
+					"account_number": "22020"
+				},
+				"ACC Payable": {
+					"account_number": "22030"
+				},
+				"Credit Cards": {
+					"Business Credit Card": {
+						"account_number": "22110"
+					},
+					"account_number": "22100",
+					"is_group": 1
+				},
+				"Customer Advances": {
+					"account_number": "22200"
+				},
+				"Deferred Revenue": {
+					"account_number": "22210"
+				},
+				"Provisional Account": {
+					"account_number": "22220"
+				},
+				"Tax Liabilities": {
+					"GST Payable": {
+						"account_number": "22310",
+						"account_type": "Tax"
+					},
+					"GST Suspense": {
+						"account_number": "22320",
+						"account_type": "Tax"
+					},
+					"FBT Payable": {
+						"account_number": "22330",
+						"account_type": "Tax"
+					},
+					"Income Tax Payable": {
+						"account_number": "22340",
+						"account_type": "Tax"
+					},
+					"account_number": "22300",
+					"is_group": 1
+				},
+				"account_number": "21500",
+				"is_group": 1
+			},
+			"Non-Current Liabilities": {
+				"Bank Loans": {
+					"Bank Loan": {
+						"account_number": "25011"
+					},
+					"account_number": "25010",
+					"is_group": 1
+				},
+				"Lease Liabilities": {
+					"Lease Liability": {
+						"account_number": "25021"
+					},
+					"account_number": "25020",
+					"is_group": 1
+				},
+				"Shareholder Loans": {
+					"Shareholder Loan": {
+						"account_number": "25031"
+					},
+					"account_number": "25030",
+					"is_group": 1
+				},
+				"account_number": "25000",
+				"is_group": 1
+			},
+			"account_number": "20000",
+			"root_type": "Liability"
+		},
+		"Equity": {
+			"Share Capital": {
+				"account_number": "31010",
+				"account_type": "Equity"
+			},
+			"Drawings": {
+				"account_number": "31020",
+				"account_type": "Equity"
+			},
+			"Current Year Earnings": {
+				"account_number": "35010",
+				"account_type": "Equity"
+			},
+			"Retained Earnings": {
+				"account_number": "35020",
+				"account_type": "Equity"
+			},
+			"account_number": "30000",
+			"root_type": "Equity"
+		},
+		"Income": {
+			"Sales": {
+				"account_number": "41010",
+				"account_type": "Income Account"
+			},
+			"Other Income": {
+				"Interest Income": {
+					"account_number": "47010",
+					"account_type": "Income Account"
+				},
+				"Rounding Gain/Loss": {
+					"account_number": "47020",
+					"account_type": "Income Account"
+				},
+				"Foreign Exchange Gain": {
+					"account_number": "47030",
+					"account_type": "Income Account"
+				},
+				"account_number": "47000",
+				"is_group": 1
+			},
+			"account_number": "40000",
+			"root_type": "Income"
+		},
+		"Expenses": {
+			"Cost of Goods Sold": {
+				"Purchases": {
+					"account_number": "51010",
+					"account_type": "Cost of Goods Sold"
+				},
+				"Freight Inwards": {
+					"account_number": "51020",
+					"account_type": "Expenses Included In Valuation"
+				},
+				"Duty and Landing Costs": {
+					"account_number": "51030",
+					"account_type": "Expenses Included In Valuation"
+				},
+				"Stock Adjustment": {
+					"account_number": "51040",
+					"account_type": "Stock Adjustment"
+				},
+				"Stock Write Off": {
+					"account_number": "51050",
+					"account_type": "Stock Adjustment"
+				},
+				"account_number": "51000",
+				"account_type": "Cost of Goods Sold",
+				"is_group": 1
+			},
+			"Operating Expenses": {
+				"Wages & Salaries": {
+					"account_number": "61010",
+					"account_type": "Expense Account"
+				},
+				"KiwiSaver Employer Contribution": {
+					"account_number": "61020",
+					"account_type": "Expense Account"
+				},
+				"ACC Levies": {
+					"account_number": "61030",
+					"account_type": "Expense Account"
+				},
+				"Rent": {
+					"account_number": "65010",
+					"account_type": "Expense Account"
+				},
+				"Power": {
+					"account_number": "65020",
+					"account_type": "Expense Account"
+				},
+				"Telephone": {
+					"account_number": "66010",
+					"account_type": "Expense Account"
+				},
+				"Insurance": {
+					"account_number": "64010",
+					"account_type": "Expense Account"
+				},
+				"Accounting Fees": {
+					"account_number": "64020",
+					"account_type": "Expense Account"
+				},
+				"Legal Fees": {
+					"account_number": "64030",
+					"account_type": "Expense Account"
+				},
+				"Advertising and Marketing": {
+					"account_number": "65030",
+					"account_type": "Expense Account"
+				},
+				"Repairs and Maintenance": {
+					"account_number": "65040",
+					"account_type": "Expense Account"
+				},
+				"Freight and Courier": {
+					"account_number": "65050",
+					"account_type": "Expense Account"
+				},
+				"Operating Costs": {
+					"account_number": "65060",
+					"account_type": "Expense Account"
+				},
+				"account_number": "60000",
+				"is_group": 1
+			},
+			"Depreciation and Amortisation": {
+				"Depreciation - Plant & Equipment": {
+					"account_number": "62010",
+					"account_type": "Depreciation"
+				},
+				"Depreciation - Motor Vehicles": {
+					"account_number": "62020",
+					"account_type": "Depreciation"
+				},
+				"Depreciation - Office Equipment": {
+					"account_number": "62030",
+					"account_type": "Depreciation"
+				},
+				"Depreciation - Computer Equipment": {
+					"account_number": "62040",
+					"account_type": "Depreciation"
+				},
+				"account_number": "62000",
+				"is_group": 1
+			},
+			"Finance Costs": {
+				"Bank Charges": {
+					"account_number": "67010",
+					"account_type": "Expense Account"
+				},
+				"Interest Expense": {
+					"account_number": "67020",
+					"account_type": "Expense Account"
+				},
+				"Rounding Off": {
+					"account_number": "67030",
+					"account_type": "Round Off"
+				},
+				"Payment Discounts": {
+					"account_number": "67040",
+					"account_type": "Expense Account"
+				},
+				"account_number": "67000",
+				"is_group": 1
+			},
+			"Income Tax Expense": {
+				"account_number": "81010",
+				"account_type": "Expense Account"
+			},
+			"Foreign Exchange": {
+				"Exchange Gain/Loss": {
+					"account_number": "82010",
+					"account_type": "Expense Account"
+				},
+				"Unrealized Exchange Gain/Loss": {
+					"account_number": "82020",
+					"account_type": "Expense Account"
+				},
+				"account_number": "82000",
+				"is_group": 1
+			},
+			"Bad Debts": {
+				"account_number": "83010",
+				"account_type": "Expense Account"
+			},
+			"Write Off": {
+				"account_number": "83020",
+				"account_type": "Expense Account"
+			},
+			"Gain/Loss on Asset Disposal": {
+				"account_number": "83030",
+				"account_type": "Expense Account"
+			},
+			"Expenses Included In Asset Valuation": {
+				"account_number": "84010",
+				"account_type": "Expenses Included In Asset Valuation"
+			},
+			"account_number": "50000",
+			"root_type": "Expense"
+		}
+	}
+}

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

@@ -570,6 +570,17 @@
 			"account_number": "5000",
 			"is_group": 1,
 			"root_type": "Expense",
+			"Cost of Goods Sold": {
+				"account_number": "5001",
+				"is_group": 1,
+				"root_type": "Expense",
+				"Cost of Goods Sold": {
+					"account_number": "5010",
+					"is_group": 0,
+					"root_type": "Expense",
+					"account_type": "Cost of Goods Sold"
+				}
+			},
 			"Operating Expenses": {
 				"account_number": "5100",
 				"is_group": 1,

erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py

@@ -198,21 +198,9 @@ def add_dimension_to_budget_doctype(df, doc):
 def delete_accounting_dimension(doc):
 	doclist = get_doctypes_with_dimensions()
 
-	frappe.db.sql(
-		"""
-		DELETE FROM `tabCustom Field`
-		WHERE fieldname = {}
-		AND dt IN ({})""".format("%s", ", ".join(["%s"] * len(doclist))),  # nosec
-		tuple([doc.fieldname, *doclist]),
-	)
+	frappe.db.delete("Custom Field", filters={"fieldname": doc.fieldname, "dt": ["in", doclist]})
 
-	frappe.db.sql(
-		"""
-		DELETE FROM `tabProperty Setter`
-		WHERE field_name = {}
-		AND doc_type IN ({})""".format("%s", ", ".join(["%s"] * len(doclist))),  # nosec
-		tuple([doc.fieldname, *doclist]),
-	)
+	frappe.db.delete("Property Setter", filters={"field_name": doc.fieldname, "doc_type": ["in", doclist]})
 
 	budget_against_property = frappe.get_doc("Property Setter", "Budget-budget_against-options")
 	value_list = budget_against_property.value.split("\n")[3:]
@@ -236,7 +224,7 @@ def disable_dimension(doc: str):
 
 
 def toggle_disabling(doc):
-	doc = json.loads(doc)
+	doc = frappe.parse_json(doc)
 
 	if doc.get("disabled"):
 		df = {"read_only": 1}
@@ -273,13 +261,27 @@ def get_accounting_dimensions(as_list=True):
 
 
 def get_checks_for_pl_and_bs_accounts():
-	return 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 AND p.disabled = 0""",
-		as_dict=1,
+	AccountingDimension = frappe.qb.DocType("Accounting Dimension")
+	AccountingDimensionDetail = frappe.qb.DocType("Accounting Dimension Detail")
+
+	query = (
+		frappe.qb.from_(AccountingDimension)
+		.join(AccountingDimensionDetail)
+		.on(AccountingDimension.name == AccountingDimensionDetail.parent)
+		.select(
+			AccountingDimension.label,
+			AccountingDimension.disabled,
+			AccountingDimension.fieldname,
+			AccountingDimensionDetail.default_dimension,
+			AccountingDimensionDetail.company,
+			AccountingDimensionDetail.mandatory_for_pl,
+			AccountingDimensionDetail.mandatory_for_bs,
+		)
+		.where(AccountingDimension.disabled == 0)
 	)
 
+	return query.run(as_dict=1)
+
 
 def get_dimension_with_children(doctype, dimensions):
 	if isinstance(dimensions, str):

erpnext/accounts/doctype/accounting_dimension_filter/accounting_dimension_filter.py

@@ -43,18 +43,19 @@ class AccountingDimensionFilter(Document):
 		self.validate_applicable_accounts()
 
 	def validate_applicable_accounts(self):
-		accounts = frappe.db.sql(
-			"""
-				SELECT a.applicable_on_account as account
-				FROM `tabApplicable On Account` a, `tabAccounting Dimension Filter` d
-				WHERE d.name = a.parent
-				and d.name != %s
-				and d.accounting_dimension = %s
-			""",
-			(self.name, self.accounting_dimension),
-			as_dict=1,
+		ApplicableOnAccount = frappe.qb.DocType("Applicable On Account")
+		AccountingDimensionFilter = frappe.qb.DocType("Accounting Dimension Filter")
+
+		query = (
+			frappe.qb.from_(ApplicableOnAccount)
+			.join(AccountingDimensionFilter)
+			.on(AccountingDimensionFilter.name == ApplicableOnAccount.parent)
+			.select(ApplicableOnAccount.applicable_on_account.as_("account"))
+			.where(AccountingDimensionFilter.name != self.name)
+			.where(AccountingDimensionFilter.accounting_dimension == self.accounting_dimension)
 		)
 
+		accounts = query.run(as_dict=1)
 		account_list = [d.account for d in accounts]
 
 		for account in self.get("accounts"):
@@ -69,22 +70,28 @@ class AccountingDimensionFilter(Document):
 
 
 def get_dimension_filter_map():
-	filters = frappe.db.sql(
-		"""
-		SELECT
-			a.applicable_on_account, d.dimension_value, p.accounting_dimension,
-			p.allow_or_restrict, p.fieldname, a.is_mandatory
-		FROM
-			`tabApplicable On Account` a,
-			`tabAccounting Dimension Filter` p
-		LEFT JOIN `tabAllowed Dimension` d ON d.parent = p.name
-		WHERE
-			p.name = a.parent
-			AND p.disabled = 0
-	""",
-		as_dict=1,
+	ApplicableOnAccount = frappe.qb.DocType("Applicable On Account")
+	AccountingDimensionFilter = frappe.qb.DocType("Accounting Dimension Filter")
+	AllowedDimension = frappe.qb.DocType("Allowed Dimension")
+
+	query = (
+		frappe.qb.from_(AccountingDimensionFilter)
+		.join(ApplicableOnAccount)
+		.on(AccountingDimensionFilter.name == ApplicableOnAccount.parent)
+		.left_join(AllowedDimension)
+		.on(AllowedDimension.parent == AccountingDimensionFilter.name)
+		.select(
+			ApplicableOnAccount.applicable_on_account,
+			AllowedDimension.dimension_value,
+			AccountingDimensionFilter.accounting_dimension,
+			AccountingDimensionFilter.allow_or_restrict,
+			AccountingDimensionFilter.fieldname,
+			ApplicableOnAccount.is_mandatory,
+		)
+		.where(AccountingDimensionFilter.disabled == 0)
 	)
 
+	filters = query.run(as_dict=1)
 	dimension_filter_map = {}
 
 	for f in filters:

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -46,23 +46,19 @@ class AccountingPeriod(Document):
 		self.name = " - ".join([self.period_name, company_abbr])
 
 	def validate_overlap(self):
-		existing_accounting_period = frappe.db.sql(
-			"""select name from `tabAccounting Period`
-			where (
-				(%(start_date)s between start_date and end_date)
-				or (%(end_date)s between start_date and end_date)
-				or (start_date between %(start_date)s and %(end_date)s)
-				or (end_date between %(start_date)s and %(end_date)s)
-			) and name!=%(name)s and company=%(company)s""",
-			{
-				"start_date": self.start_date,
-				"end_date": self.end_date,
-				"name": self.name,
-				"company": self.company,
-			},
-			as_dict=True,
+		AccountingPeriod = frappe.qb.DocType("Accounting Period")
+
+		query = (
+			frappe.qb.from_(AccountingPeriod)
+			.select(AccountingPeriod.name)
+			.where(AccountingPeriod.start_date <= self.end_date)
+			.where(AccountingPeriod.end_date >= self.start_date)
+			.where(AccountingPeriod.name != self.name)
+			.where(AccountingPeriod.company == self.company)
 		)
 
+		existing_accounting_period = query.run(as_dict=True)
+
 		if len(existing_accounting_period) > 0:
 			frappe.throw(
 				_("Accounting Period overlaps with {0}").format(existing_accounting_period[0].get("name")),

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -10,6 +10,9 @@ frappe.ui.form.on("Accounts Settings", {
 				},
 			};
 		});
+		if (!frm.naming_controller) frm.naming_controller = new frappe.ui.NamingSeriesController(frm);
+
+		frm.naming_controller.render_table("transaction_naming_html", get_transactions(frm));
 	},
 	enable_immutable_ledger: function (frm) {
 		if (!frm.doc.enable_immutable_ledger) {
@@ -49,3 +52,16 @@ function toggle_tax_settings(frm, field_name) {
 		frm.set_value(other_field, 0);
 	}
 }
+
+function get_transactions(frm) {
+	const transactions = [
+		{ label: __("Journal Entry"), doctype: "Journal Entry" },
+		{ label: __("Payment Entry"), doctype: "Payment Entry" },
+		{ label: __("Purchase Invoice"), doctype: "Purchase Invoice" },
+		{ label: __("Purchase Order"), doctype: "Purchase Order" },
+		{ label: __("Purchase Receipt"), doctype: "Purchase Receipt" },
+		{ label: __("Sales Invoice"), doctype: "Sales Invoice" },
+	];
+
+	return transactions;
+}

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -23,9 +23,9 @@
   "confirm_before_resetting_posting_date",
   "preview_mode",
   "analytics_section",
+  "enable_discounts_and_margin",
   "enable_accounting_dimensions",
   "column_break_vtnr",
-  "enable_discounts_and_margin",
   "journals_section",
   "merge_similar_account_heads",
   "deferred_accounting_settings_section",
@@ -44,7 +44,6 @@
   "print_settings",
   "show_inclusive_tax_in_print",
   "show_taxes_as_table_in_print",
-  "column_break_12",
   "show_payment_schedule_in_print",
   "item_price_settings_section",
   "maintain_same_internal_transaction_rate",
@@ -60,39 +59,41 @@
   "payments_tab",
   "section_break_jpd0",
   "auto_reconcile_payments",
+  "exchange_gain_loss_posting_date",
   "auto_reconciliation_job_trigger",
   "reconciliation_queue_size",
   "column_break_resa",
-  "exchange_gain_loss_posting_date",
   "repost_section",
+  "column_break_mfor",
   "repost_allowed_types",
   "payment_options_section",
+  "fetch_payment_schedule_in_payment_request",
   "enable_loyalty_point_program",
   "column_break_ctam",
-  "fetch_payment_schedule_in_payment_request",
   "invoicing_settings_tab",
   "accounts_transactions_settings_section",
-  "over_billing_allowance",
-  "column_break_11",
-  "role_allowed_to_over_bill",
-  "credit_controller",
   "make_payment_via_journal_entry",
+  "over_billing_allowance",
+  "credit_controller",
+  "role_allowed_to_over_bill",
+  "column_break_11",
   "assets_tab",
   "asset_settings_section",
-  "calculate_depr_using_total_days",
-  "column_break_gjcc",
   "book_asset_depreciation_entry_automatically",
+  "calculate_depr_using_total_days",
   "role_to_notify_on_depreciation_failure",
+  "column_break_gjcc",
   "closing_settings_tab",
   "period_closing_settings_section",
   "ignore_account_closing_balance",
   "use_legacy_controller_for_pcv",
+  "pcv_job_timeout",
   "column_break_25",
   "reports_tab",
   "remarks_section",
   "general_ledger_remarks_length",
-  "column_break_lvjk",
   "receivable_payable_remarks_length",
+  "column_break_lvjk",
   "accounts_receivable_payable_tuning_section",
   "receivable_payable_fetch_method",
   "default_ageing_range",
@@ -104,13 +105,15 @@
   "show_balance_in_coa",
   "banking_section",
   "enable_party_matching",
+  "automatically_run_rules_on_unreconciled_transactions",
   "enable_fuzzy_matching",
   "transfer_match_days",
-  "automatically_run_rules_on_unreconciled_transactions",
   "payment_request_section",
   "create_pr_in_draft_status",
   "budget_section",
-  "use_legacy_budget_controller"
+  "use_legacy_budget_controller",
+  "document_naming_tab",
+  "transaction_naming_html"
  ],
  "fields": [
   {
@@ -118,14 +121,14 @@
    "description": "Address used to determine Tax Category in transactions",
    "fieldname": "determine_address_tax_category_from",
    "fieldtype": "Select",
-   "label": "Determine Address Tax Category From",
+   "label": "Determine Address Tax Category from",
    "options": "Billing Address\nShipping Address"
   },
   {
    "fieldname": "credit_controller",
    "fieldtype": "Link",
    "in_list_view": 1,
-   "label": "Role allowed to bypass Credit Limit",
+   "label": "Role allowed to bypass credit limit",
    "options": "Role"
   },
   {
@@ -133,7 +136,7 @@
    "description": "Enabling this ensures each Purchase Invoice has a unique value in Supplier Invoice No. field within a particular fiscal year",
    "fieldname": "check_supplier_invoice_uniqueness",
    "fieldtype": "Check",
-   "label": "Check Supplier Invoice Number Uniqueness"
+   "label": "Check Supplier invoice number uniqueness"
   },
   {
    "default": "0",
@@ -144,27 +147,29 @@
   },
   {
    "default": "1",
+   "documentation_url": "https://docs.frappe.io/erpnext/accounts-settings#4-unlink-payment-on-cancellation-of-invoice",
    "fieldname": "unlink_payment_on_cancellation_of_invoice",
    "fieldtype": "Check",
-   "label": "Unlink Payment on Cancellation of Invoice"
+   "label": "Unlink Payment on cancellation of invoice"
   },
   {
    "default": "1",
+   "documentation_url": "https://docs.frappe.io/erpnext/accounts-settings#8-unlink-advance-payment-on-cancellation-of-order",
    "fieldname": "unlink_advance_payment_on_cancelation_of_order",
    "fieldtype": "Check",
-   "label": "Unlink Advance Payment on Cancellation of Order"
+   "label": "Unlink Advance Payment on cancellation of order"
   },
   {
    "default": "1",
    "fieldname": "book_asset_depreciation_entry_automatically",
    "fieldtype": "Check",
-   "label": "Book Asset Depreciation Entry Automatically"
+   "label": "Book Asset Depreciation entry automatically"
   },
   {
    "default": "1",
    "fieldname": "add_taxes_from_item_tax_template",
    "fieldtype": "Check",
-   "label": "Automatically Add Taxes and Charges from Item Tax Template"
+   "label": "Automatically add Taxes and Charges from Item Tax Template"
   },
   {
    "fieldname": "print_settings",
@@ -175,17 +180,13 @@
    "default": "0",
    "fieldname": "show_inclusive_tax_in_print",
    "fieldtype": "Check",
-   "label": "Show Inclusive Tax in Print"
-  },
-  {
-   "fieldname": "column_break_12",
-   "fieldtype": "Column Break"
+   "label": "Show inclusive tax in print"
   },
   {
    "default": "0",
    "fieldname": "show_payment_schedule_in_print",
    "fieldtype": "Check",
-   "label": "Show Payment Schedule in Print"
+   "label": "Show Payment Schedule in print"
   },
   {
    "fieldname": "currency_exchange_section",
@@ -211,7 +212,7 @@
    "description": "Payment Terms from orders will be fetched into the invoices as is",
    "fieldname": "automatically_fetch_payment_terms",
    "fieldtype": "Check",
-   "label": "Automatically Fetch Payment Terms from Order/Quotation"
+   "label": "Automatically fetch Payment Terms from Order/Quotation"
   },
   {
    "description": "The percentage you are allowed to bill more against the amount ordered. For example, if the order value is $100 for an item and tolerance is set as 10%, then you are allowed to bill up to $110 ",
@@ -223,7 +224,7 @@
    "default": "1",
    "fieldname": "automatically_process_deferred_accounting_entry",
    "fieldtype": "Check",
-   "label": "Automatically Process Deferred Accounting Entry"
+   "label": "Automatically process deferred Accounting entry"
   },
   {
    "fieldname": "deferred_accounting_settings_section",
@@ -239,7 +240,7 @@
    "description": "If this is unchecked, direct GL entries will be created to book deferred revenue or expense",
    "fieldname": "book_deferred_entries_via_journal_entry",
    "fieldtype": "Check",
-   "label": "Book Deferred Entries Via Journal Entry"
+   "label": "Book deferred entries via Journal Entry"
   },
   {
    "default": "0",
@@ -247,38 +248,37 @@
    "description": "If this is unchecked Journal Entries will be saved in a Draft state and will have to be submitted manually",
    "fieldname": "submit_journal_entries",
    "fieldtype": "Check",
-   "label": "Submit Journal Entries"
+   "label": "Submit Journal entries"
   },
   {
    "default": "Days",
    "description": "If \"Months\" is selected, a fixed amount will be booked as deferred revenue or expense for each month irrespective of the number of days in a month. It will be prorated if deferred revenue or expense is not booked for an entire month",
    "fieldname": "book_deferred_entries_based_on",
    "fieldtype": "Select",
-   "label": "Book Deferred Entries Based On",
+   "label": "Book Deferred entries based on",
    "options": "Days\nMonths"
   },
   {
    "default": "0",
    "fieldname": "delete_linked_ledger_entries",
    "fieldtype": "Check",
-   "label": "Delete Accounting and Stock Ledger Entries on deletion of Transaction"
+   "label": "Delete Accounting and Stock Ledger entries on deletion of transaction"
   },
   {
+   "depends_on": "eval: doc.over_billing_allowance > 0",
    "description": "Users with this role are allowed to over bill above the allowance percentage",
    "fieldname": "role_allowed_to_over_bill",
    "fieldtype": "Link",
-   "label": "Role Allowed to Over Bill ",
+   "label": "Role Allowed to over bill ",
    "options": "Role"
   },
   {
    "fieldname": "period_closing_settings_section",
-   "fieldtype": "Section Break",
-   "label": "Period Closing Settings"
+   "fieldtype": "Section Break"
   },
   {
    "fieldname": "accounts_transactions_settings_section",
-   "fieldtype": "Section Break",
-   "label": "Credit Limit Settings"
+   "fieldtype": "Section Break"
   },
   {
    "fieldname": "column_break_11",
@@ -363,14 +363,14 @@
    "default": "1",
    "fieldname": "show_balance_in_coa",
    "fieldtype": "Check",
-   "label": "Show Balances in Chart Of Accounts"
+   "label": "Show balances in Chart of Accounts"
   },
   {
    "default": "0",
    "description": "Split Early Payment Discount Loss into Income and Tax Loss",
    "fieldname": "book_tax_discount_loss",
    "fieldtype": "Check",
-   "label": "Book Tax Loss on Early Payment Discount"
+   "label": "Book tax loss on early payment discount"
   },
   {
    "fieldname": "journals_section",
@@ -382,7 +382,7 @@
    "description": "Rows with Same Account heads will be merged on Ledger",
    "fieldname": "merge_similar_account_heads",
    "fieldtype": "Check",
-   "label": "Merge Similar Account Heads"
+   "label": "Merge similar Account Heads"
   },
   {
    "fieldname": "section_break_jpd0",
@@ -393,13 +393,13 @@
    "default": "0",
    "fieldname": "auto_reconcile_payments",
    "fieldtype": "Check",
-   "label": "Auto Reconcile Payments"
+   "label": "Auto reconcile Payments"
   },
   {
    "default": "0",
    "fieldname": "show_taxes_as_table_in_print",
    "fieldtype": "Check",
-   "label": "Show Taxes as Table in Print"
+   "label": "Show taxes as table in print"
   },
   {
    "default": "0",
@@ -421,14 +421,14 @@
    "description": "Financial reports will be generated using GL Entry doctypes (should be enabled if Period Closing Voucher is not posted for all years sequentially or missing) ",
    "fieldname": "ignore_account_closing_balance",
    "fieldtype": "Check",
-   "label": "Ignore Account Closing Balance"
+   "label": "Ignore Account closing balance"
   },
   {
    "default": "0",
    "description": "Tax Amount will be rounded on a row(items) level",
    "fieldname": "round_row_wise_tax",
    "fieldtype": "Check",
-   "label": "Round Tax Amount Row-wise"
+   "label": "Round tax amount row-wise"
   },
   {
    "fieldname": "reports_tab",
@@ -440,14 +440,14 @@
    "description": "Truncates 'Remarks' column to set character length",
    "fieldname": "general_ledger_remarks_length",
    "fieldtype": "Int",
-   "label": "General Ledger"
+   "label": "General Ledger remarks length"
   },
   {
    "default": "0",
    "description": "Truncates 'Remarks' column to set character length",
    "fieldname": "receivable_payable_remarks_length",
    "fieldtype": "Int",
-   "label": "Accounts Receivable/Payable"
+   "label": "Accounts Receivable / Payable remarks length"
   },
   {
    "fieldname": "column_break_lvjk",
@@ -481,7 +481,7 @@
    "description": "Payment Requests made from Sales / Purchase Invoice will be put in Draft explicitly",
    "fieldname": "create_pr_in_draft_status",
    "fieldtype": "Check",
-   "label": "Create in Draft Status"
+   "label": "Create payment requests in Draft status"
   },
   {
    "fieldname": "column_break_yuug",
@@ -496,14 +496,14 @@
    "description": "Interval should be between 1 to 59 MInutes",
    "fieldname": "auto_reconciliation_job_trigger",
    "fieldtype": "Int",
-   "label": "Auto Reconciliation Job Trigger"
+   "label": "Auto Reconciliation job trigger"
   },
   {
    "default": "5",
    "description": "Documents Processed on each trigger. Queue Size should be between 5 and 100",
    "fieldname": "reconciliation_queue_size",
    "fieldtype": "Int",
-   "label": "Reconciliation Queue Size"
+   "label": "Reconciliation queue size"
   },
   {
    "default": "0",
@@ -517,14 +517,14 @@
    "description": "Only applies for Normal Payments",
    "fieldname": "exchange_gain_loss_posting_date",
    "fieldtype": "Select",
-   "label": "Posting Date Inheritance for Exchange Gain / Loss",
+   "label": "Posting Date inheritance for exchange gain / loss",
    "options": "Invoice\nPayment\nReconciliation Date"
   },
   {
    "default": "Buffered Cursor",
    "fieldname": "receivable_payable_fetch_method",
    "fieldtype": "Select",
-   "label": "Data Fetch Method",
+   "label": "Data fetch method",
    "options": "Buffered Cursor\nUnBuffered Cursor"
   },
   {
@@ -541,14 +541,14 @@
    "default": "0",
    "fieldname": "maintain_same_internal_transaction_rate",
    "fieldtype": "Check",
-   "label": "Maintain Same Rate Throughout Internal Transaction"
+   "label": "Maintain same rate throughout internal Transaction"
   },
   {
    "default": "Stop",
    "depends_on": "maintain_same_internal_transaction_rate",
    "fieldname": "maintain_same_rate_action",
    "fieldtype": "Select",
-   "label": "Action if Same Rate is Not Maintained Throughout  Internal Transaction",
+   "label": "Action if same rate is not maintained throughout internal transaction",
    "mandatory_depends_on": "maintain_same_internal_transaction_rate",
    "options": "Stop\nWarn"
   },
@@ -556,7 +556,7 @@
    "depends_on": "eval: doc.maintain_same_internal_transaction_rate && doc.maintain_same_rate_action == 'Stop'",
    "fieldname": "role_to_override_stop_action",
    "fieldtype": "Link",
-   "label": "Role Allowed to Override Stop Action",
+   "label": "Role allowed to override stop action",
    "options": "Role"
   },
   {
@@ -588,7 +588,7 @@
    "description": "If no taxes are set, and Taxes and Charges Template is selected, the system will automatically apply the taxes from the chosen template.",
    "fieldname": "add_taxes_from_taxes_and_charges_template",
    "fieldtype": "Check",
-   "label": "Automatically Add Taxes from Taxes and Charges Template"
+   "label": "Automatically add taxes from Taxes and Charges Template"
   },
   {
    "fieldname": "column_break_ntmi",
@@ -598,19 +598,28 @@
    "default": "0",
    "fieldname": "fetch_valuation_rate_for_internal_transaction",
    "fieldtype": "Check",
-   "label": "Fetch Valuation Rate for Internal Transaction"
+   "label": "Fetch valuation rate for internal Transaction"
   },
   {
    "default": "0",
+   "description": "Enable this if you are experiencing issues with the new budget controller. Uses the older budget validation logic",
    "fieldname": "use_legacy_budget_controller",
    "fieldtype": "Check",
-   "label": "Use Legacy Budget Controller"
+   "label": "Use legacy Budget Controller"
   },
   {
    "default": "1",
    "fieldname": "use_legacy_controller_for_pcv",
    "fieldtype": "Check",
-   "label": "Use Legacy Controller For Period Closing Voucher"
+   "label": "Use legacy controller for Period Closing Voucher"
+  },
+  {
+   "default": "3600",
+   "depends_on": "eval: !doc.use_legacy_controller_for_pcv",
+   "description": "Timeout (in seconds) for each background job enqueued by Process Period Closing Voucher",
+   "fieldname": "pcv_job_timeout",
+   "fieldtype": "Int",
+   "label": "PCV Job Timeout (seconds)"
   },
   {
    "description": "Users with this role will be notified if the asset depreciation gets failed",
@@ -628,7 +637,7 @@
   {
    "fieldname": "chart_of_accounts_section",
    "fieldtype": "Section Break",
-   "label": "Chart Of Accounts"
+   "label": "Chart of Accounts"
   },
   {
    "fieldname": "banking_section",
@@ -673,6 +682,7 @@
   },
   {
    "default": "0",
+   "documentation_url": "https://docs.frappe.io/erpnext/loyalty-program",
    "fieldname": "enable_loyalty_point_program",
    "fieldtype": "Check",
    "label": "Enable Loyalty Point Program"
@@ -699,7 +709,7 @@
    "default": "1",
    "fieldname": "fetch_payment_schedule_in_payment_request",
    "fieldtype": "Check",
-   "label": "Fetch Payment Schedule In Payment Request"
+   "label": "Fetch Payment Schedule in Payment Request"
   },
   {
    "default": "3",
@@ -724,7 +734,7 @@
   {
    "fieldname": "repost_allowed_types",
    "fieldtype": "Table",
-   "label": "Allowed Doctypes",
+   "label": "Allowed DocTypes",
    "options": "Repost Allowed Types"
   },
   {
@@ -732,7 +742,21 @@
    "description": "Runs a preview check on save before submission without making any actual changes.",
    "fieldname": "preview_mode",
    "fieldtype": "Check",
-   "label": "Preview Mode"
+   "label": "Preview mode"
+  },
+  {
+   "fieldname": "document_naming_tab",
+   "fieldtype": "Tab Break",
+   "label": "Document Naming"
+  },
+  {
+   "fieldname": "transaction_naming_html",
+   "fieldtype": "HTML"
+  },
+  {
+   "description": "Changing the account in any transaction of the DocTypes listed below will trigger a repost. To prevent reposting, remove the relevant DocType from the list.",
+   "fieldname": "column_break_mfor",
+   "fieldtype": "Column Break"
   }
  ],
  "grid_page_length": 50,
@@ -741,7 +765,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-05-18 12:16:33.679345",
+ "modified": "2026-06-24 12:59:41.868865",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -90,6 +90,7 @@ class AccountsSettings(Document):
 		make_payment_via_journal_entry: DF.Check
 		merge_similar_account_heads: DF.Check
 		over_billing_allowance: DF.Currency
+		pcv_job_timeout: DF.Int
 		preview_mode: DF.Check
 		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor"]
 		receivable_payable_remarks_length: DF.Int

erpnext/accounts/doctype/advance_payment_ledger_entry/test_advance_payment_ledger_entry.py

@@ -22,11 +22,13 @@ class TestAdvancePaymentLedgerEntry(ERPNextTestSuite, AccountsTestMixin):
 	"""
 
 	def setUp(self):
-		self.create_company()
-		self.create_usd_receivable_account()
-		self.create_usd_payable_account()
-		self.create_item()
-		self.clear_old_entries()
+		self.company = "_Test Company"
+		self.customer = "_Test Customer"
+		self.supplier = "_Test Supplier"
+		self.item = "_Test Item"
+		self.cash = "Cash - _TC"
+		self.debtors_usd = "_Test Receivable USD - _TC"
+		self.creditors_usd = "_Test Payable USD - _TC"
 
 	def create_sales_order(self, qty=1, rate=100, currency="INR", do_not_submit=False):
 		"""

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -27,6 +27,7 @@
   "column_break_12",
   "branch_code",
   "bank_account_no",
+  "statement_password",
   "address_and_contact",
   "address_html",
   "column_break_13",
@@ -149,6 +150,12 @@
    "label": "Bank Account No",
    "length": 30
   },
+  {
+   "description": "Password used to open password-protected PDF statements for this account. Stored encrypted.",
+   "fieldname": "statement_password",
+   "fieldtype": "Password",
+   "label": "Statement PDF Password"
+  },
   {
    "fieldname": "address_and_contact",
    "fieldtype": "Section Break",

erpnext/accounts/doctype/bank_account/bank_account.py

@@ -41,6 +41,7 @@ class BankAccount(Document):
 		mask: DF.Data | None
 		party: DF.DynamicLink | None
 		party_type: DF.Link | None
+		statement_password: DF.Password | None
 	# end: auto-generated types
 
 	def onload(self):

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.json

@@ -1,5 +1,6 @@
 {
  "actions": [],
+ "allow_bulk_edit": 1,
  "allow_rename": 1,
  "creation": "2026-04-11 19:48:13.622253",
  "doctype": "DocType",
@@ -7,7 +8,8 @@
  "field_order": [
   "bank_account",
   "date",
-  "balance"
+  "balance",
+  "company"
  ],
  "fields": [
   {
@@ -31,12 +33,20 @@
    "in_list_view": 1,
    "label": "Balance",
    "reqd": 1
+  },
+  {
+   "fetch_from": "bank_account.company",
+   "fieldname": "company",
+   "fieldtype": "Link",
+   "label": "Company",
+   "options": "Company",
+   "read_only": 1
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2026-04-11 19:49:45.374695",
+ "modified": "2026-06-16 22:17:48.007982",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account Balance",

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.py

@@ -16,6 +16,7 @@ class BankAccountBalance(Document):
 
 		balance: DF.Currency
 		bank_account: DF.Link
+		company: DF.Link | None
 		date: DF.Date
 	# end: auto-generated types
 

erpnext/accounts/doctype/bank_clearance/bank_clearance.py

@@ -7,7 +7,7 @@ from frappe import _, msgprint
 from frappe.model.document import Document
 from frappe.query_builder import Case
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import Coalesce, Sum
+from frappe.query_builder.functions import Coalesce, Max, Sum
 from frappe.utils import cint, flt, fmt_money, getdate
 from pypika import Order
 
@@ -94,6 +94,7 @@ class BankClearance(Document):
 		invalid_document = []
 		invalid_cheque_date = []
 		entries_to_update = []
+		self.check_permission("write")
 
 		def validate_entry(d):
 			is_valid = True
@@ -194,14 +195,17 @@ def get_payment_entries_for_bank_clearance(
 		.select(
 			ConstantColumn("Journal Entry").as_("payment_document"),
 			journal_entry.name.as_("payment_entry"),
-			journal_entry.cheque_no.as_("cheque_number"),
-			journal_entry.cheque_date,
+			# non-grouped columns are constant per grouped JE name / account (against_account is
+			# arbitrary per group on MySQL) -> Max() keeps the GROUP BY valid on postgres with the
+			# same value MySQL picked.
+			Max(journal_entry.cheque_no).as_("cheque_number"),
+			Max(journal_entry.cheque_date).as_("cheque_date"),
 			Sum(journal_entry_account.debit_in_account_currency).as_("debit"),
 			Sum(journal_entry_account.credit_in_account_currency).as_("credit"),
-			journal_entry.posting_date,
-			journal_entry_account.against_account,
-			journal_entry.clearance_date,
-			journal_entry_account.account_currency,
+			Max(journal_entry.posting_date).as_("posting_date"),
+			Max(journal_entry_account.against_account).as_("against_account"),
+			Max(journal_entry.clearance_date).as_("clearance_date"),
+			Max(journal_entry_account.account_currency).as_("account_currency"),
 		)
 		.where(
 			(journal_entry_account.account == account)
@@ -214,12 +218,13 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		journal_entry_query = journal_entry_query.where(
-			(journal_entry.clearance_date.isnull()) | (journal_entry.clearance_date == "0000-00-00")
+			(journal_entry.clearance_date.isnull())
+			| (journal_entry.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
 		)
 
 	journal_entries = (
 		journal_entry_query.groupby(journal_entry_account.account, journal_entry.name)
-		.orderby(journal_entry.posting_date)
+		.orderby(Max(journal_entry.posting_date))
 		.orderby(journal_entry.name, order=Order.desc)
 	).run(as_dict=True)
 
@@ -289,7 +294,8 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		payment_entry_query = payment_entry_query.where(
-			(pe.clearance_date.isnull()) | (pe.clearance_date == "0000-00-00")
+			(pe.clearance_date.isnull())
+			| (pe.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
 		)
 
 	payment_entries = (payment_entry_query.orderby(pe.posting_date).orderby(pe.name, order=Order.desc)).run(
@@ -326,7 +332,8 @@ def get_payment_entries_for_bank_clearance(
 
 	if not include_reconciled_entries:
 		paid_purchase_invoices_query = paid_purchase_invoices_query.where(
-			(pi.clearance_date.isnull()) | (pi.clearance_date == "0000-00-00")
+			(pi.clearance_date.isnull())
+			| (pi.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
 		)
 
 	paid_purchase_invoices = (
@@ -366,7 +373,8 @@ def get_payment_entries_for_bank_clearance(
 
 		if not include_reconciled_entries:
 			pos_sales_invoices_query = pos_sales_invoices_query.where(
-				(si_payment.clearance_date.isnull()) | (si_payment.clearance_date == "0000-00-00")
+				(si_payment.clearance_date.isnull())
+				| (si_payment.clearance_date == ("0000-00-00" if frappe.db.db_type != "postgres" else None))
 			)
 
 		pos_sales_invoices = (

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.js

@@ -9,6 +9,13 @@ cur_frm.add_fetch("bank", "swift_number", "swift_number");
 
 frappe.ui.form.on("Bank Guarantee", {
 	setup: function (frm) {
+		frm.set_query("reference_doctype", function () {
+			return {
+				filters: {
+					name: ["in", ["Sales Order", "Purchase Order"]],
+				},
+			};
+		});
 		frm.set_query("bank_account", function () {
 			return {
 				filters: {

erpnext/accounts/doctype/bank_guarantee/bank_guarantee.json

@@ -1,5 +1,6 @@
 {
  "actions": [],
+ "allow_bulk_edit": 1,
  "autoname": "ACC-BG-.YYYY.-.#####",
  "creation": "2016-12-17 10:43:35.731631",
  "doctype": "DocType",
@@ -50,8 +51,7 @@
    "fieldname": "reference_doctype",
    "fieldtype": "Link",
    "label": "Reference Document Type",
-   "options": "DocType",
-   "read_only": 1
+   "options": "DocType"
   },
   {
    "fieldname": "reference_docname",
@@ -60,14 +60,14 @@
    "options": "reference_doctype"
   },
   {
-   "depends_on": "eval: doc.bg_type == \"Receiving\"",
+   "depends_on": "eval: doc.reference_doctype == \"Sales Order\"",
    "fieldname": "customer",
    "fieldtype": "Link",
    "label": "Customer",
    "options": "Customer"
   },
   {
-   "depends_on": "eval: doc.bg_type == \"Providing\"",
+   "depends_on": "eval: doc.reference_doctype == \"Purchase Order\"",
    "fieldname": "supplier",
    "fieldtype": "Link",
    "label": "Supplier",
@@ -218,10 +218,11 @@
  "grid_page_length": 50,
  "is_submittable": 1,
  "links": [],
- "modified": "2025-08-29 11:52:33.550847",
+ "modified": "2026-05-25 18:12:10.768835",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Guarantee",
+ "naming_rule": "Expression",
  "owner": "Administrator",
  "permissions": [
   {

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -8,7 +8,7 @@ import frappe
 from frappe import _
 from frappe.model.document import Document
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import Sum
+from frappe.query_builder.functions import Max, Sum
 from frappe.utils import cint, create_batch, flt
 
 from erpnext import get_default_cost_center
@@ -518,6 +518,7 @@ def create_internal_transfer(
 	"""
 
 	bank_transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
+	bank_transaction.check_permission("write")
 
 	bank_account = frappe.get_cached_value("Bank Account", bank_transaction.bank_account, "account")
 	company = frappe.get_cached_value("Account", bank_account, "company")
@@ -778,7 +779,6 @@ def create_bulk_payment_entry_and_reconcile(
 	"""
 	Create a payment entry and reconcile it with the bank transaction
 	"""
-
 	output = []
 
 	for bank_transaction_name in bank_transaction_names:
@@ -1058,9 +1058,9 @@ def get_auto_reconcile_message(partially_reconciled, reconciled):
 
 
 @frappe.whitelist()
-def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str, is_new_voucher: bool = False):
+def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str | list, is_new_voucher: bool = False):
 	# updated clear date of all the vouchers based on the bank transaction
-	vouchers = json.loads(vouchers)
+	vouchers = frappe.parse_json(vouchers)
 	transaction = frappe.get_doc("Bank Transaction", bank_transaction_name)
 	transaction.add_payment_entries(vouchers, is_new_voucher)
 	transaction.validate_duplicate_references()
@@ -1410,12 +1410,14 @@ def get_je_matching_query(
 			Sum(getattr(jea, amount_field)).as_("paid_amount"),
 			ConstantColumn("Journal Entry").as_("doctype"),
 			je.name,
-			je.cheque_no.as_("reference_no"),
-			je.cheque_date.as_("reference_date"),
-			je.pay_to_recd_from.as_("party"),
-			jea.party_type,
-			je.posting_date,
-			jea.account_currency.as_("currency"),
+			# non-grouped columns are constant per grouped JE name (party_type/currency come from the
+			# single bank-account line) -> Max() keeps the GROUP BY valid on postgres with the same value
+			Max(je.cheque_no).as_("reference_no"),
+			Max(je.cheque_date).as_("reference_date"),
+			Max(je.pay_to_recd_from).as_("party"),
+			Max(jea.party_type).as_("party_type"),
+			Max(je.posting_date).as_("posting_date"),
+			Max(jea.account_currency).as_("currency"),
 		)
 		.where(je.docstatus == 1)
 		.where(je.voucher_type != "Opening Entry")
@@ -1423,7 +1425,7 @@ def get_je_matching_query(
 		.where(jea.account == common_filters.bank_account)
 		.where(filter_by_date)
 		.groupby(je.name)
-		.orderby(je.cheque_date if cint(filter_by_reference_date) else je.posting_date)
+		.orderby(Max(je.cheque_date) if cint(filter_by_reference_date) else Max(je.posting_date))
 	)
 
 	if frappe.flags.auto_reconcile_vouchers is True:

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -17,9 +17,10 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankReconciliationTool(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.clear_old_entries()
+		self.company = "_Test Company"
+		self.customer = "_Test Customer"
+		self.bank = "HDFC - _TC"
+		self.debit_to = "Debtors - _TC"
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.json

@@ -221,12 +221,12 @@
    "default": "0",
    "fieldname": "import_mt940_fromat",
    "fieldtype": "Check",
-   "label": "Import MT940 Fromat"
+   "label": "Import MT940 Format"
   }
  ],
  "hide_toolbar": 1,
  "links": [],
- "modified": "2026-05-31 00:41:11.251215",
+ "modified": "2026-06-19 14:18:00.000000",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Statement Import",

erpnext/accounts/doctype/bank_statement_import/bank_statement_import.py

@@ -290,7 +290,7 @@ def update_mapping_db(bank, template_options):
 	for d in bank.bank_transaction_mapping:
 		d.delete()
 
-	for d in json.loads(template_options)["column_to_field_map"].items():
+	for d in frappe.parse_json(template_options)["column_to_field_map"].items():
 		bank.append("bank_transaction_mapping", {"bank_transaction_field": d[1], "file_field": d[0]})
 
 	bank.save()

erpnext/accounts/doctype/bank_statement_import_log/bank_statement_import_log.json

@@ -28,7 +28,8 @@
   "detected_transaction_starting_index",
   "detected_transaction_ending_index",
   "section_break_yulq",
-  "column_mapping"
+  "column_mapping",
+  "pdf_tables"
  ],
  "fields": [
   {
@@ -128,6 +129,13 @@
    "label": "Column Mapping",
    "options": "Bank Statement Import Log Column Map"
   },
+  {
+   "description": "Per-table extraction data for PDF statements (rows, bbox, page image, column mapping). Edited via the banking app.",
+   "fieldname": "pdf_tables",
+   "fieldtype": "JSON",
+   "label": "PDF Tables",
+   "read_only": 1
+  },
   {
    "default": "Not Started",
    "fieldname": "status",

erpnext/accounts/doctype/bank_statement_import_log/test_bank_statement_import_log.py

@@ -7,7 +7,18 @@ from frappe.utils import getdate
 
 from erpnext.accounts.doctype.bank_statement_import_log.bank_statement_import_log import (
 	BankStatementImportLog,
+	build_table_transactions,
+	detect_column_mapping,
+	detect_header_row,
+	extract_pdf_tables,
 	get_float_amount,
+	get_statement_details,
+	guess_column_mapping_by_content,
+	reextract_pdf_table,
+	set_header_index,
+	set_pdf_table_header,
+	update_column_mapping,
+	update_pdf_tables,
 )
 from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.tests.utils import ERPNextTestSuite
@@ -15,9 +26,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankStatementImportLog(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.clear_old_entries()
+		self.company = "_Test Company"
+		self.customer = "_Test Customer"
+		self.bank = "HDFC - _TC"
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()
@@ -113,6 +124,346 @@ class TestBankStatementImportLog(ERPNextTestSuite, AccountsTestMixin):
 		self.assertIsNone(get_float_amount("ABCD"))
 		self.assertIsNone(get_float_amount("****"))
 
+	# ------------------------------------------------------------------ #
+	# PDF statement import
+	# ------------------------------------------------------------------ #
+
+	@staticmethod
+	def _make_pdf(html: str) -> bytes:
+		import pdfkit
+
+		return pdfkit.from_string(html, False)
+
+	@staticmethod
+	def _encrypt(pdf_bytes: bytes, password: str) -> bytes:
+		import io
+
+		from pypdf import PdfReader, PdfWriter
+
+		reader = PdfReader(io.BytesIO(pdf_bytes))
+		writer = PdfWriter()
+		for page in reader.pages:
+			writer.add_page(page)
+		writer.encrypt(password)
+		buffer = io.BytesIO()
+		writer.write(buffer)
+		return buffer.getvalue()
+
+	@staticmethod
+	def _auto_map(table: dict) -> dict:
+		"""Mimic prepare_pdf_tables' best-effort mapping for a single extracted table."""
+		header_index, score = detect_header_row(table["rows"])
+		if score >= 2:
+			table["header_index"] = header_index
+			table["column_mapping"] = detect_column_mapping(table["rows"][header_index])
+		else:
+			table["header_index"] = None
+			table["column_mapping"] = guess_column_mapping_by_content(table["rows"])
+		table["included"] = True
+		return table
+
+	def test_pdf_multi_page_kept_separate_and_unioned(self):
+		"""Tables on separate pages must NOT be merged; transactions are the union."""
+		html = """
+		<html><body>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Withdrawal</th><th>Deposit</th><th>Balance</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td><td></td><td>9500.00</td></tr>
+		<tr><td>03/04/2024</td><td>SALARY</td><td></td><td>20000.00</td><td>29500.00</td></tr></table>
+		<div style="page-break-before: always"></div>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Withdrawal</th><th>Deposit</th><th>Balance</th></tr>
+		<tr><td>05/04/2024</td><td>ATM WDL</td><td>2000.00</td><td></td><td>27500.00</td></tr></table>
+		</body></html>
+		"""
+		tables = extract_pdf_tables(self._make_pdf(html))
+
+		# Two separate tables, one per page
+		self.assertEqual(len(tables), 2)
+		self.assertEqual(sorted(t["page"] for t in tables), [1, 2])
+		for table in tables:
+			self.assertIn("bbox", table)
+			self.assertEqual(len(table["bbox"]), 4)
+
+		union = []
+		for table in tables:
+			final, _df, _af = build_table_transactions(self._auto_map(table))
+			union.extend(final)
+
+		self.assertEqual(len(union), 3)
+		self.assertEqual(sorted(t["date"] for t in union), ["2024-04-01", "2024-04-03", "2024-04-05"])
+
+	def test_pdf_junk_table_excluded(self):
+		"""A non-transactions table (ad/summary) should yield zero transactions."""
+		ad_table = self._auto_map({"rows": [["Open a new account!", "Call 1800-XYZ"]]})
+		final, _df, _af = build_table_transactions(ad_table)
+		self.assertEqual(final, [])
+
+	def test_headerless_content_mapping(self):
+		"""Without a header row, columns are guessed from their contents."""
+		rows = [
+			["01/04/2024", "UPI PAYMENT", "500.00"],
+			["03/04/2024", "SALARY CREDIT", "20000.00"],
+		]
+		mapping = {
+			c["maps_to"]: c["index"]
+			for c in guess_column_mapping_by_content(rows)
+			if c["maps_to"] != "Do not import"
+		}
+		self.assertEqual(mapping.get("Date"), 0)
+		self.assertEqual(mapping.get("Description"), 1)
+		self.assertEqual(mapping.get("Amount"), 2)
+
+	def test_pdf_password_protected(self):
+		"""Encrypted PDFs error without a password and succeed with the right one."""
+		html = """
+		<html><body><table border="1">
+		<tr><th>Date</th><th>Narration</th><th>Amount</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td></tr></table></body></html>
+		"""
+		encrypted = self._encrypt(self._make_pdf(html), "secret123")
+
+		# No / wrong password -> recognizable error
+		self.assertRaises(frappe.ValidationError, extract_pdf_tables, encrypted)
+		self.assertRaises(frappe.ValidationError, extract_pdf_tables, encrypted, "wrong")
+
+		# Correct password -> extracts
+		tables = extract_pdf_tables(encrypted, "secret123")
+		self.assertTrue(tables)
+
+	def test_pdf_no_tables_detected(self):
+		"""A PDF with no detectable tables raises a clear error (e.g. scanned PDFs)."""
+		html = "<html><body><p>Just some prose with no tabular data at all.</p></body></html>"
+		self.assertRaises(frappe.ValidationError, extract_pdf_tables, self._make_pdf(html))
+
+	def _create_pdf_import_log(self, html: str) -> BankStatementImportLog:
+		pdf_bytes = self._make_pdf(html)
+		file_doc = frappe.get_doc(
+			{
+				"doctype": "File",
+				"file_name": f"test-statement-{frappe.generate_hash(length=8)}.pdf",
+				"is_private": 1,
+				"content": pdf_bytes,
+			}
+		).insert(ignore_permissions=True)
+
+		doc = frappe.get_doc(
+			{
+				"doctype": "Bank Statement Import Log",
+				"name": f"test-pdf-{frappe.generate_hash(length=8)}",
+				"bank_account": self.bank_account,
+				"file": file_doc.file_url,
+			}
+		)
+		return doc.insert()
+
+	def test_pdf_full_lifecycle(self):
+		"""End-to-end doc lifecycle: insert -> rasterize -> preview -> edit -> import."""
+		html = """
+		<html><body>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Withdrawal</th><th>Deposit</th><th>Balance</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td><td></td><td>9500.00</td></tr>
+		<tr><td>03/04/2024</td><td>SALARY</td><td></td><td>20000.00</td><td>29500.00</td></tr></table>
+		<div style="page-break-before: always"></div>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Withdrawal</th><th>Deposit</th><th>Balance</th></tr>
+		<tr><td>05/04/2024</td><td>ATM WDL</td><td>2000.00</td><td></td><td>27500.00</td></tr></table>
+		</body></html>
+		"""
+		doc = self._create_pdf_import_log(html)
+
+		# before_insert populated the per-table JSON, page images and the union summary
+		tables = doc.get_pdf_tables()
+		self.assertEqual(len(tables), 2)
+		for table in tables:
+			self.assertTrue(table.get("page_image"))
+			self.assertIn("bbox", table)
+			# Page-image File must be attached to the final docname, not the client's temp id
+			attached_to = frappe.db.get_value("File", {"file_url": table["page_image"]}, "attached_to_name")
+			self.assertEqual(attached_to, doc.name)
+		self.assertEqual(doc.number_of_transactions, 3)
+		self.assertEqual(doc.total_debit_transactions, 2)
+		self.assertEqual(doc.total_credit_transactions, 1)
+
+		# get_statement_details returns the union and the per-table data for the editor
+		details = get_statement_details(doc.name)
+		self.assertEqual(len(details["final_transactions"]), 3)
+		self.assertEqual(details["raw_data"], [])
+		self.assertEqual(len(details["pdf_tables"]), 2)
+
+		# Excluding the second table (page 2) drops its single transaction
+		tables[1]["included"] = False
+		update_pdf_tables(doc.name, tables)
+		doc.reload()
+		self.assertEqual(doc.number_of_transactions, 2)
+
+		# Re-include and import; transactions are created for the union
+		tables[1]["included"] = True
+		update_pdf_tables(doc.name, tables)
+		doc.reload()
+		doc.insert_transactions()
+		doc.reload()
+		self.assertEqual(doc.status, "Completed")
+
+		created = frappe.get_all(
+			"Bank Transaction", filters={"bank_account": self.bank_account, "docstatus": 1}
+		)
+		self.assertEqual(len(created), 3)
+
+	def test_pdf_reextract_table_from_bbox(self):
+		"""Re-extracting a table from an adjusted bbox updates its rows and stores the bbox."""
+		html = """
+		<html><body>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Amount</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td></tr>
+		<tr><td>03/04/2024</td><td>SALARY</td><td>20000.00</td></tr></table>
+		</body></html>
+		"""
+		doc = self._create_pdf_import_log(html)
+		table = doc.get_pdf_tables()[0]
+		bbox = table["bbox"]
+
+		details = reextract_pdf_table(doc.name, table["page"], table["table_index"], bbox)
+		updated = details["pdf_tables"][0]
+
+		# Same region -> same rows; bbox is persisted
+		self.assertTrue(updated["rows"])
+		self.assertEqual(updated["bbox"], [round(float(v), 2) for v in bbox])
+		self.assertEqual(updated["rows"], table["rows"])
+
+	def test_pdf_reextract_changed_bbox_updates_rows_and_transactions(self):
+		"""Shrinking a table's bbox must drop rows and update the transaction count end-to-end."""
+		html = """
+		<html><body>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Amount</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td></tr>
+		<tr><td>03/04/2024</td><td>SALARY</td><td>20000.00</td></tr>
+		<tr><td>05/04/2024</td><td>ATM WDL</td><td>2000.00</td></tr>
+		<tr><td>07/04/2024</td><td>INTEREST</td><td>12.50</td></tr></table>
+		</body></html>
+		"""
+		doc = self._create_pdf_import_log(html)
+		original = doc.get_pdf_tables()[0]
+		original_rows = len(original["rows"])
+		original_txns = doc.number_of_transactions
+
+		# Shrink the box to roughly the top half (simulating a user drag).
+		x0, top, x1, bottom = original["bbox"]
+		shrunk = [x0, top, x1, top + (bottom - top) * 0.5]
+
+		details = reextract_pdf_table(doc.name, original["page"], original["table_index"], shrunk)
+		updated = details["pdf_tables"][0]
+		doc.reload()
+
+		self.assertLess(len(updated["rows"]), original_rows)
+		self.assertLess(doc.number_of_transactions, original_txns)
+		self.assertEqual(len(details["final_transactions"]), doc.number_of_transactions)
+
+	def test_pdf_set_table_header(self):
+		"""User can clear a table's header (no header row) or set a specific header row."""
+		html = """
+		<html><body>
+		<table border="1"><tr><th>Date</th><th>Narration</th><th>Amount</th></tr>
+		<tr><td>01/04/2024</td><td>UPI PAYMENT</td><td>500.00</td></tr>
+		<tr><td>03/04/2024</td><td>SALARY</td><td>20000.00</td></tr></table>
+		</body></html>
+		"""
+		doc = self._create_pdf_import_log(html)
+		table = doc.get_pdf_tables()[0]
+		self.assertEqual(table["header_index"], 0)
+		original = {
+			c["maps_to"]: c["index"] for c in table["column_mapping"] if c["maps_to"] != "Do not import"
+		}
+
+		# Clear the header (-1): header is removed but the mapping is preserved (not re-guessed).
+		details = set_pdf_table_header(doc.name, table["page"], table["table_index"], -1)
+		updated = details["pdf_tables"][0]
+		self.assertIsNone(updated["header_index"])
+		preserved = {
+			c["maps_to"]: c["index"] for c in updated["column_mapping"] if c["maps_to"] != "Do not import"
+		}
+		self.assertEqual(preserved, original)
+
+		# Set row 0 back as the header: it resolves meaningfully, so mapping is re-derived.
+		details = set_pdf_table_header(doc.name, table["page"], table["table_index"], 0)
+		updated = details["pdf_tables"][0]
+		self.assertEqual(updated["header_index"], 0)
+		mapped = {
+			c["maps_to"]: c["index"] for c in updated["column_mapping"] if c["maps_to"] != "Do not import"
+		}
+		self.assertEqual(mapped.get("Date"), 0)
+		self.assertEqual(mapped.get("Description"), 1)
+
+	# ------------------------------------------------------------------ #
+	# CSV/XLSX column mapping + header overrides
+	# ------------------------------------------------------------------ #
+
+	def _create_csv_import_log(self, csv_text: str) -> BankStatementImportLog:
+		file_doc = frappe.get_doc(
+			{
+				"doctype": "File",
+				"file_name": f"test-statement-{frappe.generate_hash(length=8)}.csv",
+				"is_private": 1,
+				"content": csv_text,
+			}
+		).insert(ignore_permissions=True)
+
+		doc = frappe.get_doc(
+			{
+				"doctype": "Bank Statement Import Log",
+				"bank_account": self.bank_account,
+				"file": file_doc.file_url,
+			}
+		)
+		return doc.insert()
+
+	def test_csv_update_column_mapping(self):
+		"""Overriding the column mapping recomputes the transaction count."""
+		csv_text = "Date,Narration,Amount\n01/04/2024,UPI PAYMENT,500.00\n03/04/2024,SALARY,20000.00\n"
+		doc = self._create_csv_import_log(csv_text)
+		self.assertEqual(doc.number_of_transactions, 2)
+
+		# Drop the amount column -> no amount -> no transactions detected.
+		mapping = [
+			{"index": c.index, "maps_to": "Do not import" if c.maps_to == "Amount" else c.maps_to}
+			for c in doc.column_mapping
+		]
+		details = update_column_mapping(doc.name, mapping)
+		doc.reload()
+		self.assertEqual(doc.number_of_transactions, 0)
+		self.assertEqual(len(details["final_transactions"]), 0)
+
+	def test_csv_set_header_index_preserves_mapping(self):
+		"""Clearing the header keeps the user's mapping; it is not re-guessed."""
+		csv_text = "Date,Narration,Amount\n01/04/2024,UPI PAYMENT,500.00\n03/04/2024,SALARY,20000.00\n"
+		doc = self._create_csv_import_log(csv_text)
+		self.assertEqual(doc.detected_header_index, 0)
+
+		# Manually map the Narration column (1) as Reference.
+		mapping = [
+			{
+				"index": c.index,
+				"maps_to": "Reference" if c.index == 1 else c.maps_to,
+				"header_text": c.header_text,
+			}
+			for c in doc.column_mapping
+		]
+		update_column_mapping(doc.name, mapping)
+		doc.reload()
+
+		# Clear the header row: the manual mapping must be preserved (column 1 stays Reference,
+		# not re-guessed to Description). The label row fails date parsing, so 2 transactions remain.
+		set_header_index(doc.name, -1)
+		doc.reload()
+		self.assertEqual(doc.detected_header_index, -1)
+		self.assertEqual(doc.number_of_transactions, 2)
+		current = {c.index: c.maps_to for c in doc.column_mapping}
+		self.assertEqual(current.get(1), "Reference")
+
+		# Restore row 0 as the header (resolves meaningfully -> re-derived from labels).
+		set_header_index(doc.name, 0)
+		doc.reload()
+		self.assertEqual(doc.detected_header_index, 0)
+		restored = {c.maps_to: c.index for c in doc.column_mapping if c.maps_to != "Do not import"}
+		self.assertEqual(restored.get("Description"), 1)
+
 
 test_hdfc_sample_statement_data = [
 	["HDFC BANK Ltd.  Page No .: 1  Statement of accounts", "", "", "", "", "", ""],

erpnext/accounts/doctype/bank_transaction/bank_transaction.py

@@ -5,6 +5,8 @@ import frappe
 from frappe import _
 from frappe.model.docstatus import DocStatus
 from frappe.model.document import Document
+from frappe.query_builder import Tuple
+from frappe.query_builder.functions import Abs, Max, Sum
 from frappe.utils import flt, getdate
 
 
@@ -374,6 +376,7 @@ def unreconcile_transaction(transaction_name: str | int):
 	Else, cancel the individual entries
 	"""
 	transaction = frappe.get_doc("Bank Transaction", transaction_name)
+	transaction.check_permission("write")
 
 	vouchers_to_cancel = []
 
@@ -401,6 +404,7 @@ def unreconcile_transaction_entry(bank_transaction_id: str | int, voucher_type:
 	"""
 
 	bank_transaction = frappe.get_doc("Bank Transaction", bank_transaction_id)
+	bank_transaction.check_permission("write")
 
 	# Find the voucher in the bank transaction and depending on the action, either remove it or cancel the voucher
 	for entry in bank_transaction.payment_entries:
@@ -436,7 +440,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 		if bt_bank_account != gl_bank_account:
 			frappe.throw(
-				_("Bank Account {} in Bank Transaction {} is not matching with Bank Account {}").format(
+				_("Bank Account {0} in Bank Transaction {1} is not matching with Bank Account {2}").format(
 					bt_bank_account, payment_entry.payment_entry, gl_bank_account
 				)
 			)
@@ -445,7 +449,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 	if gl_bank_account not in gl_entries:
 		frappe.throw(
-			_("{} {} is not affecting bank account {}").format(
+			_("{0} {1} is not affecting bank account {2}").format(
 				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account
 			)
 		)
@@ -453,7 +457,7 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 	allocable_amount = gl_entries.pop(gl_bank_account) or 0
 	if allocable_amount <= 0.0:
 		frappe.throw(
-			_("Invalid amount in accounting entries of {} {} for Account {}: {}").format(
+			_("Invalid amount in accounting entries of {0} {1} for Account {2}: {3}").format(
 				payment_entry.payment_document, payment_entry.payment_entry, gl_bank_account, allocable_amount
 			)
 		)
@@ -476,30 +480,28 @@ def get_clearance_details(transaction, payment_entry, bt_allocations, gl_entries
 
 
 def get_related_bank_gl_entries(docs):
-	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
 	if not docs:
 		return {}
 
-	result = frappe.db.sql(
-		"""
-        SELECT
-            gle.voucher_type AS doctype,
-            gle.voucher_no AS docname,
-            gle.account AS gl_account,
-            SUM(ABS(gle.credit_in_account_currency - gle.debit_in_account_currency)) AS amount
-        FROM
-            `tabGL Entry` gle
-        LEFT JOIN
-            `tabAccount` ac ON ac.name = gle.account
-        WHERE
-            ac.account_type = 'Bank'
-            AND (gle.voucher_type, gle.voucher_no) IN %(docs)s
-            AND gle.is_cancelled = 0
-        GROUP BY
-            gle.voucher_type, gle.voucher_no, gle.account
-        """,
-		{"docs": docs},
-		as_dict=True,
+	gle = frappe.qb.DocType("GL Entry")
+	ac = frappe.qb.DocType("Account")
+	result = (
+		frappe.qb.from_(gle)
+		.left_join(ac)
+		.on(ac.name == gle.account)
+		.select(
+			gle.voucher_type.as_("doctype"),
+			gle.voucher_no.as_("docname"),
+			gle.account.as_("gl_account"),
+			Sum(Abs(gle.credit_in_account_currency - gle.debit_in_account_currency)).as_("amount"),
+		)
+		.where(
+			(ac.account_type == "Bank")
+			& Tuple(gle.voucher_type, gle.voucher_no).isin([Tuple(vt, vn) for vt, vn in docs])
+			& (gle.is_cancelled == 0)
+		)
+		.groupby(gle.voucher_type, gle.voucher_no, gle.account)
+		.run(as_dict=True)
 	)
 
 	entries = {}
@@ -521,31 +523,32 @@ def get_total_allocated_amount(docs):
 	if not docs:
 		return {}
 
-	# nosemgrep: frappe-semgrep-rules.rules.frappe-using-db-sql
-	result = frappe.db.sql(
-		"""
-		SELECT total, latest_date, gl_account, payment_document, payment_entry FROM (
-			SELECT
-				ROW_NUMBER() OVER w AS rownum,
-				SUM(btp.allocated_amount) OVER(PARTITION BY ba.account, btp.payment_document, btp.payment_entry) AS total,
-				FIRST_VALUE(bt.date) OVER w AS latest_date,
-				ba.account AS gl_account,
-				btp.payment_document,
-				btp.payment_entry
-			FROM
-				`tabBank Transaction Payments` btp
-			LEFT JOIN `tabBank Transaction` bt ON bt.name=btp.parent
-			LEFT JOIN `tabBank Account` ba ON ba.name=bt.bank_account
-			WHERE
-				(btp.payment_document, btp.payment_entry) IN %(docs)s
-				AND bt.docstatus = 1
-			WINDOW w AS (PARTITION BY ba.account, btp.payment_document, btp.payment_entry ORDER BY bt.date DESC)
-		) temp
-		WHERE
-			rownum = 1
-		""",
-		dict(docs=docs),
-		as_dict=True,
+	# The original window query (ROW_NUMBER/FIRST_VALUE + rownum = 1) just collapses to one
+	# row per (account, payment_document, payment_entry) with the partition's allocation total
+	# and most recent transaction date — i.e. a plain GROUP BY with SUM and MAX.
+	btp = frappe.qb.DocType("Bank Transaction Payments")
+	bt = frappe.qb.DocType("Bank Transaction")
+	ba = frappe.qb.DocType("Bank Account")
+
+	result = (
+		frappe.qb.from_(btp)
+		.left_join(bt)
+		.on(bt.name == btp.parent)
+		.left_join(ba)
+		.on(ba.name == bt.bank_account)
+		.select(
+			Sum(btp.allocated_amount).as_("total"),
+			Max(bt.date).as_("latest_date"),
+			ba.account.as_("gl_account"),
+			btp.payment_document,
+			btp.payment_entry,
+		)
+		.where(
+			Tuple(btp.payment_document, btp.payment_entry).isin([Tuple(pd, pe) for pd, pe in docs])
+			& (bt.docstatus == 1)
+		)
+		.groupby(ba.account, btp.payment_document, btp.payment_entry)
+		.run(as_dict=True)
 	)
 
 	payment_allocation_details = {}

erpnext/accounts/doctype/bank_transaction/bank_transaction_upload.py

@@ -35,12 +35,12 @@ def upload_bank_statement():
 
 
 @frappe.whitelist()
-def create_bank_entries(columns: str, data: str, bank_account: str):
+def create_bank_entries(columns: str, data: str | list, bank_account: str):
 	header_map = get_header_mapping(columns, bank_account)
 
 	success = 0
 	errors = 0
-	for d in json.loads(data):
+	for d in frappe.parse_json(data):
 		if all(item is None for item in d) is True:
 			continue
 		fields = {}
@@ -66,7 +66,7 @@ def get_header_mapping(columns, bank_account):
 	mapping = get_bank_mapping(bank_account)
 
 	header_map = {}
-	for column in json.loads(columns):
+	for column in frappe.parse_json(columns):
 		if column["content"] in mapping:
 			header_map.update({mapping[column["content"]]: column["colIndex"]})
 

erpnext/accounts/doctype/bank_transaction/test_bank_transaction.py

@@ -47,7 +47,7 @@ class TestBankTransaction(ERPNextTestSuite):
 			from_date=bank_transaction.date,
 			to_date=utils.today(),
 		)
-		self.assertTrue(linked_payments[0]["party"] == "Conrad Electronic")
+		self.assertEqual(linked_payments[0]["party"], "Conrad Electronic")
 
 	# This test validates a simple reconciliation leading to the clearance of the bank transaction and the payment
 	def test_reconcile(self):
@@ -70,10 +70,10 @@ class TestBankTransaction(ERPNextTestSuite):
 		unallocated_amount = frappe.db.get_value(
 			"Bank Transaction", bank_transaction.name, "unallocated_amount"
 		)
-		self.assertTrue(unallocated_amount == 0)
+		self.assertEqual(unallocated_amount, 0)
 
 		clearance_date = frappe.db.get_value("Payment Entry", payment.name, "clearance_date")
-		self.assertTrue(clearance_date is not None)
+		self.assertIsNot(clearance_date, None)
 
 		bank_transaction.reload()
 		bank_transaction.cancel()
@@ -104,6 +104,36 @@ class TestBankTransaction(ERPNextTestSuite):
 		self.assertEqual(bank_transaction.unallocated_amount, 1700)
 		self.assertEqual(bank_transaction.payment_entries, [])
 
+	# Amending a reconciled payment entry must not carry over its clearance date
+	def test_clearance_date_cleared_on_amend(self):
+		bank_transaction = frappe.get_doc(
+			"Bank Transaction",
+			dict(description="1512567 BG/000003025 OPSKATTUZWXXX AT776000000098709849 Herr G"),
+		)
+		payment = frappe.get_doc("Payment Entry", dict(party="Mr G", paid_amount=1700))
+		vouchers = json.dumps(
+			[
+				{
+					"payment_doctype": "Payment Entry",
+					"payment_name": payment.name,
+					"amount": bank_transaction.unallocated_amount,
+				}
+			]
+		)
+		reconcile_vouchers(bank_transaction.name, vouchers)
+
+		self.assertTrue(frappe.db.get_value("Payment Entry", payment.name, "clearance_date"))
+
+		payment.reload()
+		payment.cancel()
+
+		amended = frappe.copy_doc(payment)
+		amended.amended_from = payment.name
+		amended.docstatus = 0
+		amended.insert()
+
+		self.assertFalse(amended.clearance_date)
+
 	# Check if ERPNext can correctly filter a linked payments based on the debit/credit amount
 	def test_debit_credit_output(self):
 		bank_transaction = frappe.get_doc(
@@ -178,9 +208,8 @@ class TestBankTransaction(ERPNextTestSuite):
 		self.assertEqual(
 			frappe.db.get_value("Bank Transaction", bank_transaction.name, "unallocated_amount"), 0
 		)
-		self.assertTrue(
-			frappe.db.get_value("Sales Invoice Payment", dict(parent=payment.name), "clearance_date")
-			is not None
+		self.assertIsNot(
+			frappe.db.get_value("Sales Invoice Payment", dict(parent=payment.name), "clearance_date"), None
 		)
 
 	@if_lending_app_installed

erpnext/accounts/doctype/bank_transaction_rule/bank_transaction_rule.py

@@ -66,7 +66,7 @@ class BankTransactionRule(Document):
 				frappe.throw(_("Party type is required to create a payment entry."))
 
 			if not self.party:
-				frappe.throw(_("Party is required create a payment entry."))
+				frappe.throw(_("Party is required to create a payment entry."))
 
 			if not self.account:
 				frappe.throw(_("Party account is required to create a payment entry."))

erpnext/accounts/doctype/bank_transaction_rule/test_bank_transaction_rule.py

@@ -11,9 +11,11 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.create_company()
-		self.create_customer()
-		self.clear_old_entries()
+		self.company = "_Test Company"
+		self.customer = "_Test Customer"
+		self.bank = "HDFC - _TC"
+		self.debit_to = "Debtors - _TC"
+		self.cash = "Cash - _TC"
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()

erpnext/accounts/doctype/bisect_accounting_statements/bisect_accounting_statements.py

@@ -121,7 +121,7 @@ class BisectAccountingStatements(Document):
 
 				cur_node.save()
 
-	@frappe.whitelist()
+	@frappe.whitelist(methods=["POST"])
 	def build_tree(self):
 		frappe.db.delete("Bisect Nodes")
 

erpnext/accounts/doctype/budget/budget.js

@@ -17,6 +17,7 @@ frappe.ui.form.on("Budget", {
 				filters: {
 					is_group: 0,
 					company: frm.doc.company,
+					root_type: ["in", ["Income", "Expense"]],
 				},
 			};
 		});
@@ -135,6 +136,9 @@ function set_total_budget_amount(frm) {
 function toggle_distribution_fields(frm) {
 	const grid = frm.fields_dict.budget_distribution.grid;
 
+	frm.set_df_property("budget_distribution", "cannot_add_rows", true);
+	frm.set_df_property("budget_distribution", "cannot_delete_rows", true);
+
 	["amount", "percent"].forEach((field) => {
 		grid.update_docfield_property(field, "read_only", frm.doc.distribute_equally);
 	});

erpnext/accounts/doctype/budget/budget.py

@@ -5,9 +5,11 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.query_builder.functions import Sum
+from frappe.query_builder import Criterion
+from frappe.query_builder.functions import Coalesce, Sum
 from frappe.utils import add_months, flt, fmt_money, get_last_day, getdate
 from frappe.utils.data import get_first_day
+from pypika.terms import ExistsCriterion
 
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
@@ -115,23 +117,26 @@ class Budget(Document):
 		if not account:
 			return
 
-		existing_budget = frappe.db.sql(
-			f"""
-			SELECT name, account
-			FROM `tabBudget`
-			WHERE
-				docstatus < 2
-				AND company = %s
-				AND {budget_against_field} = %s
-				AND account = %s
-				AND name != %s
-				AND (
-					(SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
-					AND (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
-				)
-			""",
-			(self.company, budget_against, account, self.name, self.budget_end_date, self.budget_start_date),
-			as_dict=True,
+		budget = frappe.qb.DocType("Budget")
+		fy_from = frappe.qb.DocType("Fiscal Year").as_("fy_from")
+		fy_to = frappe.qb.DocType("Fiscal Year").as_("fy_to")
+		existing_budget = (
+			frappe.qb.from_(budget)
+			.inner_join(fy_from)
+			.on(fy_from.name == budget.from_fiscal_year)
+			.inner_join(fy_to)
+			.on(fy_to.name == budget.to_fiscal_year)
+			.select(budget.name, budget.account)
+			.where(
+				(budget.docstatus < 2)
+				& (budget.company == self.company)
+				& (budget[budget_against_field] == budget_against)
+				& (budget.account == account)
+				& (budget.name != self.name)
+				& (fy_from.year_start_date <= self.budget_end_date)
+				& (fy_to.year_end_date >= self.budget_start_date)
+			)
+			.run(as_dict=True)
 		)
 
 		if existing_budget:
@@ -157,9 +162,9 @@ class Budget(Document):
 			frappe.throw(_("Account {0} does not belong to company {1}").format(self.account, self.company))
 		elif account_details.report_type != "Profit and Loss":
 			frappe.throw(
-				_("Budget cannot be assigned against {0}, as it's not an Income or Expense account").format(
-					self.account
-				)
+				_(
+					"Budget cannot be assigned against {0}, as its Root Type is not of Income or Expense"
+				).format(self.account)
 			)
 
 	def set_null_value(self):
@@ -353,8 +358,8 @@ class Budget(Document):
 		if self.should_regenerate_budget_distribution():
 			return
 
-		total_amount = sum(d.amount for d in self.budget_distribution)
-		total_percent = sum(d.percent for d in self.budget_distribution)
+		total_amount = sum(flt(d.amount) for d in self.budget_distribution)
+		total_percent = sum(flt(d.percent) for d in self.budget_distribution)
 
 		if flt(abs(total_amount - self.budget_amount), 2) > 0.10:
 			frappe.throw(
@@ -381,17 +386,24 @@ def validate_expense_against_budget(params, expense_amount=0):
 	posting_fiscal_year = get_fiscal_year(posting_date, company=params.get("company"))[0]
 	year_start_date, year_end_date = get_fiscal_year_date_range(posting_fiscal_year, posting_fiscal_year)
 
-	budget_exists = frappe.db.sql(
-		"""
-		select name
-		from `tabBudget`
-		where company = %s
-		and docstatus = 1
-		and (SELECT year_start_date FROM `tabFiscal Year` WHERE name = from_fiscal_year) <= %s
-		and (SELECT year_end_date FROM `tabFiscal Year` WHERE name = to_fiscal_year) >= %s
-		limit 1
-		""",
-		(params.company, year_end_date, year_start_date),
+	budget = frappe.qb.DocType("Budget")
+	fy_from = frappe.qb.DocType("Fiscal Year").as_("fy_from")
+	fy_to = frappe.qb.DocType("Fiscal Year").as_("fy_to")
+	budget_exists = (
+		frappe.qb.from_(budget)
+		.inner_join(fy_from)
+		.on(fy_from.name == budget.from_fiscal_year)
+		.inner_join(fy_to)
+		.on(fy_to.name == budget.to_fiscal_year)
+		.select(budget.name)
+		.where(
+			(budget.company == params.company)
+			& (budget.docstatus == 1)
+			& (fy_from.year_start_date <= year_end_date)
+			& (fy_to.year_end_date >= year_start_date)
+		)
+		.limit(1)
+		.run()
 	)
 
 	if not budget_exists:
@@ -434,50 +446,52 @@ def validate_expense_against_budget(params, expense_amount=0):
 			and (frappe.get_cached_value("Account", params.account, "root_type") == "Expense")
 		):
 			doctype = dimension.get("document_type")
-
-			if frappe.get_cached_value("DocType", doctype, "is_tree"):
-				lft, rgt = frappe.get_cached_value(doctype, params.get(budget_against), ["lft", "rgt"])
-				condition = f"""and exists(select name from `tab{doctype}`
-					where lft<={lft} and rgt>={rgt} and name=b.{budget_against})"""  # nosec
-				params.is_tree = True
-			else:
-				condition = f"and b.{budget_against}={frappe.db.escape(params.get(budget_against))}"
-				params.is_tree = False
-
+			params.is_tree = bool(frappe.get_cached_value("DocType", doctype, "is_tree"))
 			params.budget_against_field = budget_against
 			params.budget_against_doctype = doctype
 
-			budget_records = frappe.db.sql(
-				f"""
-				SELECT
+			b = frappe.qb.DocType("Budget")
+			query = (
+				frappe.qb.from_(b)
+				.select(
 					b.name,
-					b.{budget_against} AS budget_against,
+					getattr(b, budget_against).as_("budget_against"),
 					b.budget_amount,
 					b.from_fiscal_year,
 					b.to_fiscal_year,
 					b.budget_start_date,
 					b.budget_end_date,
-					IFNULL(b.applicable_on_material_request, 0) AS for_material_request,
-					IFNULL(b.applicable_on_purchase_order, 0) AS for_purchase_order,
-					IFNULL(b.applicable_on_booking_actual_expenses, 0) AS for_actual_expenses,
+					Coalesce(b.applicable_on_material_request, 0).as_("for_material_request"),
+					Coalesce(b.applicable_on_purchase_order, 0).as_("for_purchase_order"),
+					Coalesce(b.applicable_on_booking_actual_expenses, 0).as_("for_actual_expenses"),
 					b.action_if_annual_budget_exceeded,
 					b.action_if_accumulated_monthly_budget_exceeded,
 					b.action_if_annual_budget_exceeded_on_mr,
 					b.action_if_accumulated_monthly_budget_exceeded_on_mr,
 					b.action_if_annual_budget_exceeded_on_po,
-					b.action_if_accumulated_monthly_budget_exceeded_on_po
-				FROM
-					`tabBudget` b
-				WHERE
-					b.company = %s
-					AND b.docstatus = 1
-					AND %s BETWEEN b.budget_start_date AND b.budget_end_date
-					AND b.account = %s
-					{condition}
-				""",
-				(params.company, params.posting_date, params.account),
-				as_dict=True,
-			)  # nosec
+					b.action_if_accumulated_monthly_budget_exceeded_on_po,
+				)
+				.where(b.company == params.company)
+				.where(b.docstatus == 1)
+				.where(b.budget_start_date <= params.posting_date)
+				.where(b.budget_end_date >= params.posting_date)
+				.where(b.account == params.account)
+			)
+
+			if params.is_tree:
+				lft, rgt = frappe.get_cached_value(doctype, params.get(budget_against), ["lft", "rgt"])
+				dim = frappe.qb.DocType(doctype)
+				query = query.where(
+					ExistsCriterion(
+						frappe.qb.from_(dim)
+						.select(dim.name)
+						.where((dim.lft <= lft) & (dim.rgt >= rgt) & (dim.name == getattr(b, budget_against)))
+					)
+				)
+			else:
+				query = query.where(getattr(b, budget_against) == params.get(budget_against))
+
+			budget_records = query.run(as_dict=True)
 
 			if budget_records:
 				validate_budget_records(params, budget_records, expense_amount)
@@ -674,15 +688,27 @@ def get_actions(params, budget):
 
 def get_requested_amount(params):
 	item_code = params.get("item_code")
-	condition = get_other_condition(params, "Material Request")
 
-	data = frappe.db.sql(
-		""" select ifnull((sum(child.stock_qty - child.ordered_qty) * rate), 0) as amount
-		from `tabMaterial Request Item` child, `tabMaterial Request` parent where parent.name = child.parent and
-		child.item_code = %s and parent.docstatus = 1 and child.stock_qty > child.ordered_qty and {} and
-		parent.material_request_type = 'Purchase' and parent.status != 'Stopped'""".format(condition),
-		item_code,
-		as_list=1,
+	child = frappe.qb.DocType("Material Request Item")
+	parent = frappe.qb.DocType("Material Request")
+
+	data = (
+		frappe.qb.from_(child)
+		.join(parent)
+		.on(parent.name == child.parent)
+		.select(
+			# rate inside the aggregate: Sum(qty * rate) is the correct requested amount and is PG-valid
+			Coalesce(Sum((child.stock_qty - child.ordered_qty) * child.rate), 0).as_("amount")
+		)
+		.where(
+			(child.item_code == item_code)
+			& (parent.docstatus == 1)
+			& (child.stock_qty > child.ordered_qty)
+			& Criterion.all(get_other_condition(params, child, parent, "Material Request"))
+			& (parent.material_request_type == "Purchase")
+			& (parent.status != "Stopped")
+		)
+		.run(as_list=1)
 	)
 
 	return data[0][0] if data else 0
@@ -690,35 +716,43 @@ def get_requested_amount(params):
 
 def get_ordered_amount(params):
 	item_code = params.get("item_code")
-	condition = get_other_condition(params, "Purchase Order")
 
-	data = frappe.db.sql(
-		f""" select ifnull(sum(child.amount - child.billed_amt), 0) as amount
-		from `tabPurchase Order Item` child, `tabPurchase Order` parent where
-		parent.name = child.parent and child.item_code = %s and parent.docstatus = 1 and child.amount > child.billed_amt
-		and parent.status != 'Closed' and {condition}""",
-		item_code,
-		as_list=1,
+	child = frappe.qb.DocType("Purchase Order Item")
+	parent = frappe.qb.DocType("Purchase Order")
+
+	data = (
+		frappe.qb.from_(child)
+		.join(parent)
+		.on(parent.name == child.parent)
+		.select(Coalesce(Sum(child.amount - child.billed_amt), 0).as_("amount"))
+		.where(
+			(child.item_code == item_code)
+			& (parent.docstatus == 1)
+			& (child.amount > child.billed_amt)
+			& (parent.status != "Closed")
+			& Criterion.all(get_other_condition(params, child, parent, "Purchase Order"))
+		)
+		.run(as_list=1)
 	)
 
 	return data[0][0] if data else 0
 
 
-def get_other_condition(params, for_doc):
-	condition = f"expense_account = '{params.expense_account}'"
+def get_other_condition(params, child, parent, for_doc):
+	conditions = [child.expense_account == params.expense_account]
 	budget_against_field = params.get("budget_against_field")
 
 	if budget_against_field and params.get(budget_against_field):
-		condition += f" and child.{budget_against_field} = '{params.get(budget_against_field)}'"
+		conditions.append(child[budget_against_field] == params.get(budget_against_field))
 
 	date_field = "schedule_date" if for_doc == "Material Request" else "transaction_date"
 
 	start_date = frappe.get_cached_value("Fiscal Year", params.from_fiscal_year, "year_start_date")
 	end_date = frappe.get_cached_value("Fiscal Year", params.to_fiscal_year, "year_end_date")
 
-	condition += f" and parent.{date_field} between '{start_date}' and '{end_date}'"
+	conditions.append(parent[date_field][str(start_date) : str(end_date)])
 
-	return condition
+	return conditions
 
 
 def get_actual_expense(params):
@@ -726,11 +760,19 @@ def get_actual_expense(params):
 		params.budget_against_doctype = frappe.unscrub(params.budget_against_field)
 
 	budget_against_field = params.get("budget_against_field")
-	condition1 = " and gle.posting_date <= %(month_end_date)s" if params.get("month_end_date") else ""
 
-	date_condition = (
-		f"and gle.posting_date between '{params.budget_start_date}' and '{params.budget_end_date}'"
-	)
+	gle = frappe.qb.DocType("GL Entry")
+
+	conditions = [
+		gle.is_cancelled == 0,
+		gle.account == params.get("account"),
+		gle.posting_date[str(params.budget_start_date) : str(params.budget_end_date)],
+		gle.company == params.get("company"),
+		gle.docstatus == 1,
+	]
+
+	if params.get("month_end_date"):
+		conditions.append(gle.posting_date <= params.get("month_end_date"))
 
 	if params.is_tree:
 		lft_rgt = frappe.db.get_value(
@@ -738,35 +780,27 @@ def get_actual_expense(params):
 		)
 		params.update(lft_rgt)
 
-		condition2 = f"""
-			and exists(
-				select name from `tab{params.budget_against_doctype}`
-				where lft >= %(lft)s and rgt <= %(rgt)s
-				and name = gle.{budget_against_field}
+		tree = frappe.qb.DocType(params.budget_against_doctype)
+		conditions.append(
+			ExistsCriterion(
+				frappe.qb.from_(tree)
+				.select(tree.name)
+				.where(
+					(tree.lft >= params.get("lft"))
+					& (tree.rgt <= params.get("rgt"))
+					& (tree.name == gle[budget_against_field])
+				)
 			)
-		"""
+		)
 	else:
-		condition2 = f"""
-			and gle.{budget_against_field} = %({budget_against_field})s
-		"""
+		conditions.append(gle[budget_against_field] == params.get(budget_against_field))
 
 	amount = flt(
-		frappe.db.sql(
-			f"""
-				select sum(gle.debit) - sum(gle.credit)
-				from `tabGL Entry` gle
-				where
-					is_cancelled = 0
-					and gle.account = %(account)s
-					{condition1}
-					{date_condition}
-					and gle.company = %(company)s
-					and gle.docstatus = 1
-					{condition2}
-			""",
-			params,
-		)[0][0]
-	)  # nosec
+		frappe.qb.from_(gle)
+		.select(Sum(gle.debit) - Sum(gle.credit))
+		.where(Criterion.all(conditions))
+		.run()[0][0]
+	)
 
 	return amount
 

erpnext/accounts/doctype/budget_distribution/budget_distribution.json

@@ -18,6 +18,7 @@
    "in_list_view": 1,
    "label": "Start Date",
    "read_only": 1,
+   "reqd": 1,
    "search_index": 1
   },
   {
@@ -25,26 +26,29 @@
    "fieldtype": "Date",
    "in_list_view": 1,
    "label": "End Date",
-   "read_only": 1
+   "read_only": 1,
+   "reqd": 1
   },
   {
    "fieldname": "amount",
    "fieldtype": "Currency",
    "in_list_view": 1,
-   "label": "Amount"
+   "label": "Amount",
+   "reqd": 1
   },
   {
    "fieldname": "percent",
    "fieldtype": "Percent",
    "in_list_view": 1,
-   "label": "Percent"
+   "label": "Percent",
+   "reqd": 1
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2025-11-03 13:18:28.398198",
+ "modified": "2026-06-18 11:23:17.669733",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Budget Distribution",

erpnext/accounts/doctype/budget_distribution/budget_distribution.py

@@ -15,12 +15,12 @@ class BudgetDistribution(Document):
 		from frappe.types import DF
 
 		amount: DF.Currency
-		end_date: DF.Date | None
+		end_date: DF.Date
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
 		percent: DF.Percent
-		start_date: DF.Date | None
+		start_date: DF.Date
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/cashier_closing/cashier_closing.py

@@ -5,6 +5,7 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
+from frappe.query_builder.functions import Sum
 from frappe.utils import flt
 
 
@@ -43,13 +44,17 @@ class CashierClosing(Document):
 		self.make_calculations()
 
 	def get_outstanding(self):
-		values = frappe.db.sql(
-			"""
-			select sum(outstanding_amount)
-			from `tabSales Invoice`
-			where posting_date=%s and posting_time>=%s and posting_time<=%s and owner=%s
-		""",
-			(self.date, self.from_time, self.time, self.user),
+		si = frappe.qb.DocType("Sales Invoice")
+		values = (
+			frappe.qb.from_(si)
+			.select(Sum(si.outstanding_amount))
+			.where(
+				(si.posting_date == self.date)
+				& (si.posting_time >= self.from_time)
+				& (si.posting_time <= self.time)
+				& (si.owner == self.user)
+			)
+			.run()
 		)
 		self.outstanding_amount = flt(values[0][0] if values else 0)
 

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -63,8 +63,8 @@ def validate_company(company: str):
 	)
 
 	if parent_company and (not allow_account_creation_against_child_company):
-		msg = _("{} is a child company.").format(frappe.bold(company)) + " "
-		msg += _("Please import accounts against parent company or enable {} in company master.").format(
+		msg = _("{0} is a child company.").format(frappe.bold(company)) + " "
+		msg += _("Please import accounts against parent company or enable {0} in company master.").format(
 			frappe.bold(_("Allow Account Creation Against Child Company"))
 		)
 		frappe.throw(msg, title=_("Wrong Company"))
@@ -75,7 +75,10 @@ def validate_company(company: str):
 
 @frappe.whitelist()
 def import_coa(file_name: str, company: str):
+	frappe.only_for("Accounts Manager")
+
 	# delete existing data for accounts
+	frappe.has_permission("Company", "write", company, throw=True)
 	unset_existing_data(company)
 
 	# create accounts
@@ -453,6 +456,7 @@ def unset_existing_data(company):
 	fieldnames = get_linked_fields("Account").get("Company", {}).get("fieldname", [])
 	linked = [{"fieldname": name} for name in fieldnames]
 	update_values = {d.get("fieldname"): "" for d in linked}
+
 	frappe.db.set_value("Company", company, update_values, update_values)
 
 	# remove accounts data from various doctypes
@@ -464,8 +468,7 @@ def unset_existing_data(company):
 		"Sales Taxes and Charges Template",
 		"Purchase Taxes and Charges Template",
 	]:
-		dt = frappe.qb.DocType(doctype)
-		frappe.qb.from_(dt).where(dt.company == company).delete().run()
+		frappe.get_query(doctype, delete=True, filters={"company": company}, ignore_permissions=False).run()
 
 
 def set_default_accounts(company):

erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js

@@ -6,12 +6,14 @@ frappe.provide("erpnext.cheque_print");
 frappe.ui.form.on("Cheque Print Template", {
 	refresh: function (frm) {
 		if (!frm.doc.__islocal) {
-			frm.add_custom_button(
-				frm.doc.has_print_format ? __("Update Print Format") : __("Create Print Format"),
-				function () {
-					erpnext.cheque_print.view_cheque_print(frm);
-				}
-			).addClass("btn-primary");
+			if (frappe.user.has_role("System Manager")) {
+				frm.add_custom_button(
+					frm.doc.has_print_format ? __("Update Print Format") : __("Create Print Format"),
+					function () {
+						erpnext.cheque_print.view_cheque_print(frm);
+					}
+				).addClass("btn-primary");
+			}
 
 			$(frm.fields_dict.cheque_print_preview.wrapper).empty();
 

erpnext/accounts/doctype/cheque_print_template/cheque_print_template.json

@@ -1,5 +1,6 @@
 {
  "actions": [],
+ "allow_bulk_edit": 1,
  "autoname": "field:bank_name",
  "creation": "2016-05-04 14:35:00.402544",
  "doctype": "DocType",
@@ -294,7 +295,7 @@
  ],
  "links": [],
  "max_attachments": 1,
- "modified": "2024-03-27 13:06:44.654989",
+ "modified": "2026-06-08 12:10:35.829531",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Cheque Print Template",
@@ -325,19 +326,17 @@
    "write": 1
   },
   {
-   "create": 1,
-   "delete": 1,
    "email": 1,
    "export": 1,
    "print": 1,
    "read": 1,
    "report": 1,
    "role": "Accounts User",
-   "share": 1,
-   "write": 1
+   "share": 1
   }
  ],
+ "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/cheque_print_template/cheque_print_template.py

@@ -48,6 +48,8 @@ class ChequePrintTemplate(Document):
 
 @frappe.whitelist()
 def create_or_update_cheque_print_format(template_name: str):
+	frappe.only_for("System Manager")
+
 	if not frappe.db.exists("Print Format", template_name):
 		cheque_print = frappe.new_doc("Print Format")
 		cheque_print.update(

erpnext/accounts/doctype/cost_center/cost_center.py

@@ -84,10 +84,10 @@ class CostCenter(NestedSet):
 		return frappe.db.get_value("GL Entry", {"cost_center": self.name})
 
 	def check_if_child_exists(self):
-		return frappe.db.sql(
-			"select name from `tabCost Center` where \
-			parent_cost_center = %s and docstatus != 2",
-			self.name,
+		return frappe.get_all(
+			"Cost Center",
+			filters={"parent_cost_center": self.name, "docstatus": ["!=", 2]},
+			pluck="name",
 		)
 
 	def if_allocation_exists_against_cost_center(self):

erpnext/accounts/doctype/cost_center_allocation/test_cost_center_allocation.py

@@ -182,7 +182,7 @@ class TestCostCenterAllocation(ERPNextTestSuite):
 		self.assertTrue(gl_entries)
 
 		for gle in gl_entries:
-			self.assertTrue(gle.cost_center in expected_values)
+			self.assertIn(gle.cost_center, expected_values)
 			self.assertEqual(gle.debit, 0)
 			self.assertEqual(gle.credit, expected_values[gle.cost_center])
 

erpnext/accounts/doctype/coupon_code/test_coupon_code.py

@@ -173,3 +173,66 @@ class TestCouponCode(ERPNextTestSuite):
 
 		# Clean up
 		coupon.delete()
+
+	def test_validate_coupon_code_rejections(self):
+		from frappe.utils import add_days, nowdate
+
+		from erpnext.accounts.doctype.pricing_rule.utils import validate_coupon_code
+
+		pricing_rule = frappe.db.get_value("Pricing Rule", {"title": "_Test Pricing Rule for _Test Item"})
+
+		def make_coupon(name, **kwargs):
+			frappe.delete_doc_if_exists("Coupon Code", name)
+			return frappe.get_doc(
+				{
+					"doctype": "Coupon Code",
+					"coupon_name": name,
+					"coupon_code": name,
+					"coupon_type": "Promotional",
+					"pricing_rule": pricing_rule,
+					**kwargs,
+				}
+			).insert(ignore_permissions=True)
+
+		with self.subTest("validity not yet started"):
+			make_coupon("_Test Coupon Future", valid_from=add_days(nowdate(), 5))
+			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Future")
+
+		with self.subTest("validity expired"):
+			make_coupon("_Test Coupon Expired", valid_upto=add_days(nowdate(), -5))
+			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Expired")
+
+		with self.subTest("maximum use exhausted"):
+			make_coupon("_Test Coupon Exhausted", maximum_use=2, used=2)
+			self.assertRaises(frappe.ValidationError, validate_coupon_code, "_Test Coupon Exhausted")
+
+		with self.subTest("valid coupon passes"):
+			make_coupon("_Test Coupon Valid", maximum_use=5, used=1, valid_upto=add_days(nowdate(), 5))
+			validate_coupon_code("_Test Coupon Valid")  # no raise
+
+	def test_update_coupon_code_count_cancel_and_exhaust(self):
+		from erpnext.accounts.doctype.pricing_rule.utils import update_coupon_code_count
+
+		pricing_rule = frappe.db.get_value("Pricing Rule", {"title": "_Test Pricing Rule for _Test Item"})
+		frappe.delete_doc_if_exists("Coupon Code", "_Test Coupon Count")
+		frappe.get_doc(
+			{
+				"doctype": "Coupon Code",
+				"coupon_name": "_Test Coupon Count",
+				"coupon_code": "_Test Coupon Count",
+				"coupon_type": "Promotional",
+				"pricing_rule": pricing_rule,
+				"maximum_use": 2,
+				"used": 1,
+			}
+		).insert(ignore_permissions=True)
+
+		# cancelling a transaction releases one use
+		update_coupon_code_count("_Test Coupon Count", "cancelled")
+		self.assertEqual(frappe.db.get_value("Coupon Code", "_Test Coupon Count", "used"), 0)
+
+		# using up to the maximum is allowed, beyond it is rejected
+		update_coupon_code_count("_Test Coupon Count", "used")
+		update_coupon_code_count("_Test Coupon Count", "used")
+		self.assertEqual(frappe.db.get_value("Coupon Code", "_Test Coupon Count", "used"), 2)
+		self.assertRaises(frappe.ValidationError, update_coupon_code_count, "_Test Coupon Count", "used")

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.js

@@ -11,22 +11,28 @@ frappe.ui.form.on("Currency Exchange Settings", {
 			},
 			callback: function (r) {
 				if (r && r.message) {
+					let result = [],
+						params = {};
 					if (frm.doc.service_provider == "exchangerate.host") {
-						let result = ["result"];
-						let params = {
+						result = ["result"];
+						params = {
 							date: "{transaction_date}",
 							from: "{from_currency}",
 							to: "{to_currency}",
 						};
-						add_param(frm, r.message, params, result);
 					} else if (["frankfurter.app", "frankfurter.dev"].includes(frm.doc.service_provider)) {
-						let result = ["rates", "{to_currency}"];
-						let params = {
+						result = ["rates", "{to_currency}"];
+						params = {
 							base: "{from_currency}",
 							symbols: "{to_currency}",
 						};
-						add_param(frm, r.message, params, result);
+					} else if (frm.doc.service_provider == "frankfurter.dev - v2") {
+						result = ["rate"];
+						params = {
+							date: "{transaction_date}",
+						};
 					}
+					add_param(frm, r.message, params, result);
 				}
 			},
 		});

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.json

@@ -78,7 +78,7 @@
    "fieldname": "service_provider",
    "fieldtype": "Select",
    "label": "Service Provider",
-   "options": "frankfurter.dev\nexchangerate.host\nCustom",
+   "options": "frankfurter.dev\nexchangerate.host\nfrankfurter.dev - v2\nCustom",
    "reqd": 1
   },
   {
@@ -101,11 +101,10 @@
    "label": "Use HTTP Protocol"
   }
  ],
- "hide_toolbar": 0,
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-03-16 13:28:21.075743",
+ "modified": "2026-06-15 11:25:55.873110",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Currency Exchange Settings",
@@ -122,24 +121,11 @@
    "write": 1
   },
   {
-   "create": 1,
-   "delete": 1,
-   "email": 1,
-   "print": 1,
-   "read": 1,
-   "role": "Accounts Manager",
-   "share": 1,
-   "write": 1
-  },
-  {
-   "create": 1,
-   "delete": 1,
    "email": 1,
    "print": 1,
    "read": 1,
    "role": "Accounts User",
-   "share": 1,
-   "write": 1
+   "share": 1
   }
  ],
  "row_format": "Dynamic",

erpnext/accounts/doctype/currency_exchange_settings/currency_exchange_settings.py

@@ -29,7 +29,7 @@ class CurrencyExchangeSettings(Document):
 		disabled: DF.Check
 		req_params: DF.Table[CurrencyExchangeSettingsDetails]
 		result_key: DF.Table[CurrencyExchangeSettingsResult]
-		service_provider: DF.Literal["frankfurter.dev", "exchangerate.host", "Custom"]
+		service_provider: DF.Literal["frankfurter.dev", "exchangerate.host", "frankfurter.dev - v2", "Custom"]
 		url: DF.Data | None
 		use_http: DF.Check
 	# end: auto-generated types
@@ -70,6 +70,14 @@ class CurrencyExchangeSettings(Document):
 			self.append("req_params", {"key": "base", "value": "{from_currency}"})
 			self.append("req_params", {"key": "symbols", "value": "{to_currency}"})
 
+		elif self.service_provider == "frankfurter.dev - v2":
+			self.set("result_key", [])
+			self.set("req_params", [])
+
+			self.api_endpoint = get_api_endpoint(self.service_provider, self.use_http)
+			self.append("result_key", {"key": "rate"})
+			self.append("req_params", {"key": "date", "value": "{transaction_date}"})
+
 	def validate_parameters(self):
 		params = {}
 		for row in self.req_params:
@@ -82,7 +90,7 @@ class CurrencyExchangeSettings(Document):
 		try:
 			response = requests.get(api_url, params=params)
 		except requests.exceptions.RequestException as e:
-			frappe.throw("Error: " + str(e))
+			frappe.throw(_("Error: {0}").format(str(e)))
 
 		response.raise_for_status()
 		value = response.json()
@@ -105,13 +113,20 @@ class CurrencyExchangeSettings(Document):
 
 @frappe.whitelist()
 def get_api_endpoint(service_provider: str | None = None, use_http: bool = False):
-	if service_provider and service_provider in ["exchangerate.host", "frankfurter.dev", "frankfurter.app"]:
+	if service_provider and service_provider in [
+		"exchangerate.host",
+		"frankfurter.dev",
+		"frankfurter.app",
+		"frankfurter.dev - v2",
+	]:
 		if service_provider == "exchangerate.host":
 			api = "api.exchangerate.host/convert"
 		elif service_provider == "frankfurter.app":
 			api = "api.frankfurter.app/{transaction_date}"
 		elif service_provider == "frankfurter.dev":
 			api = "api.frankfurter.dev/v1/{transaction_date}"
+		elif service_provider == "frankfurter.dev - v2":
+			api = "api.frankfurter.dev/v2/rate/{from_currency}/{to_currency}"
 
 		protocol = "https://"
 		if use_http:

erpnext/accounts/doctype/dunning/dunning.js

@@ -60,7 +60,7 @@ frappe.ui.form.on("Dunning", {
 		if (frm.doc.docstatus === 0) {
 			frm.add_custom_button(__("Fetch Overdue Payments"), () => {
 				erpnext.utils.map_current_doc({
-					method: "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning",
+					method: "erpnext.accounts.doctype.sales_invoice.mapper.create_dunning",
 					source_doctype: "Sales Invoice",
 					date_field: "due_date",
 					target: frm,

erpnext/accounts/doctype/dunning/dunning.py

@@ -85,7 +85,7 @@ class Dunning(AccountsController):
 			if invoice_currency != self.currency:
 				frappe.throw(
 					_(
-						"The currency of invoice {} ({}) is different from the currency of this dunning ({})."
+						"The currency of invoice {0} ({1}) is different from the currency of this dunning ({2})."
 					).format(
 						frappe.get_desk_link(
 							"Sales Invoice",
@@ -248,8 +248,7 @@ def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str |
 	DOCTYPE = "Dunning Letter Text"
 	FIELDS = ["body_text", "closing_text", "language"]
 
-	if isinstance(doc, str):
-		doc = json.loads(doc)
+	doc = frappe.parse_json(doc)
 
 	if not language:
 		language = doc.get("language")

erpnext/accounts/doctype/dunning/test_dunning.py

@@ -8,7 +8,7 @@ from frappe.utils import add_days, nowdate, today
 
 from erpnext import get_default_cost_center
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import get_payment_entry
-from erpnext.accounts.doctype.sales_invoice.sales_invoice import (
+from erpnext.accounts.doctype.sales_invoice.mapper import (
 	create_dunning as create_dunning_from_sales_invoice,
 )
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import (
@@ -73,7 +73,7 @@ class TestDunning(ERPNextTestSuite):
 		dunning = create_dunning_from_sales_invoice(si1.name)
 		dunning.overdue_payments = []
 
-		method = "erpnext.accounts.doctype.sales_invoice.sales_invoice.create_dunning"
+		method = "erpnext.accounts.doctype.sales_invoice.mapper.create_dunning"
 		updated_dunning = mapper.map_docs(method, json.dumps([si1.name, si2.name]), dunning)
 
 		self.assertEqual(len(updated_dunning.overdue_payments), 2)

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -136,7 +136,7 @@ frappe.ui.form.on("Exchange Rate Revaluation Account", {
 var get_account_details = function (frm, cdt, cdn) {
 	var row = frappe.get_doc(cdt, cdn);
 	if (!frm.doc.company || !frm.doc.posting_date) {
-		frappe.throw(__("Please select Company and Posting Date to getting entries"));
+		frappe.throw(__("Please select Company and Posting Date to get entries"));
 	}
 	frappe.call({
 		method: "erpnext.accounts.doctype.exchange_rate_revaluation.exchange_rate_revaluation.get_account_details",

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -8,7 +8,7 @@ from frappe import _, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.query_builder import Criterion, Order
-from frappe.query_builder.functions import NullIf, Sum
+from frappe.query_builder.functions import Max, NullIf, Sum
 from frappe.utils import flt, get_link_to_form
 
 import erpnext
@@ -73,7 +73,7 @@ class ExchangeRateRevaluation(Document):
 
 	def validate_mandatory(self):
 		if not (self.company and self.posting_date):
-			frappe.throw(_("Please select Company and Posting Date to getting entries"))
+			frappe.throw(_("Please select Company and Posting Date to get entries"))
 
 	def before_submit(self):
 		self.remove_accounts_without_gain_loss()
@@ -188,12 +188,18 @@ class ExchangeRateRevaluation(Document):
 				accounts = [x[0] for x in res]
 
 			if accounts:
-				having_clause = (qb.Field("balance") != qb.Field("balance_in_account_currency")) & (
-					(qb.Field("balance_in_account_currency") != 0) | (qb.Field("balance") != 0)
-				)
-
 				gle = qb.DocType("GL Entry")
 
+				# balance expressions reused in both SELECT and HAVING; postgres can't reference a
+				# SELECT alias inside HAVING, so the aggregate expression must be repeated there.
+				balance = Sum(gle.debit) - Sum(gle.credit)
+				balance_in_account_currency = Sum(gle.debit_in_account_currency) - Sum(
+					gle.credit_in_account_currency
+				)
+				having_clause = (balance != balance_in_account_currency) & (
+					(balance_in_account_currency != 0) | (balance != 0)
+				)
+
 				# conditions
 				conditions = []
 				conditions.append(gle.account.isin(accounts))
@@ -209,17 +215,15 @@ class ExchangeRateRevaluation(Document):
 					qb.from_(gle)
 					.select(
 						gle.account,
-						gle.party_type,
-						gle.party,
-						gle.account_currency,
-						(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency)).as_(
-							"balance_in_account_currency"
-						),
-						(Sum(gle.debit) - Sum(gle.credit)).as_("balance"),
-						(Sum(gle.debit) - Sum(gle.credit) == 0)
-						^ (Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency) == 0).as_(
-							"zero_balance"
-						),
+						# grouped by NullIf(party_type/party, ""); the bare columns + account_currency are
+						# constant per group -> Max() keeps the GROUP BY valid on postgres with the same value.
+						Max(gle.party_type).as_("party_type"),
+						Max(gle.party).as_("party"),
+						Max(gle.account_currency).as_("account_currency"),
+						balance_in_account_currency.as_("balance_in_account_currency"),
+						balance.as_("balance"),
+						# zero_balance is recomputed in Python below (after rounding), so the SQL value is
+						# unused -- dropped (it used MySQL's XOR operator, which postgres lacks).
 					)
 					.where(Criterion.all(conditions))
 					.groupby(gle.account, NullIf(gle.party_type, ""), NullIf(gle.party, ""))
@@ -346,12 +350,14 @@ class ExchangeRateRevaluation(Document):
 		zero_balance_jv = self.make_jv_for_zero_balance()
 		if zero_balance_jv:
 			frappe.msgprint(
-				f"Zero Balance Journal: {get_link_to_form('Journal Entry', zero_balance_jv.name)}"
+				_("Zero Balance Journal: {0}").format(get_link_to_form("Journal Entry", zero_balance_jv.name))
 			)
 
 		revaluation_jv = self.make_jv_for_revaluation()
 		if revaluation_jv:
-			frappe.msgprint(f"Revaluation Journal: {get_link_to_form('Journal Entry', revaluation_jv.name)}")
+			frappe.msgprint(
+				_("Revaluation Journal: {0}").format(get_link_to_form("Journal Entry", revaluation_jv.name))
+			)
 
 		return {
 			"revaluation_jv": revaluation_jv.name if revaluation_jv else None,
@@ -601,7 +607,10 @@ def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 
 		last_exchange_rate = (
 			qb.from_(gl)
-			.select((gl.debit - gl.credit) / (gl.debit_in_account_currency - gl.credit_in_account_currency))
+			.select(
+				(gl.debit - gl.credit)
+				/ NullIf(gl.debit_in_account_currency - gl.credit_in_account_currency, 0)
+			)
 			.where(
 				(gl.voucher_type == voucher_type) & (gl.voucher_no == voucher_no) & (gl.account == account)
 			)
@@ -622,6 +631,8 @@ def get_account_details(
 	party: str | None = None,
 	rounding_loss_allowance: float = 0.0,
 ):
+	frappe.has_permission("Account", doc=account, throw=True)
+
 	if not (company and posting_date):
 		frappe.throw(_("Company and Posting Date is mandatory"))
 

erpnext/accounts/doctype/exchange_rate_revaluation/test_exchange_rate_revaluation.py

@@ -15,11 +15,11 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.create_company()
-		self.create_usd_receivable_account()
-		self.create_item()
-		self.create_customer()
-		self.clear_old_entries()
+		self.company = "_Test Company"
+		self.item = "_Test Item"
+		self.customer = "_Test Customer"
+		self.cost_center = "Main - _TC"
+		self.debtors_usd = "_Test Receivable USD - _TC"
 		self.set_system_and_company_settings()
 
 	def set_system_and_company_settings(self):

erpnext/accounts/doctype/financial_report_template/financial_report_engine.py

@@ -12,8 +12,9 @@ from typing import Any, Union
 import frappe
 from frappe import _
 from frappe.database.operator_map import OPERATOR_MAP
+from frappe.model import numeric_fieldtypes
 from frappe.query_builder import Case
-from frappe.query_builder.functions import Sum
+from frappe.query_builder.functions import Cast_, Sum
 from frappe.utils import cstr, date_diff, flt, getdate
 from frappe.utils.xlsxutils import XLSXMetadata, XLSXStyleBuilder
 from pypika.terms import Bracket, LiteralValue
@@ -864,8 +865,15 @@ class FilterExpressionParser:
 		field = getattr(table, field_name, None)
 		operator_fn = OPERATOR_MAP.get(operator.casefold())
 
-		if "like" in operator.casefold() and "%" not in value:
-			value = f"%{value}%"
+		if "like" in operator.casefold():
+			if "%" not in value:
+				value = f"%{value}%"
+			# Postgres has no LIKE/ILIKE operator for non-text columns; MariaDB implicitly casts
+			# the numeric column to text. Cast a numeric/Check Account field to varchar so the
+			# match runs on both engines and reproduces MariaDB's result.
+			meta_field = frappe.get_meta("Account").get_field(field_name)
+			if meta_field and meta_field.fieldtype in numeric_fieldtypes:
+				field = Cast_(field, "varchar")
 
 		return operator_fn(field, value)
 
@@ -1024,8 +1032,7 @@ class FormulaFieldUpdater:
 def get_filtered_accounts(company: str, account_rows: str | list):
 	frappe.has_permission("Financial Report Template", ptype="read", throw=True)
 
-	if isinstance(account_rows, str):
-		account_rows = json.loads(account_rows, object_hook=frappe._dict)
+	account_rows = [frappe._dict(row) for row in frappe.parse_json(account_rows)]
 
 	return DataCollector.get_filtered_accounts(company, account_rows)
 

erpnext/accounts/doctype/financial_report_template/financial_report_validation.py

@@ -361,7 +361,7 @@ class CalculationFormulaValidator(Validator):
 					"sqrt": lambda x: x**0.5,
 					"pow": pow,
 					"ceil": lambda x: int(x) + (1 if x % 1 else 0),
-					"floor": lambda x: int(x),
+					"floor": int,
 				}
 			)
 

erpnext/accounts/doctype/fiscal_year/fiscal_year.py

@@ -72,10 +72,8 @@ class FiscalYear(Document):
 
 		if existing_fiscal_years:
 			for existing in existing_fiscal_years:
-				company_for_existing = frappe.db.sql_list(
-					"""select company from `tabFiscal Year Company`
-					where parent=%s""",
-					existing.name,
+				company_for_existing = frappe.get_all(
+					"Fiscal Year Company", filters={"parent": existing.name}, pluck="company"
 				)
 
 				overlap = False

erpnext/accounts/doctype/gl_entry/gl_entry.py

@@ -7,6 +7,7 @@ from frappe import _
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
 from frappe.model.naming import set_name_from_naming_options
+from frappe.query_builder.functions import Sum
 from frappe.utils import create_batch, flt, fmt_money, now
 
 import erpnext
@@ -331,10 +332,12 @@ def validate_balance_type(account, adv_adj=False):
 	if not adv_adj and account:
 		balance_must_be = frappe.get_cached_value("Account", account, "balance_must_be")
 		if balance_must_be:
-			balance = frappe.db.sql(
-				"""select sum(debit) - sum(credit)
-				from `tabGL Entry` where is_cancelled = 0 and account = %s""",
-				account,
+			gle = frappe.qb.DocType("GL Entry")
+			balance = (
+				frappe.qb.from_(gle)
+				.select(Sum(gle.debit) - Sum(gle.credit))
+				.where((gle.is_cancelled == 0) & (gle.account == account))
+				.run()
 			)[0][0]
 
 			if (balance_must_be == "Debit" and flt(balance) < 0) or (
@@ -348,44 +351,48 @@ def validate_balance_type(account, adv_adj=False):
 def update_outstanding_amt(
 	account, party_type, party, against_voucher_type, against_voucher, on_cancel=False
 ):
+	gle = frappe.qb.DocType("GL Entry")
+
+	conditions = (
+		(gle.against_voucher_type == against_voucher_type)
+		& (gle.against_voucher == against_voucher)
+		& (gle.voucher_type != "Invoice Discounting")
+	)
 	if party_type and party:
-		party_condition = " and party_type={} and party={}".format(
-			frappe.db.escape(party_type), frappe.db.escape(party)
-		)
-	else:
-		party_condition = ""
+		conditions &= (gle.party_type == party_type) & (gle.party == party)
 
 	if against_voucher_type == "Sales Invoice":
 		party_account = frappe.get_cached_value(against_voucher_type, against_voucher, "debit_to")
-		account_condition = f"and account in ({frappe.db.escape(account)}, {frappe.db.escape(party_account)})"
+		conditions &= gle.account.isin([account, party_account])
 	else:
-		account_condition = f" and account = {frappe.db.escape(account)}"
+		conditions &= gle.account == account
 
 	# get final outstanding amt
 	bal = flt(
-		frappe.db.sql(
-			f"""
-		select sum(debit_in_account_currency) - sum(credit_in_account_currency)
-		from `tabGL Entry`
-		where against_voucher_type=%s and against_voucher=%s
-		and voucher_type != 'Invoice Discounting'
-		{party_condition} {account_condition}""",
-			(against_voucher_type, against_voucher),
-		)[0][0]
+		frappe.qb.from_(gle)
+		.select(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency))
+		.where(conditions)
+		.run()[0][0]
 		or 0.0
 	)
 
 	if against_voucher_type == "Purchase Invoice":
 		bal = -bal
 	elif against_voucher_type == "Journal Entry":
+		je_conditions = (
+			(gle.voucher_type == "Journal Entry")
+			& (gle.voucher_no == against_voucher)
+			& (gle.account == account)
+			& (gle.against_voucher.isnull() | (gle.against_voucher == ""))
+		)
+		if party_type and party:
+			je_conditions &= (gle.party_type == party_type) & (gle.party == party)
+
 		against_voucher_amount = flt(
-			frappe.db.sql(
-				f"""
-			select sum(debit_in_account_currency) - sum(credit_in_account_currency)
-			from `tabGL Entry` where voucher_type = 'Journal Entry' and voucher_no = %s
-			and account = %s and (against_voucher is null or against_voucher='') {party_condition}""",
-				(against_voucher, account),
-			)[0][0]
+			frappe.qb.from_(gle)
+			.select(Sum(gle.debit_in_account_currency) - Sum(gle.credit_in_account_currency))
+			.where(je_conditions)
+			.run()[0][0]
 		)
 
 		if not against_voucher_amount:
@@ -480,10 +487,14 @@ def rename_temporarily_named_docs(doctype):
 			oldname = doc.name
 			set_name_from_naming_options(autoname, doc)
 			newname = doc.name
-			frappe.db.sql(
-				f"UPDATE `tab{doctype}` SET name = %s, to_rename = 0, modified = %s where name = %s",
-				(newname, now(), oldname),
-			)
+			dt = frappe.qb.DocType(doctype)
+			(
+				frappe.qb.update(dt)
+				.set(dt.name, newname)
+				.set(dt.to_rename, 0)
+				.set(dt.modified, now())
+				.where(dt.name == oldname)
+			).run()
 
 			for hook_type in ("on_gle_rename", "on_sle_rename"):
 				for hook in frappe.get_hooks(hook_type):

erpnext/accounts/doctype/gl_entry/test_gl_entry.py

@@ -26,12 +26,17 @@ class TestGLEntry(ERPNextTestSuite):
 		jv.flags.ignore_validate = True
 		jv.submit()
 
-		round_off_entry = frappe.db.sql(
-			"""select name from `tabGL Entry`
-			where voucher_type='Journal Entry' and voucher_no = %s
-			and account='_Test Write Off - _TC' and cost_center='_Test Cost Center - _TC'
-			and debit = 0 and credit = '.01'""",
-			jv.name,
+		round_off_entry = frappe.get_all(
+			"GL Entry",
+			filters={
+				"voucher_type": "Journal Entry",
+				"voucher_no": jv.name,
+				"account": "_Test Write Off - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"debit": 0,
+				"credit": 0.01,
+			},
+			pluck="name",
 		)
 
 		self.assertTrue(round_off_entry)
@@ -55,8 +60,9 @@ class TestGLEntry(ERPNextTestSuite):
 		)
 
 		self.assertTrue(all(entry.to_rename == 1 for entry in gl_entries))
-		old_naming_series_current_value = frappe.db.sql(
-			"SELECT current from tabSeries where name = %s", naming_series
+		series = frappe.qb.DocType("Series")
+		old_naming_series_current_value = (
+			frappe.qb.from_(series).select(series["current"]).where(series.name == naming_series).run()
 		)[0][0]
 
 		rename_gle_sle_docs()
@@ -73,8 +79,8 @@ class TestGLEntry(ERPNextTestSuite):
 			all(new.name != old.name for new, old in zip(gl_entries, new_gl_entries, strict=False))
 		)
 
-		new_naming_series_current_value = frappe.db.sql(
-			"SELECT current from tabSeries where name = %s", naming_series
+		new_naming_series_current_value = (
+			frappe.qb.from_(series).select(series["current"]).where(series.name == naming_series).run()
 		)[0][0]
 		self.assertEqual(old_naming_series_current_value + 2, new_naming_series_current_value)
 

erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py

@@ -317,58 +317,50 @@ class InvoiceDiscounting(AccountsController):
 
 
 @frappe.whitelist()
-def get_invoices(filters: str):
-	filters = frappe._dict(json.loads(filters))
-	cond = []
-	if filters.customer:
-		cond.append("customer=%(customer)s")
-	if filters.from_date:
-		cond.append("posting_date >= %(from_date)s")
-	if filters.to_date:
-		cond.append("posting_date <= %(to_date)s")
-	if filters.min_amount:
-		cond.append("base_grand_total >= %(min_amount)s")
-	if filters.max_amount:
-		cond.append("base_grand_total <= %(max_amount)s")
+def get_invoices(filters: str | dict):
+	filters = frappe._dict(frappe.parse_json(filters))
+	si = frappe.qb.DocType("Sales Invoice")
+	di = frappe.qb.DocType("Discounted Invoice")
 
-	where_condition = ""
-	if cond:
-		where_condition += " and " + " and ".join(cond)
+	discounted = frappe.qb.from_(di).select(di.sales_invoice).where(di.docstatus == 1)
 
-	return frappe.db.sql(
-		"""
-		select
-			name as sales_invoice,
-			customer,
-			posting_date,
-			outstanding_amount,
-			debit_to
-		from `tabSales Invoice` si
-		where
-			docstatus = 1
-			and outstanding_amount > 0
-			%s
-			and not exists(select di.name from `tabDiscounted Invoice` di
-				where di.docstatus=1 and di.sales_invoice=si.name)
-	"""
-		% where_condition,
-		filters,
-		as_dict=1,
+	query = (
+		frappe.qb.from_(si)
+		.select(
+			si.name.as_("sales_invoice"),
+			si.customer,
+			si.posting_date,
+			si.outstanding_amount,
+			si.debit_to,
+		)
+		.where((si.docstatus == 1) & (si.outstanding_amount > 0) & si.name.notin(discounted))
 	)
 
+	if filters.customer:
+		query = query.where(si.customer == filters.customer)
+	if filters.from_date:
+		query = query.where(si.posting_date >= filters.from_date)
+	if filters.to_date:
+		query = query.where(si.posting_date <= filters.to_date)
+	if filters.min_amount:
+		query = query.where(si.base_grand_total >= filters.min_amount)
+	if filters.max_amount:
+		query = query.where(si.base_grand_total <= filters.max_amount)
+
+	return query.run(as_dict=1)
+
 
 def get_party_account_based_on_invoice_discounting(sales_invoice):
 	party_account = None
-	invoice_discounting = frappe.db.sql(
-		"""
-		select par.accounts_receivable_discounted, par.accounts_receivable_unpaid, par.status
-		from `tabInvoice Discounting` par, `tabDiscounted Invoice` ch
-		where par.name=ch.parent
-			and par.docstatus=1
-			and ch.sales_invoice = %s
-	""",
-		(sales_invoice),
-		as_dict=1,
+	par = frappe.qb.DocType("Invoice Discounting")
+	ch = frappe.qb.DocType("Discounted Invoice")
+	invoice_discounting = (
+		frappe.qb.from_(par)
+		.inner_join(ch)
+		.on(par.name == ch.parent)
+		.select(par.accounts_receivable_discounted, par.accounts_receivable_unpaid, par.status)
+		.where((par.docstatus == 1) & (ch.sales_invoice == sales_invoice))
+		.run(as_dict=1)
 	)
 	if invoice_discounting:
 		if invoice_discounting[0].status == "Disbursed":

erpnext/accounts/doctype/invoice_discounting/test_invoice_discounting.py

@@ -5,7 +5,7 @@ import frappe
 from frappe.utils import add_days, flt, nowdate
 
 from erpnext.accounts.doctype.account.test_account import create_account
-from erpnext.accounts.doctype.journal_entry.journal_entry import get_payment_entry_against_invoice
+from erpnext.accounts.doctype.journal_entry.mapper import get_payment_entry_against_invoice
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import get_gl_entries
 from erpnext.tests.utils import ERPNextTestSuite

erpnext/accounts/doctype/journal_entry/mapper.py

@@ -0,0 +1,261 @@
+# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+"""Document builders that map a source document to a Journal Entry or to a
+Payment Entry raised against it."""
+
+import frappe
+from frappe import _
+from frappe.model.document import Document
+from frappe.utils import flt, get_link_to_form, nowdate
+
+from erpnext.accounts.doctype.invoice_discounting.invoice_discounting import (
+	get_party_account_based_on_invoice_discounting,
+)
+from erpnext.accounts.party import get_party_account
+from erpnext.accounts.utils import get_account_currency
+
+
+@frappe.whitelist()
+def get_payment_entry_against_order(
+	dt: str,
+	dn: str,
+	amount: float | None = None,
+	debit_in_account_currency: str | float | None = None,
+	journal_entry: bool = False,
+	bank_account: str | None = None,
+) -> dict | Document:
+	"""Build an advance-payment Journal Entry against an unbilled Sales/Purchase Order."""
+	ref_doc = frappe.get_doc(dt, dn)
+
+	if flt(ref_doc.per_billed, 2) > 0:
+		frappe.throw(_("Can only make payment against unbilled {0}").format(dt))
+
+	if dt == "Sales Order":
+		party_type = "Customer"
+		amount_field_party = "credit_in_account_currency"
+		amount_field_bank = "debit_in_account_currency"
+	else:
+		party_type = "Supplier"
+		amount_field_party = "debit_in_account_currency"
+		amount_field_bank = "credit_in_account_currency"
+
+	party_account = get_party_account(party_type, ref_doc.get(party_type.lower()), ref_doc.company)
+	party_account_currency = get_account_currency(party_account)
+
+	if not amount:
+		if party_account_currency == ref_doc.company_currency:
+			amount = flt(ref_doc.base_grand_total) - flt(ref_doc.advance_paid)
+		else:
+			amount = flt(ref_doc.grand_total) - flt(ref_doc.advance_paid)
+
+	return get_payment_entry(
+		ref_doc,
+		{
+			"party_type": party_type,
+			"party_account": party_account,
+			"party_account_currency": party_account_currency,
+			"amount_field_party": amount_field_party,
+			"amount_field_bank": amount_field_bank,
+			"amount": amount,
+			"debit_in_account_currency": debit_in_account_currency,
+			"remarks": f"Advance Payment received against {dt} {dn}",
+			"is_advance": "Yes",
+			"bank_account": bank_account,
+			"journal_entry": journal_entry,
+		},
+	)
+
+
+@frappe.whitelist()
+def get_payment_entry_against_invoice(
+	dt: str,
+	dn: str,
+	amount: float | None = None,
+	debit_in_account_currency: str | None = None,
+	journal_entry: bool = False,
+	bank_account: str | None = None,
+) -> dict | Document:
+	"""Build a payment Journal Entry against a Sales/Purchase Invoice's outstanding amount."""
+	ref_doc = frappe.get_doc(dt, dn)
+	if dt == "Sales Invoice":
+		party_type = "Customer"
+		party_account = get_party_account_based_on_invoice_discounting(dn) or ref_doc.debit_to
+	else:
+		party_type = "Supplier"
+		party_account = ref_doc.credit_to
+
+	if (dt == "Sales Invoice" and ref_doc.outstanding_amount > 0) or (
+		dt == "Purchase Invoice" and ref_doc.outstanding_amount < 0
+	):
+		amount_field_party = "credit_in_account_currency"
+		amount_field_bank = "debit_in_account_currency"
+	else:
+		amount_field_party = "debit_in_account_currency"
+		amount_field_bank = "credit_in_account_currency"
+
+	return get_payment_entry(
+		ref_doc,
+		{
+			"party_type": party_type,
+			"party_account": party_account,
+			"party_account_currency": ref_doc.party_account_currency,
+			"amount_field_party": amount_field_party,
+			"amount_field_bank": amount_field_bank,
+			"amount": amount if amount else abs(ref_doc.outstanding_amount),
+			"debit_in_account_currency": debit_in_account_currency,
+			"remarks": f"Payment received against {dt} {dn}. {ref_doc.remarks}",
+			"is_advance": "No",
+			"bank_account": bank_account,
+			"journal_entry": journal_entry,
+		},
+	)
+
+
+def get_payment_entry(ref_doc, args: dict) -> dict | Document:
+	"""Build a Bank Entry Journal Entry paying `ref_doc`, with a party row and a bank row.
+
+	Returns the Journal Entry document when `args["journal_entry"]` is truthy, otherwise its
+	dict (for client calls).
+	"""
+	je = frappe.new_doc("Journal Entry")
+	je.update({"voucher_type": "Bank Entry", "company": ref_doc.company, "remark": args.get("remarks")})
+
+	cost_center = ref_doc.get("cost_center") or frappe.get_cached_value(
+		"Company", ref_doc.company, "cost_center"
+	)
+	exchange_rate = _reference_exchange_rate(ref_doc, args)
+
+	party_row = _append_party_row(je, ref_doc, args, cost_center, exchange_rate)
+	bank_row = _append_bank_row(je, ref_doc, args, cost_center, exchange_rate)
+
+	if party_row.account_currency != ref_doc.company_currency or (
+		bank_row.account_currency and bank_row.account_currency != ref_doc.company_currency
+	):
+		je.multi_currency = 1
+
+	je.set_amounts_in_company_currency()
+	je.set_total_debit_credit()
+
+	return je if args.get("journal_entry") else je.as_dict()
+
+
+def _reference_exchange_rate(ref_doc, args: dict) -> float:
+	"""Exchange rate of the party account on the reference document's posting date."""
+	if not args.get("party_account"):
+		return 1
+
+	from erpnext.accounts.doctype.journal_entry.journal_entry import get_exchange_rate
+
+	return get_exchange_rate(
+		ref_doc.get("posting_date") or ref_doc.get("transaction_date"),
+		args.get("party_account"),
+		args.get("party_account_currency"),
+		ref_doc.company,
+		ref_doc.doctype,
+		ref_doc.name,
+	)
+
+
+def _append_party_row(je, ref_doc, args: dict, cost_center, exchange_rate: float):
+	"""Append the party (debtor/creditor) row that records the advance/payment."""
+	return je.append(
+		"accounts",
+		{
+			"account": args.get("party_account"),
+			"party_type": args.get("party_type"),
+			"party": ref_doc.get(args.get("party_type").lower()),
+			"cost_center": cost_center,
+			"account_type": frappe.get_cached_value("Account", args.get("party_account"), "account_type"),
+			"account_currency": args.get("party_account_currency")
+			or get_account_currency(args.get("party_account")),
+			"exchange_rate": exchange_rate,
+			args.get("amount_field_party"): args.get("amount"),
+			"is_advance": args.get("is_advance"),
+			"reference_type": ref_doc.doctype,
+			"reference_name": ref_doc.name,
+		},
+	)
+
+
+def _append_bank_row(je, ref_doc, args: dict, cost_center, exchange_rate: float):
+	"""Append the bank/cash row, defaulting the account and converting the amount to it."""
+	from erpnext.accounts.doctype.journal_entry.journal_entry import (
+		get_default_bank_cash_account,
+		get_exchange_rate,
+	)
+
+	bank_row = je.append("accounts")
+	bank_account = get_default_bank_cash_account(ref_doc.company, "Bank", account=args.get("bank_account"))
+	if bank_account:
+		bank_row.update(bank_account)
+		# posting date assumed to be the reference document's posting/transaction date
+		bank_row.exchange_rate = get_exchange_rate(
+			ref_doc.get("posting_date") or ref_doc.get("transaction_date"),
+			bank_account["account"],
+			bank_account["account_currency"],
+			ref_doc.company,
+		)
+
+	bank_row.cost_center = cost_center
+
+	amount = args.get("debit_in_account_currency") or args.get("amount")
+	if bank_row.account_currency == args.get("party_account_currency"):
+		bank_row.set(args.get("amount_field_bank"), amount)
+	else:
+		bank_row.set(args.get("amount_field_bank"), amount * exchange_rate)
+
+	return bank_row
+
+
+@frappe.whitelist()
+def make_inter_company_journal_entry(name: str, voucher_type: str, company: str) -> dict:
+	"""Build the counterpart Journal Entry in another company, linked back to `name`."""
+	journal_entry = frappe.new_doc("Journal Entry")
+	journal_entry.voucher_type = voucher_type
+	journal_entry.company = company
+	journal_entry.posting_date = nowdate()
+	journal_entry.inter_company_journal_entry_reference = name
+	return journal_entry.as_dict()
+
+
+@frappe.whitelist()
+def make_reverse_journal_entry(source_name: str, target_doc: str | Document | None = None) -> Document:
+	"""Map a submitted Journal Entry to a reversing one (debits and credits swapped)."""
+	existing_reverse = frappe.db.exists("Journal Entry", {"reversal_of": source_name, "docstatus": 1})
+	if existing_reverse:
+		frappe.throw(
+			_("A Reverse Journal Entry {0} already exists for this Journal Entry.").format(
+				get_link_to_form("Journal Entry", existing_reverse)
+			)
+		)
+
+	from frappe.model.mapper import get_mapped_doc
+
+	def post_process(source, target) -> None:
+		target.reversal_of = source.name
+
+	doclist = get_mapped_doc(
+		"Journal Entry",
+		source_name,
+		{
+			"Journal Entry": {"doctype": "Journal Entry", "validation": {"docstatus": ["=", 1]}},
+			"Journal Entry Account": {
+				"doctype": "Journal Entry Account",
+				"field_map": {
+					"account_currency": "account_currency",
+					"exchange_rate": "exchange_rate",
+					"debit_in_account_currency": "credit_in_account_currency",
+					"debit": "credit",
+					"credit_in_account_currency": "debit_in_account_currency",
+					"credit": "debit",
+					"reference_type": "reference_type",
+					"reference_name": "reference_name",
+				},
+			},
+		},
+		target_doc,
+		post_process,
+	)
+
+	return doclist

erpnext/accounts/doctype/journal_entry/services/asset_service.py

@@ -0,0 +1,200 @@
+# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+import frappe
+from frappe import _
+from frappe.utils import flt
+
+from erpnext.assets.doctype.asset_depreciation_schedule.asset_depreciation_schedule import (
+	get_depr_schedule,
+)
+
+
+class AssetService:
+	"""Keeps Assets in sync with the Journal Entries that depreciate, dispose or
+	adjust them.
+
+	On submit of a Depreciation Entry it reduces the asset value and links the
+	depreciation schedule; on submit of an Asset Disposal it marks the asset
+	disposed. On cancel it reverses those links. It also guards cancellation of
+	Journal Entries tied to asset scrapping or value adjustments.
+	"""
+
+	def __init__(self, doc) -> None:
+		self.doc = doc
+
+	def validate_depr_account_and_depr_entry_voucher_type(self) -> None:
+		"""A depreciation account requires voucher type Depreciation Entry and an Expense account."""
+		for d in self.doc.get("accounts"):
+			if d.account_type == "Depreciation":
+				if self.doc.voucher_type != "Depreciation Entry":
+					frappe.throw(
+						_("Journal Entry type should be set as Depreciation Entry for asset depreciation")
+					)
+
+				if frappe.get_cached_value("Account", d.account, "root_type") != "Expense":
+					frappe.throw(_("Account {0} should be of type Expense").format(d.account))
+
+	def has_asset_adjustment_entry(self) -> None:
+		"""Block cancellation while a submitted Asset Value Adjustment links to this entry."""
+		if self.doc.flags.get("via_asset_value_adjustment"):
+			return
+
+		asset_value_adjustment = frappe.db.get_value(
+			"Asset Value Adjustment", {"docstatus": 1, "journal_entry": self.doc.name}, "name"
+		)
+		if asset_value_adjustment:
+			frappe.throw(
+				_(
+					"Cannot cancel this document as it is linked with the submitted Asset Value Adjustment <b>{0}</b>. Please cancel the Asset Value Adjustment to continue."
+				).format(frappe.utils.get_link_to_form("Asset Value Adjustment", asset_value_adjustment))
+			)
+
+	def update_asset_value(self) -> None:
+		"""Apply the entry's effect to its linked assets on submit (depreciation or disposal)."""
+		self.update_asset_on_depreciation()
+		self.update_asset_on_disposal()
+
+	def update_asset_on_depreciation(self) -> None:
+		"""Reduce each depreciated asset's value and link the depreciation schedule row."""
+		if self.doc.voucher_type != "Depreciation Entry":
+			return
+
+		for d in self.doc.get("accounts"):
+			if (
+				d.reference_type == "Asset"
+				and d.reference_name
+				and frappe.get_cached_value("Account", d.account, "root_type") == "Expense"
+				and d.debit
+			):
+				asset = frappe.get_cached_doc("Asset", d.reference_name)
+
+				if asset.calculate_depreciation:
+					self.update_journal_entry_link_on_depr_schedule(asset, d)
+					self.update_value_after_depreciation(asset, d.debit)
+
+				asset.db_set("value_after_depreciation", asset.value_after_depreciation - d.debit)
+				asset.set_status()
+				asset.set_total_booked_depreciations()
+
+	def update_value_after_depreciation(self, asset, depr_amount: float) -> None:
+		"""Subtract the depreciation amount from the asset's relevant finance book."""
+		fb_idx = 1
+		if self.doc.finance_book:
+			for fb_row in asset.get("finance_books"):
+				if fb_row.finance_book == self.doc.finance_book:
+					fb_idx = fb_row.idx
+					break
+		fb_row = asset.get("finance_books")[fb_idx - 1]
+		fb_row.value_after_depreciation -= depr_amount
+		frappe.db.set_value(
+			"Asset Finance Book", fb_row.name, "value_after_depreciation", fb_row.value_after_depreciation
+		)
+
+	def update_journal_entry_link_on_depr_schedule(self, asset, je_row) -> None:
+		"""Stamp this entry onto the matching (date + amount) depreciation schedule row."""
+		depr_schedule = get_depr_schedule(asset.name, "Active", self.doc.finance_book)
+		for d in depr_schedule or []:
+			if (
+				d.schedule_date == self.doc.posting_date
+				and not d.journal_entry
+				and d.depreciation_amount == flt(je_row.debit)
+			):
+				frappe.db.set_value("Depreciation Schedule", d.name, "journal_entry", self.doc.name)
+
+	def update_asset_on_disposal(self) -> None:
+		"""Mark each referenced asset disposed (date + scrap entry) on an Asset Disposal."""
+		if self.doc.voucher_type == "Asset Disposal":
+			disposed_assets = []
+			for d in self.doc.get("accounts"):
+				if (
+					d.reference_type == "Asset"
+					and d.reference_name
+					and d.reference_name not in disposed_assets
+				):
+					frappe.db.set_value(
+						"Asset",
+						d.reference_name,
+						{
+							"disposal_date": self.doc.posting_date,
+							"journal_entry_for_scrap": self.doc.name,
+						},
+					)
+					asset_doc = frappe.get_doc("Asset", d.reference_name)
+					asset_doc.set_status()
+					disposed_assets.append(d.reference_name)
+
+	def unlink_asset_reference(self) -> None:
+		"""On cancel, reverse depreciation links and block cancelling an asset-scrap entry."""
+		for d in self.doc.get("accounts"):
+			if self._is_depreciation_asset_row(d):
+				self._reverse_asset_depreciation(d)
+			elif (
+				self.doc.voucher_type == "Journal Entry" and d.reference_type == "Asset" and d.reference_name
+			):
+				self._block_scrap_journal_cancel(d)
+
+	def _is_depreciation_asset_row(self, d) -> bool:
+		return bool(
+			self.doc.voucher_type == "Depreciation Entry"
+			and d.reference_type == "Asset"
+			and d.reference_name
+			and frappe.get_cached_value("Account", d.account, "root_type") == "Expense"
+			and d.debit
+		)
+
+	def _reverse_asset_depreciation(self, d) -> None:
+		"""Add the depreciation amount back to the asset and unlink its schedule row."""
+		asset = frappe.get_doc("Asset", d.reference_name)
+
+		if asset.calculate_depreciation and not self._restore_scheduled_depreciation(asset, d.debit):
+			self._restore_finance_book_value(asset, d.debit)
+
+		asset.db_set("value_after_depreciation", asset.value_after_depreciation + d.debit)
+		asset.set_status()
+		asset.set_total_booked_depreciations()
+
+	def _restore_scheduled_depreciation(self, asset, debit: float) -> bool:
+		"""Unlink this entry from the depreciation schedule and credit back its finance book.
+
+		Returns True if a matching scheduled depreciation was found.
+		"""
+		for fb_row in asset.get("finance_books"):
+			depr_schedule = get_depr_schedule(asset.name, "Active", fb_row.finance_book)
+			for s in depr_schedule or []:
+				if s.journal_entry == self.doc.name:
+					s.db_set("journal_entry", None)
+					fb_row.value_after_depreciation += debit
+					fb_row.db_update()
+					return True
+		return False
+
+	def _restore_finance_book_value(self, asset, debit: float) -> None:
+		"""Credit the depreciation amount back to the relevant finance book when no schedule matched."""
+		fb_idx = 1
+		if self.doc.finance_book:
+			for fb_row in asset.get("finance_books"):
+				if fb_row.finance_book == self.doc.finance_book:
+					fb_idx = fb_row.idx
+					break
+
+		fb_row = asset.get("finance_books")[fb_idx - 1]
+		fb_row.value_after_depreciation += debit
+		fb_row.db_update()
+
+	def _block_scrap_journal_cancel(self, d) -> None:
+		"""Prevent cancelling a plain Journal Entry that is an asset's scrap voucher."""
+		journal_entry_for_scrap = frappe.db.get_value("Asset", d.reference_name, "journal_entry_for_scrap")
+		if journal_entry_for_scrap == self.doc.name:
+			frappe.throw(
+				_("Journal Entry for Asset scrapping cannot be cancelled. Please restore the Asset.")
+			)
+
+	def unlink_asset_adjustment_entry(self) -> None:
+		"""Detach this entry from any Asset Value Adjustment that referenced it."""
+		AssetValueAdjustment = frappe.qb.DocType("Asset Value Adjustment")
+		(
+			frappe.qb.update(AssetValueAdjustment)
+			.set(AssetValueAdjustment.journal_entry, None)
+			.where(AssetValueAdjustment.journal_entry == self.doc.name)
+		).run()

erpnext/accounts/doctype/journal_entry/services/gl_composer.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+import frappe
+from frappe.utils import flt
+
+import erpnext
+from erpnext.accounts.services.base_gl_composer import BaseGLComposer
+from erpnext.accounts.utils import get_advance_payment_doctypes
+
+
+class JournalEntryGLComposer(BaseGLComposer):
+	"""Assembles the GL entries for a Journal Entry.
+
+	A Journal Entry already carries its ledger rows in the ``accounts`` child
+	table, so composing is a straight projection of those rows into GL dicts
+	via ``self.get_gl_dict``. The transaction currency/rate are resolved
+	from the first foreign-currency row (mirroring the former build_gl_map).
+	"""
+
+	def compose(self) -> list:
+		"""Project the Journal Entry's non-zero account rows into GL dicts."""
+		self._set_transaction_currency()
+		advance_doctypes = get_advance_payment_doctypes()
+
+		gl_map = []
+		for d in self.doc.get("accounts"):
+			if d.debit or d.credit or self.doc.voucher_type == "Exchange Gain Or Loss":
+				gl_map.append(self.get_gl_dict(self._gl_row(d, advance_doctypes), item=d))
+		return gl_map
+
+	def _set_transaction_currency(self) -> None:
+		"""Company currency, or the first foreign-currency row, becomes the transaction currency."""
+		doc = self.doc
+		doc.transaction_currency = erpnext.get_company_currency(doc.company)
+		doc.transaction_exchange_rate = 1
+		if not doc.multi_currency:
+			return
+
+		for row in doc.get("accounts"):
+			if row.account_currency != doc.transaction_currency:
+				# Journal assumes the first foreign currency as transaction currency
+				doc.transaction_currency = row.account_currency
+				doc.transaction_exchange_rate = row.exchange_rate
+				break
+
+	def _gl_row(self, d, advance_doctypes: list) -> dict:
+		"""Build the GL dict for a single account row."""
+		doc = self.doc
+		remarks = "\n".join(x for x in [d.user_remark, doc.remark] if x)
+
+		row = {
+			"account": d.account,
+			"party_type": d.party_type,
+			"due_date": doc.due_date,
+			"party": d.party,
+			"against": d.against_account,
+			"debit": flt(d.debit, d.precision("debit")),
+			"credit": flt(d.credit, d.precision("credit")),
+			"account_currency": d.account_currency,
+			"debit_in_account_currency": flt(
+				d.debit_in_account_currency, d.precision("debit_in_account_currency")
+			),
+			"credit_in_account_currency": flt(
+				d.credit_in_account_currency, d.precision("credit_in_account_currency")
+			),
+			"transaction_currency": doc.transaction_currency,
+			"transaction_exchange_rate": doc.transaction_exchange_rate,
+			"debit_in_transaction_currency": flt(
+				d.debit_in_account_currency, d.precision("debit_in_account_currency")
+			)
+			if doc.transaction_currency == d.account_currency
+			else flt(d.debit, d.precision("debit")) / doc.transaction_exchange_rate,
+			"credit_in_transaction_currency": flt(
+				d.credit_in_account_currency, d.precision("credit_in_account_currency")
+			)
+			if doc.transaction_currency == d.account_currency
+			else flt(d.credit, d.precision("credit")) / doc.transaction_exchange_rate,
+			"against_voucher_type": d.reference_type,
+			"against_voucher": d.reference_name,
+			"remarks": remarks,
+			"voucher_detail_no": d.reference_detail_no,
+			"cost_center": d.cost_center,
+			"project": d.project,
+			"finance_book": doc.finance_book,
+			"advance_voucher_type": d.advance_voucher_type,
+			"advance_voucher_no": d.advance_voucher_no,
+		}
+
+		if d.reference_type in advance_doctypes:
+			row.update(
+				{
+					"against_voucher_type": doc.doctype,
+					"against_voucher": doc.name,
+					"advance_voucher_type": d.reference_type,
+					"advance_voucher_no": d.reference_name,
+				}
+			)
+
+		# set flag to skip party validation
+		account_type = frappe.get_cached_value("Account", d.account, "account_type")
+		if account_type in ["Receivable", "Payable"] and doc.party_not_required:
+			frappe.flags.party_not_required = True
+
+		return row

erpnext/accounts/doctype/journal_entry/services/reference_validator.py

@@ -0,0 +1,199 @@
+# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
+# License: GNU General Public License v3. See license.txt
+
+import frappe
+from frappe import _, scrub
+from frappe.utils import cstr, flt, fmt_money
+
+from erpnext.accounts.deferred_revenue import get_deferred_booking_accounts
+from erpnext.accounts.doctype.invoice_discounting.invoice_discounting import (
+	get_party_account_based_on_invoice_discounting,
+)
+from erpnext.accounts.utils import get_account_currency
+
+REFERENCE_PARTY_ACCOUNT_FIELDS = {
+	"Sales Invoice": ["Customer", "Debit To"],
+	"Purchase Invoice": ["Supplier", "Credit To"],
+	"Sales Order": ["Customer"],
+	"Purchase Order": ["Supplier"],
+}
+
+
+class JournalEntryReferenceValidator:
+	"""Validates Journal Entry account rows against their referenced documents.
+
+	For each row that links a Sales/Purchase Invoice or Order, this checks the
+	debit/credit direction, party and account match, and aggregates per-reference
+	totals (held on the document as ``reference_totals``/``reference_types``/
+	``reference_accounts``) which are then validated against the referenced
+	orders and invoices.
+	"""
+
+	def __init__(self, doc) -> None:
+		self.doc = doc
+
+	def validate(self) -> None:
+		"""Validate every reference-bearing row, then the referenced orders and invoices."""
+		self.doc.reference_totals = {}
+		self.doc.reference_types = {}
+		self.doc.reference_accounts = {}
+		for row in self.doc.get("accounts"):
+			self._normalize_reference_fields(row)
+			if not self._has_party_reference(row):
+				continue
+			self._validate_order_direction(row)
+			self._register_reference(row)
+			self._validate_reference_party_and_account(row)
+
+		self._validate_orders()
+		self._validate_invoices()
+
+	def _normalize_reference_fields(self, row) -> None:
+		if not row.reference_type:
+			row.reference_name = None
+		if not row.reference_name:
+			row.reference_type = None
+
+	def _has_party_reference(self, row) -> bool:
+		return bool(
+			row.reference_type and row.reference_name and row.reference_type in REFERENCE_PARTY_ACCOUNT_FIELDS
+		)
+
+	def _reference_amount_field(self, row) -> str:
+		if row.reference_type in ("Sales Order", "Sales Invoice"):
+			return "credit_in_account_currency"
+		return "debit_in_account_currency"
+
+	def _validate_order_direction(self, row) -> None:
+		"""An order can only be linked on the side that records an advance."""
+		if row.reference_type == "Sales Order" and flt(row.debit) > 0:
+			frappe.throw(
+				_("Row {0}: Debit entry can not be linked with a {1}").format(row.idx, row.reference_type)
+			)
+		if row.reference_type == "Purchase Order" and flt(row.credit) > 0:
+			frappe.throw(
+				_("Row {0}: Credit entry can not be linked with a {1}").format(row.idx, row.reference_type)
+			)
+
+	def _register_reference(self, row) -> None:
+		"""Aggregate the row's amount, type and account onto the per-reference lookups."""
+		if row.reference_name not in self.doc.reference_totals:
+			self.doc.reference_totals[row.reference_name] = 0.0
+		if self.doc.voucher_type not in ("Deferred Revenue", "Deferred Expense"):
+			self.doc.reference_totals[row.reference_name] += flt(row.get(self._reference_amount_field(row)))
+		self.doc.reference_types[row.reference_name] = row.reference_type
+		self.doc.reference_accounts[row.reference_name] = row.account
+
+	def _validate_reference_party_and_account(self, row) -> None:
+		"""Reject a missing reference, then check party/account against the linked document."""
+		party_fields = REFERENCE_PARTY_ACCOUNT_FIELDS[row.reference_type]
+		against_voucher = frappe.db.get_value(
+			row.reference_type, row.reference_name, [scrub(f) for f in party_fields]
+		)
+		if not against_voucher:
+			frappe.throw(_("Row {0}: Invalid reference {1}").format(row.idx, row.reference_name))
+
+		if row.reference_type in ("Sales Invoice", "Purchase Invoice"):
+			self._validate_invoice_party_and_account(row, against_voucher, party_fields)
+		elif row.reference_type in ("Sales Order", "Purchase Order"):
+			self._validate_order_party(row, against_voucher)
+
+	def _validate_invoice_party_and_account(self, row, against_voucher, party_fields) -> None:
+		party_account, against_party = self._resolve_invoice_party_account(row, against_voucher)
+		if self.doc.voucher_type == "Exchange Gain Or Loss":
+			return
+		if against_party != cstr(row.party) or party_account != row.account:
+			frappe.throw(
+				_("Row {0}: Party / Account does not match with {1} / {2} in {3} {4}").format(
+					row.idx, party_fields[0], party_fields[1], row.reference_type, row.reference_name
+				)
+			)
+
+	def _resolve_invoice_party_account(self, row, against_voucher) -> tuple:
+		"""Expected (party_account, party) for an invoice row, honouring deferred booking
+		and invoice-discounting accounts."""
+		if self.doc.voucher_type in ("Deferred Revenue", "Deferred Expense") and row.reference_detail_no:
+			debit_or_credit = "Debit" if row.debit else "Credit"
+			party_account = get_deferred_booking_accounts(
+				row.reference_type, row.reference_detail_no, debit_or_credit
+			)
+			return party_account, ""
+		if row.reference_type == "Sales Invoice":
+			party_account = (
+				get_party_account_based_on_invoice_discounting(row.reference_name) or against_voucher[1]
+			)
+		else:
+			party_account = against_voucher[1]
+		return party_account, against_voucher[0]
+
+	def _validate_order_party(self, row, against_voucher) -> None:
+		if against_voucher != row.party:
+			frappe.throw(
+				_("Row {0}: {1} {2} does not match with {3}").format(
+					row.idx, row.party_type, row.party, row.reference_type
+				)
+			)
+
+	def _validate_orders(self) -> None:
+		"""Validate totals, closed and docstatus for referenced orders."""
+		for reference_name, total in self.doc.reference_totals.items():
+			reference_type = self.doc.reference_types[reference_name]
+			account = self.doc.reference_accounts[reference_name]
+			if reference_type not in ("Sales Order", "Purchase Order"):
+				continue
+
+			order = frappe.get_doc(reference_type, reference_name)
+			self._validate_order_status(order, reference_type, reference_name)
+			self._validate_order_advance_total(order, account, total, reference_type, reference_name)
+
+	def _validate_order_status(self, order, reference_type, reference_name) -> None:
+		if order.docstatus != 1:
+			frappe.throw(_("{0} {1} is not submitted").format(reference_type, reference_name))
+		if flt(order.per_billed) >= 100:
+			frappe.throw(_("{0} {1} is fully billed").format(reference_type, reference_name))
+		if cstr(order.status) == "Closed":
+			frappe.throw(_("{0} {1} is closed").format(reference_type, reference_name))
+
+	def _validate_order_advance_total(self, order, account, total, reference_type, reference_name) -> None:
+		"""The advance paid against an order cannot exceed its grand total."""
+		account_currency = get_account_currency(account)
+		if account_currency == self.doc.company_currency:
+			voucher_total = order.base_grand_total
+			field = "base_grand_total"
+		else:
+			voucher_total = order.grand_total
+			field = "grand_total"
+
+		if flt(voucher_total) < (flt(order.advance_paid) + total):
+			formatted_voucher_total = fmt_money(
+				voucher_total, order.precision(field), currency=account_currency
+			)
+			frappe.throw(
+				_("Advance paid against {0} {1} cannot be greater than Grand Total {2}").format(
+					reference_type, reference_name, formatted_voucher_total
+				)
+			)
+
+	def _validate_invoices(self) -> None:
+		"""Validate totals and docstatus for referenced invoices."""
+		if self.doc.voucher_type in ("Debit Note", "Credit Note"):
+			return
+		for reference_name, total in self.doc.reference_totals.items():
+			reference_type = self.doc.reference_types[reference_name]
+			if reference_type not in ("Sales Invoice", "Purchase Invoice"):
+				continue
+			invoice = frappe.get_doc(reference_type, reference_name)
+			self._validate_invoice_outstanding(invoice, total, reference_type, reference_name)
+
+	def _validate_invoice_outstanding(self, invoice, total, reference_type, reference_name) -> None:
+		"""Payment booked against an invoice cannot exceed its outstanding amount."""
+		if invoice.docstatus != 1:
+			frappe.throw(_("{0} {1} is not submitted").format(reference_type, reference_name))
+
+		precision = invoice.precision("outstanding_amount")
+		if total and flt(invoice.outstanding_amount, precision) < flt(total, precision):
+			frappe.throw(
+				_("Payment against {0} {1} cannot be greater than Outstanding Amount {2}").format(
+					reference_type, reference_name, invoice.outstanding_amount
+				)
+			)

erpnext/accounts/doctype/journal_entry/test_journal_entry.py

@@ -43,18 +43,18 @@ class TestJournalEntry(ERPNextTestSuite):
 
 		if test_voucher.doctype == "Journal Entry":
 			self.assertTrue(
-				frappe.db.sql(
-					"""select name from `tabJournal Entry Account`
-				where account = %s and docstatus = 1 and parent = %s""",
-					("Debtors - _TC", test_voucher.name),
+				frappe.get_all(
+					"Journal Entry Account",
+					filters={"account": "Debtors - _TC", "docstatus": 1, "parent": test_voucher.name},
+					pluck="name",
 				)
 			)
 
 		self.assertFalse(
-			frappe.db.sql(
-				"""select name from `tabJournal Entry Account`
-			where reference_type = %s and reference_name = %s""",
-				(test_voucher.doctype, test_voucher.name),
+			frappe.get_all(
+				"Journal Entry Account",
+				filters={"reference_type": test_voucher.doctype, "reference_name": test_voucher.name},
+				pluck="name",
 			)
 		)
 
@@ -69,10 +69,14 @@ class TestJournalEntry(ERPNextTestSuite):
 		submitted_voucher = frappe.get_doc(test_voucher.doctype, test_voucher.name)
 
 		self.assertTrue(
-			frappe.db.sql(
-				f"""select name from `tabJournal Entry Account`
-			where reference_type = %s and reference_name = %s and {dr_or_cr}=400""",
-				(submitted_voucher.doctype, submitted_voucher.name),
+			frappe.get_all(
+				"Journal Entry Account",
+				filters={
+					"reference_type": submitted_voucher.doctype,
+					"reference_name": submitted_voucher.name,
+					dr_or_cr: 400,
+				},
+				pluck="name",
 			)
 		)
 
@@ -82,24 +86,20 @@ class TestJournalEntry(ERPNextTestSuite):
 
 	def advance_paid_testcase(self, base_jv, test_voucher, dr_or_cr):
 		# Test advance paid field
-		advance_paid = frappe.db.sql(
-			"""select advance_paid from `tab{}`
-					where name={}""".format(test_voucher.doctype, "%s"),
-			(test_voucher.name),
-		)
+		advance_paid = frappe.db.get_value(test_voucher.doctype, test_voucher.name, "advance_paid")
 		payment_against_order = base_jv.get("accounts")[0].get(dr_or_cr)
 
-		self.assertTrue(flt(advance_paid[0][0]) == flt(payment_against_order))
+		self.assertEqual(flt(advance_paid), flt(payment_against_order))
 
 	def cancel_against_voucher_testcase(self, test_voucher):
 		if test_voucher.doctype == "Journal Entry":
 			# if test_voucher is a Journal Entry, test cancellation of test_voucher
 			test_voucher.cancel()
 			self.assertFalse(
-				frappe.db.sql(
-					"""select name from `tabJournal Entry Account`
-				where reference_type='Journal Entry' and reference_name=%s""",
-					test_voucher.name,
+				frappe.get_all(
+					"Journal Entry Account",
+					filters={"reference_type": "Journal Entry", "reference_name": test_voucher.name},
+					pluck="name",
 				)
 			)
 
@@ -169,8 +169,11 @@ class TestJournalEntry(ERPNextTestSuite):
 			"debit_in_account_currency",
 			"credit",
 			"credit_in_account_currency",
+			"debit_in_transaction_currency",
+			"credit_in_transaction_currency",
 		]
 
+		# Transaction currency is USD (first foreign row); the INR row is converted at 1/50.
 		self.expected_gle = [
 			{
 				"account": "_Test Bank - _TC",
@@ -179,6 +182,8 @@ class TestJournalEntry(ERPNextTestSuite):
 				"debit_in_account_currency": 0,
 				"credit": 5000,
 				"credit_in_account_currency": 5000,
+				"debit_in_transaction_currency": 0,
+				"credit_in_transaction_currency": 100,
 			},
 			{
 				"account": "_Test Bank USD - _TC",
@@ -187,6 +192,8 @@ class TestJournalEntry(ERPNextTestSuite):
 				"debit_in_account_currency": 100,
 				"credit": 0,
 				"credit_in_account_currency": 0,
+				"debit_in_transaction_currency": 100,
+				"credit_in_transaction_currency": 0,
 			},
 		]
 
@@ -195,16 +202,62 @@ class TestJournalEntry(ERPNextTestSuite):
 		# cancel
 		jv.cancel()
 
-		gle = frappe.db.sql(
-			"""select name from `tabGL Entry`
-			where voucher_type='Sales Invoice' and voucher_no=%s""",
-			jv.name,
+		gle = frappe.get_all(
+			"GL Entry",
+			filters={"voucher_type": "Sales Invoice", "voucher_no": jv.name},
+			pluck="name",
 		)
 
 		self.assertFalse(gle)
 
+	def test_multi_currency_transaction_currency_on_foreign_debit(self):
+		"""Pin debit_in_transaction_currency for a foreign-currency debit row.
+
+		Transaction currency is USD (the first foreign row); the INR debit row must be
+		converted at 1/exchange_rate, so 5000 INR -> 100 USD. Guards the / vs * direction.
+		"""
+		jv = frappe.new_doc("Journal Entry")
+		jv.company = "_Test Company"
+		jv.posting_date = nowdate()
+		jv.multi_currency = 1
+		jv.append(
+			"accounts",
+			{
+				"account": "_Test Bank USD - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"credit_in_account_currency": 100,
+				"exchange_rate": 50,
+			},
+		)
+		jv.append(
+			"accounts",
+			{
+				"account": "_Test Bank - _TC",
+				"cost_center": "_Test Cost Center - _TC",
+				"debit_in_account_currency": 5000,
+				"exchange_rate": 1,
+			},
+		)
+		jv.submit()
+
+		self.voucher_no = jv.name
+		self.fields = ["account", "debit_in_transaction_currency", "credit_in_transaction_currency"]
+		self.expected_gle = [
+			{
+				"account": "_Test Bank - _TC",
+				"debit_in_transaction_currency": 100,
+				"credit_in_transaction_currency": 0,
+			},
+			{
+				"account": "_Test Bank USD - _TC",
+				"debit_in_transaction_currency": 0,
+				"credit_in_transaction_currency": 100,
+			},
+		]
+		self.check_gl_entries()
+
 	def test_reverse_journal_entry(self):
-		from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
+		from erpnext.accounts.doctype.journal_entry.mapper import make_reverse_journal_entry
 
 		jv = make_journal_entry("_Test Bank USD - _TC", "Sales - _TC", 100, exchange_rate=50, save=False)
 
@@ -473,9 +526,16 @@ class TestJournalEntry(ERPNextTestSuite):
 
 		gl_entries = query.run(as_dict=True)
 
-		for i in range(len(self.expected_gle)):
+		# MariaDB and Postgres collate `account` differently, so the DB ordering isn't portable;
+		# sort both sides identically before the positional comparison.
+		def _key(row):
+			return tuple(str(row[f]) for f in self.fields)
+
+		gl_entries = sorted(gl_entries, key=_key)
+		expected_gle = sorted(self.expected_gle, key=_key)
+		for i in range(len(expected_gle)):
 			for field in self.fields:
-				self.assertEqual(self.expected_gle[i][field], gl_entries[i][field])
+				self.assertEqual(expected_gle[i][field], gl_entries[i][field])
 
 	def test_negative_debit_and_credit_with_same_account_head(self):
 		from erpnext.accounts.general_ledger import process_gl_map
@@ -609,6 +669,197 @@ class TestJournalEntry(ERPNextTestSuite):
 		jv.save()
 		self.assertRaises(frappe.ValidationError, jv.submit)
 
+	def test_validate_reference_doc_debit_against_sales_order_throws(self):
+		"""Characterize: a debit entry linked to a Sales Order is rejected."""
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		sales_order = make_sales_order()
+		jv = make_journal_entry("Debtors - _TC", "_Test Cash - _TC", 100, save=False)
+		jv.accounts[0].party_type = "Customer"
+		jv.accounts[0].party = "_Test Customer"
+		jv.accounts[0].reference_type = "Sales Order"
+		jv.accounts[0].reference_name = sales_order.name
+		self.assertRaisesRegex(frappe.ValidationError, "Debit entry can not be linked", jv.insert)
+
+	def test_validate_reference_doc_credit_against_purchase_order_throws(self):
+		"""Characterize: a credit entry linked to a Purchase Order is rejected."""
+		from erpnext.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
+
+		purchase_order = create_purchase_order()
+		jv = make_journal_entry("_Test Cash - _TC", "Creditors - _TC", 100, save=False)
+		jv.accounts[1].party_type = "Supplier"
+		jv.accounts[1].party = "_Test Supplier"
+		jv.accounts[1].reference_type = "Purchase Order"
+		jv.accounts[1].reference_name = purchase_order.name
+		self.assertRaisesRegex(frappe.ValidationError, "Credit entry can not be linked", jv.insert)
+
+	def test_validate_reference_doc_nonexistent_reference_rejected(self):
+		"""Characterize: a JE referencing a non-existent invoice is rejected by link validation.
+
+		Note: the controller's own "Invalid reference" branch is unreachable in normal flow
+		because Frappe link validation rejects the missing reference before validate_reference_doc.
+		"""
+		jv = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 100, save=False)
+		jv.accounts[1].party_type = "Customer"
+		jv.accounts[1].party = "_Test Customer"
+		jv.accounts[1].reference_type = "Sales Invoice"
+		jv.accounts[1].reference_name = "NON-EXISTENT-SI"
+		self.assertRaises(frappe.LinkValidationError, jv.insert)
+
+	def test_validate_reference_doc_invoice_party_mismatch_throws(self):
+		"""Characterize: an invoice reference whose party differs from the row party is rejected."""
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		invoice = create_sales_invoice(rate=500)
+		other_customer = make_customer("_Test JE Mismatch Customer")
+		jv = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 100, save=False)
+		jv.accounts[1].party_type = "Customer"
+		jv.accounts[1].party = other_customer
+		jv.accounts[1].reference_type = "Sales Invoice"
+		jv.accounts[1].reference_name = invoice.name
+		self.assertRaisesRegex(frappe.ValidationError, "Party / Account does not match", jv.insert)
+
+	def test_validate_reference_doc_order_party_mismatch_throws(self):
+		"""Characterize: a Sales Order reference whose party differs from the row party is rejected."""
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		sales_order = make_sales_order()
+		other_customer = make_customer("_Test JE Mismatch Customer")
+		jv = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 100, save=False)
+		jv.accounts[1].party_type = "Customer"
+		jv.accounts[1].party = other_customer
+		jv.accounts[1].is_advance = "Yes"
+		jv.accounts[1].reference_type = "Sales Order"
+		jv.accounts[1].reference_name = sales_order.name
+		self.assertRaisesRegex(frappe.ValidationError, "does not match", jv.insert)
+
+	def test_validate_reference_doc_populates_reference_side_effects(self):
+		"""Characterize: a valid invoice reference populates reference_totals/types/accounts."""
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		invoice = create_sales_invoice(rate=500)
+		jv = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 100, save=False)
+		jv.accounts[1].party_type = "Customer"
+		jv.accounts[1].party = "_Test Customer"
+		jv.accounts[1].reference_type = "Sales Invoice"
+		jv.accounts[1].reference_name = invoice.name
+		jv.insert()
+		self.assertEqual(jv.reference_totals[invoice.name], 100.0)
+		self.assertEqual(jv.reference_types[invoice.name], "Sales Invoice")
+		self.assertEqual(jv.reference_accounts[invoice.name], "Debtors - _TC")
+
+	def test_get_balance_places_difference_on_blank_row(self):
+		"""Characterize: get_balance puts the unbalanced difference on an amountless row."""
+		jv = frappe.new_doc("Journal Entry")
+		jv.company = "_Test Company"
+		jv.posting_date = nowdate()
+		jv.append(
+			"accounts",
+			{
+				"account": "_Test Cash - _TC",
+				"debit_in_account_currency": 100,
+				"debit": 100,
+				"exchange_rate": 1,
+			},
+		)
+		jv.append("accounts", {"account": "_Test Bank - _TC", "exchange_rate": 1})  # amountless row
+		jv.set_total_debit_credit()
+		self.assertEqual(jv.difference, 100)
+
+		jv.get_balance()
+		blank_row = jv.accounts[1]
+		self.assertEqual(blank_row.credit_in_account_currency, 100)
+		self.assertEqual(jv.total_debit, jv.total_credit)
+
+	def test_get_balance_recomputes_difference_ignoring_client_value(self):
+		"""get_balance computes its own difference instead of trusting a stale client-sent value."""
+		jv = frappe.new_doc("Journal Entry")
+		jv.company = "_Test Company"
+		jv.posting_date = nowdate()
+		jv.append(
+			"accounts",
+			{
+				"account": "_Test Cash - _TC",
+				"debit_in_account_currency": 100,
+				"debit": 100,
+				"exchange_rate": 1,
+			},
+		)
+		jv.append("accounts", {"account": "_Test Bank - _TC", "exchange_rate": 1})
+		# a stale/incorrect value as the client might send; get_balance must not rely on it
+		jv.difference = 0
+
+		jv.get_balance()
+		self.assertEqual(jv.accounts[1].credit_in_account_currency, 100)
+		self.assertEqual(jv.total_debit, jv.total_credit)
+		self.assertEqual(jv.difference, 0)
+
+	def test_get_outstanding_invoices_builds_write_off_rows(self):
+		"""Characterize: get_outstanding_invoices adds a party row for each outstanding invoice."""
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		invoice = create_sales_invoice(rate=700)
+		jv = frappe.new_doc("Journal Entry")
+		jv.company = "_Test Company"
+		jv.posting_date = nowdate()
+		jv.voucher_type = "Write Off Entry"
+		jv.write_off_based_on = "Accounts Receivable"
+		jv.write_off_amount = 1000
+		jv.get_outstanding_invoices()
+
+		invoice_rows = [row for row in jv.accounts if row.reference_name == invoice.name]
+		self.assertTrue(invoice_rows)
+		self.assertEqual(invoice_rows[0].party_type, "Customer")
+		self.assertEqual(invoice_rows[0].reference_type, "Sales Invoice")
+		self.assertEqual(flt(invoice_rows[0].credit_in_account_currency), 700)
+
+	def test_unlink_advance_entry_reference_on_cancel(self):
+		"""Characterize: cancelling an advance JE against an invoice clears the row's reference."""
+		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+
+		invoice = create_sales_invoice(rate=700)
+		jv = make_journal_entry("_Test Cash - _TC", "Debtors - _TC", 100, save=False)
+		advance_row = jv.accounts[1]
+		advance_row.party_type = "Customer"
+		advance_row.party = "_Test Customer"
+		advance_row.is_advance = "Yes"
+		advance_row.reference_type = "Sales Invoice"
+		advance_row.reference_name = invoice.name
+		jv.submit()
+
+		jv.cancel()
+		jv.reload()
+		self.assertFalse(jv.accounts[1].reference_type)
+		self.assertFalse(jv.accounts[1].reference_name)
+
+	def test_get_payment_entry_against_order_builds_advance_je(self):
+		"""Characterize the mapper: an advance Bank Entry JE is built against an unbilled order."""
+		from erpnext.accounts.doctype.journal_entry.mapper import get_payment_entry_against_order
+		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+
+		sales_order = make_sales_order()
+		je = get_payment_entry_against_order("Sales Order", sales_order.name, journal_entry=True)
+
+		self.assertEqual(je.voucher_type, "Bank Entry")
+		party_rows = [row for row in je.accounts if row.party_type == "Customer"]
+		self.assertTrue(party_rows)
+		self.assertEqual(party_rows[0].reference_type, "Sales Order")
+		self.assertEqual(party_rows[0].reference_name, sales_order.name)
+		self.assertEqual(party_rows[0].is_advance, "Yes")
+
+	def test_make_inter_company_journal_entry_builds_linked_draft(self):
+		"""Characterize the mapper: the counterpart JE carries the company and back-reference."""
+		from erpnext.accounts.doctype.journal_entry.mapper import make_inter_company_journal_entry
+
+		source = make_journal_entry("_Test Cash - _TC", "_Test Bank - _TC", 100, submit=True)
+		result = make_inter_company_journal_entry(
+			source.name, "Inter Company Journal Entry", "_Test Company 1"
+		)
+
+		self.assertEqual(result.get("voucher_type"), "Inter Company Journal Entry")
+		self.assertEqual(result.get("company"), "_Test Company 1")
+		self.assertEqual(result.get("inter_company_journal_entry_reference"), source.name)
+
 
 def make_journal_entry(
 	account1,