test(stock): validate completed status for mixed transfer methods

(cherry picked from commit 1dbdf85ddc)

.github/helper/hydrate.sh

@@ -1,72 +0,0 @@
-#!/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

@@ -7,106 +7,21 @@ cd ~ || exit
 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
+sudo apt 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=$!
+# apt remove/install must run sequentially but can overlap with pip and git.
+sudo apt remove mysql-server mysql-client
+sudo apt install libcups2-dev redis-server mariadb-client libmariadb-dev &
+apt_pid=$!
 
-    pip install frappe-bench &
-    pip_pid=$!
-else
-    apt_pid=
-    pip_pid=
-fi
+pip install frappe-bench &
+pip_pid=$!
 
 mkdir frappe
 (
@@ -117,247 +32,76 @@ mkdir frappe
 ) &
 clone_pid=$!
 
-if [ -n "$apt_pid" ]; then wait $apt_pid; fi
-if [ -n "$pip_pid" ]; then wait $pip_pid; fi
+wait $apt_pid
+wait $pip_pid
 wait $clone_pid
 
 pushd frappe
 git checkout FETCH_HEAD
 popd
-frappe_sha=$(git -C frappe rev-parse HEAD)
-
-get_bench_cache_archive() {
-    if [ -z "$bench_cache_dir" ]; then
-        return
-    fi
-
-    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
+bench init --skip-assets --frappe-path ~/frappe --python "$(which python)" frappe-bench
 
-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
+mkdir ~/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
-    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 "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'"
 
-    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'"
-
-    # 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 \
+    # Belt-and-suspenders: also set performance variables at runtime in case
+    # MARIADB_EXTRA_FLAGS was not honoured by the container image.
+    mariadb --host 127.0.0.1 --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 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 "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"
+    mariadb --host 127.0.0.1 --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() {
+    # Re-use the .deb if the wkhtmltopdf cache step already restored it.
+    if [ ! -f /tmp/wkhtmltox.deb ]; then
+        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
+    fi
+    sudo apt install /tmp/wkhtmltox.deb
+}
+install_whktml &
+wkpid=$!
+
+
 cd ~/frappe-bench || exit
 
-run_ci_step "Get payments app" bench get-app payments --branch develop
+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
 
-# 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[@]}"
+bench get-app payments --branch develop
+bench get-app erpnext "${GITHUB_WORKSPACE}"
 
-if [ "$TYPE" == "server" ]; then run_ci_step "Setup dev requirements" bench setup requirements --dev; fi
+if [ "$TYPE" == "server" ]; then bench setup requirements --dev; fi
 
-bench start >> ~/frappe-bench/bench_start.log 2>&1 &
+wait $wkpid
 
-# 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
+bench start &>> ~/frappe-bench/bench_start.log &
+CI=Yes bench build --app frappe &
+bench --site test_site reinstall --yes

.github/helper/start-db.sh

@@ -1,79 +0,0 @@
-#!/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/linters.yml

@@ -21,7 +21,7 @@ jobs:
           cache: pip
 
       - name: Install and Run Pre-commit
-        uses: pre-commit/action@v3.0.1
+        uses: pre-commit/action@v3.0.0
 
   semgrep:
     name: semgrep

.github/workflows/patch.yml

@@ -134,7 +134,6 @@ 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

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

@@ -22,4 +22,4 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: alyf-de/po-review-action@v1.1.0
+      - uses: alyf-de/po-review-action@v1.0.0

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

@@ -31,49 +31,51 @@ 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:
-  # 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
+  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'
+          # Disable durability guarantees that are unnecessary in a throwaway CI container.
+          # innodb_flush_log_at_trx_commit=0 avoids an fsync on every commit (biggest win).
+          # sync_binlog=0 skips binary-log syncs; innodb_doublewrite=0 skips the doublewrite buffer.
+          MARIADB_EXTRA_FLAGS: --innodb-flush-log-at-trx-commit=0 --sync-binlog=0 --innodb-doublewrite=0
+        ports:
+          - 3306:3306
+        options: --health-cmd="mariadb-admin ping" --health-interval=5s --health-timeout=2s --health-retries=3
+
     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}"
@@ -82,17 +84,53 @@ 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
 
-      # 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
+      - 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
         env:
-          SKIP_SYSTEM_SETUP: "1"
-          CI_DB_DATADIR: /home/ci/db-data
+          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-
+
+      - name: Cache wkhtmltopdf
+        uses: actions/cache@v4
+        with:
+          path: /tmp/wkhtmltox.deb
+          key: wkhtmltox-0.12.6.1-2-jammy-amd64
 
       - name: Install
         run: bash ${GITHUB_WORKSPACE}/.github/helper/install.sh
@@ -101,88 +139,9 @@ 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"
-
-      - name: Warm up test data
-        run: |
-          su -m "${ERPNEXT_CI_USER:-frappe}" -s /bin/bash <<'EOF'
-          cd ~/frappe-bench/
-          bench --site test_site run-tests --lightmode --module erpnext.tests.bootstrap_test_data
-          EOF
-
-      # 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: |
-          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
@@ -190,10 +149,10 @@ jobs:
             --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
@@ -203,11 +162,11 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: coverage-${{ matrix.container }}
-          path: /home/ci/frappe-bench/sites/coverage.xml
+          path: /home/runner/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:

.pre-commit-config.yaml

@@ -48,6 +48,7 @@ repos:
                 cypress/.*|
                 .*node_modules.*|
                 .*boilerplate.*|
+                erpnext/public/js/controllers/.*|
                 erpnext/templates/pages/order.js|
                 erpnext/templates/includes/.*
             )$

banking/package.json

@@ -14,52 +14,52 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
-    "@tailwindcss/vite": "^4.3.2",
+    "@tailwindcss/vite": "^4.3.0",
     "@tanstack/react-table": "^8.21.3",
     "@tanstack/react-virtual": "^3.13.24",
-    "@vitejs/plugin-react": "^6.0.3",
+    "@vitejs/plugin-react": "^6.0.1",
     "chrono-node": "^2.9.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "dayjs": "^1.11.20",
-    "frappe-react-sdk": "^1.17.0",
+    "frappe-react-sdk": "^1.15.0",
     "fuse.js": "^7.3.0",
-    "jotai": "^2.20.1",
-    "jotai-family": "^1.0.2",
+    "jotai": "^2.20.0",
+    "jotai-family": "^1.0.1",
     "lodash.isplainobject": "^4.0.6",
     "lucide-react": "^1.14.0",
-    "radix-ui": "^1.6.1",
-    "react": "^19.2.7",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.6",
     "react-currency-input-field": "^4.0.5",
     "react-day-picker": "9.14.0",
-    "react-dom": "^19.2.7",
+    "react-dom": "^19.2.6",
     "react-dropzone": "^15.0.0",
     "react-hook-form": "^7.75.0",
     "react-hotkeys-hook": "^5.3.2",
     "react-markdown": "^10.1.0",
-    "react-router": "^8.1.0",
+    "react-router": "^7.15.0",
+    "react-router-dom": "^7.15.0",
     "rehype-raw": "^7.0.0",
     "remark-gfm": "^4.0.1",
-    "safe-expr-eval": "^1.0.4",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.3.0",
     "tw-animate-css": "^1.4.0",
     "usehooks-ts": "^3.1.1",
-    "vite": "^8.0.16"
+    "vite": "^8.0.11"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.4",
+    "@eslint/js": "^9.39.1",
     "@types/node": "^25.3.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-react-refresh": "^0.5.3",
+    "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.62.1"
+    "typescript-eslint": "^8.48.0"
   }
 }

banking/src/App.tsx

@@ -1,5 +1,5 @@
 import { lazy, useEffect } from 'react'
-import { BrowserRouter, Navigate, Route, Routes } from 'react-router'
+import { BrowserRouter, Navigate, Route, Routes } from 'react-router-dom'
 import { FrappeProvider } from 'frappe-react-sdk'
 import { Toaster } from '@/components/ui/sonner'
 import BankReconciliation from '@/pages/BankReconciliation'

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 && <div className="py-2"><ErrorBanner error={error} /></div>}
+            {error && <ErrorBanner error={error} />}
             <div className="py-4">
                 <CurrencyFormField
                     name="balance"

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

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, SelectedBank, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo, useState } from "react"
 import { useFrappeGetCall, useFrappePostCall, useSWRConfig } from "frappe-react-sdk"
@@ -25,7 +26,6 @@ import { Form } from "@/components/ui/form"
 import { useForm } from "react-hook-form"
 import { DateField } from "@/components/ui/form-elements"
 import { Empty, EmptyMedia, EmptyHeader, EmptyTitle, EmptyDescription } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankClearanceSummary = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -203,14 +203,14 @@ const BankClearanceSummaryView = () => {
         [accountCurrency, bankAccount, companyID, mutate, onCopy],
     )
 
-    const content = _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all accounting entries posted against the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                }} />
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

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

@@ -18,7 +18,6 @@ import { useMultiFileUploadProgress } from "@/hooks/useMultiFileUploadProgress"
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"
 import { Checkbox } from "@/components/ui/checkbox"
 import { ArrowDownRight, ArrowUpRight, Plus, Trash2 } from "lucide-react"
-import { evaluateAmountFormula } from "@/lib/amountFormula"
 import { flt, formatCurrency } from "@/lib/numbers"
 import { cn } from "@/lib/utils"
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
@@ -216,13 +215,38 @@ const BankEntryForm = ({ selectedTransaction }: { selectedTransaction: Unreconci
                         })
                     } else {
 
-                        const transactionAmount = selectedTransaction.unallocated_amount ?? 0
+                        /**
+                         * The debit and credit amounts can also be expressions - like "transaction_amount * 0.5"
+                         * So we need to compute the value of the expression
+                         * We can use the eval function to do this. But we need to expose certain variables to the expression.
+                         * One of them is transaction_amount which is the unallocated amount of the selected transaction
+                         * @param expression - The expression to compute
+                         * @returns The computed value
+                         */
+                        const computeExpression = (expression: string) => {
+
+                            const script = `
+                                const transaction_amount = ${selectedTransaction.unallocated_amount ?? 0}
+                                ${expression};
+                            `
+
+                            let value = 0;
+
+                            try {
+                                value = window.eval(script);
+                            } catch (error: unknown) {
+                                console.error(error);
+                                value = 0;
+                            }
+
+                            return value;
+                        }
                         if (!acc?.debit && !acc?.credit) {
                             hasTotallyEmptyRowEarlier = true;
                         }
 
-                        const computedDebit = acc?.debit ? flt(evaluateAmountFormula(acc.debit, transactionAmount), 2) : 0
-                        const computedCredit = acc?.credit ? flt(evaluateAmountFormula(acc.credit, transactionAmount), 2) : 0
+                        const computedDebit = acc?.debit ? flt(computeExpression(acc.debit), 2) : 0
+                        const computedCredit = acc?.credit ? flt(computeExpression(acc.credit), 2) : 0
 
                         totalDebits = flt(totalDebits + computedDebit, 2)
                         totalCredits = flt(totalCredits + computedCredit, 2)

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

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import { useCallback, useMemo } from "react"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useFrappeGetCall } from "frappe-react-sdk"
@@ -18,7 +19,6 @@ import _ from "@/lib/translate"
 import { toast } from "sonner"
 import { useCopyToClipboard } from "usehooks-ts"
 import { Empty, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankReconciliationStatement = () => {
     const bankAccount = useAtomValue(selectedBankAccountAtom)
@@ -189,14 +189,14 @@ const BankReconciliationStatementView = () => {
         return data.message.result.filter((row: BankClearanceSummaryEntry) => Boolean(row.payment_entry))
     }, [data])
 
-    const content = _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all entries posted against the bank account {0} which have not been cleared till {1}.", [`<strong>${bankAccount?.account}</strong>`, `<strong>${formatDate(dates.toDate)}</strong>`])
+                }} />
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

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

@@ -1,6 +1,7 @@
 import { useAtomValue, useSetAtom } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, bankRecUnreconcileModalAtom, selectedBankAccountAtom } from "./bankRecAtoms"
+import { Paragraph } from "@/components/ui/typography"
 import { formatDate } from "@/lib/date"
 import { ListView, type ListViewColumnMeta } from "@/components/ui/list-view"
 import { formatCurrency, getCurrencyFormatInfo } from "@/lib/numbers"
@@ -22,7 +23,6 @@ import { useCallback, useMemo, useState } from "react"
 import { Link } from "react-router"
 import { Empty, EmptyTitle, EmptyHeader, EmptyMedia, EmptyDescription, EmptyContent } from "@/components/ui/empty"
 import { InputGroup, InputGroupAddon } from "@/components/ui/input-group"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const BankTransactions = () => {
     const selectedBank = useAtomValue(selectedBankAccountAtom)
@@ -243,14 +243,14 @@ const BankTransactionListView = () => {
 
     }, [data, search, amountFilter, typeFilter, status])
 
-    const content = _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-2 py-2">
 
         <div className="flex gap-2 justify-between items-center">
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
-            </span>
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("Below is a list of all bank transactions imported in the system for the bank account {0} between {1} and {2}.", [`<strong>${bankAccount?.account_name}</strong>`, `<strong>${formattedFromDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                }} />
+            </Paragraph>
 
             <Button size='md' variant='subtle' asChild>
                 <Link to="/statement-importer">

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

@@ -19,22 +19,13 @@ import {
 import { cn } from "@/lib/utils"
 import _ from "@/lib/translate"
 import { selectedBankAccountAtom } from "./bankRecAtoms"
-import { useFrappeGetDocList } from "frappe-react-sdk"
-import ErrorBanner from "@/components/ui/error-banner"
 
 const CompanySelector = ({ onChange }: { onChange?: (company: string) => void }) => {
     const [open, setOpen] = useState(false)
     const [searchQuery, setSearchQuery] = useState("")
 
-    const { data: companies, error } = useFrappeGetDocList("Company", {
-        limit: 0,
-        fields: ["name"],
-    }, 'company_list', {
-        revalidateOnFocus: false,
-        revalidateOnReconnect: false,
-    })
-
-    const options = companies?.map((company: { name: string }) => company.name) || []
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const options = window.frappe?.boot?.docs?.filter((doc: Record<string, any>) => doc.doctype === ":Company").map((company: Record<string, any>) => company.name) || []
 
     const setSelectedCompany = useSetAtom(selectedCompanyAtom)
     const setSelectedBankAccount = useSetAtom(selectedBankAccountAtom)
@@ -51,10 +42,6 @@ const CompanySelector = ({ onChange }: { onChange?: (company: string) => void })
         }
     }
 
-    if (error) {
-        return <ErrorBanner error={error} />
-    }
-
     return (<Popover open={open} onOpenChange={setOpen}>
         <PopoverTrigger asChild>
             <Button

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

@@ -2,6 +2,7 @@ import { useAtomValue } from "jotai"
 import { MissingFiltersBanner } from "./MissingFiltersBanner"
 import { bankRecDateAtom, selectedBankAccountAtom } from "./bankRecAtoms"
 import { useCurrentCompany } from "@/hooks/useCurrentCompany"
+import { Paragraph } from "@/components/ui/typography"
 import type { ColumnDef } from "@tanstack/react-table"
 import { useCallback, useMemo } from "react"
 import { useFrappeGetCall, useFrappePostCall } from "frappe-react-sdk"
@@ -17,7 +18,6 @@ import { PartyPopper } from "lucide-react"
 import ErrorBanner from "@/components/ui/error-banner"
 import _ from "@/lib/translate"
 import { Empty, EmptyTitle, EmptyDescription, EmptyMedia, EmptyHeader } from "@/components/ui/empty"
-import MarkdownRenderer from "@/components/ui/markdown"
 
 const IncorrectlyClearedEntries = () => {
     const companyID = useCurrentCompany()
@@ -177,22 +177,22 @@ const IncorrectlyClearedEntriesView = () => {
         [accountCurrency, onClearClick],
     )
 
-    const content = _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
-
-    const entriesContent = _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
-
     return <div className="space-y-4 py-2">
 
         <div>
-            <span className="text-p-sm">
-                <MarkdownRenderer content={content} />
+            <Paragraph className="text-sm">
+                <span dangerouslySetInnerHTML={{
+                    __html: _("This report shows all entries in the system where the <strong>clearance date is before the posting date</strong> which is incorrect.")
+                }} />
                 <br />
                 {data && data.message.result.length > 0 && <span>
-                    <MarkdownRenderer content={entriesContent} />
+                    <span dangerouslySetInnerHTML={{
+                        __html: _("Entries below have a posting date after {0} but the clearance date is before {1}.", [`<strong>${formattedToDate}</strong>`, `<strong>${formattedToDate}</strong>`])
+                    }} />
                     <br />
                     {_("You can reset the clearing dates of these entries here.")}
                 </span>}
-            </span>
+            </Paragraph>
         </div>
 
         {error && <ErrorBanner error={error} />}

banking/src/components/features/BankReconciliation/Rules/RuleForm.tsx

@@ -11,7 +11,6 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
 import { H4, Paragraph } from "@/components/ui/typography"
 import { today } from "@/lib/date"
-import { evaluateAmountFormula } from "@/lib/amountFormula"
 import _ from "@/lib/translate"
 import { cn } from "@/lib/utils"
 import { BankTransactionRule } from "@/types/Accounts/BankTransactionRule"
@@ -446,10 +445,11 @@ const AmountFormulaRenderer = ({ value }: { value?: string }) => {
     // If it's a string and cannot be a number, then show it as a formula
 
     if (isNaN(Number(value))) {
+
         let calculatedValue = "";
 
         try {
-            calculatedValue = String(evaluateAmountFormula(value ?? "", 200));
+            calculatedValue = window.eval(`const transaction_amount = 200; ${value}`);
         } catch (error: unknown) {
             console.error(error);
             calculatedValue = "Error";

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

@@ -2,7 +2,9 @@ import CSVRawDataPreview from './CSVRawDataPreview'
 import StatementDetails from './StatementDetails'
 import { GetStatementDetailsResponse } from '../import_utils'
 
-const CSVImport = ({ data, mutate }: { data: { message: GetStatementDetailsResponse }, mutate: () => void }) => {
+const CSVImport = ({ data }: { data: { message: GetStatementDetailsResponse } }) => {
+
+
 
     return (
         <div className="w-full flex">
@@ -10,7 +12,7 @@ const CSVImport = ({ data, mutate }: { data: { message: GetStatementDetailsRespo
                 <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} mutate={mutate} />
+                <CSVRawDataPreview data={data.message} />
             </div>
         </div>
     )

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

@@ -1,104 +1,151 @@
-import { useEffect, useRef, useState } from "react"
-import { toast } from "sonner"
+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 _ from "@/lib/translate"
-import RawTableGrid from "../RawTableGrid"
-import {
-    applyColumnMappingChange,
-    ColumnMapsTo,
-    GetStatementDetailsResponse,
-    useSetHeaderIndex,
-    useUpdateColumnMapping,
-} from "../import_utils"
+import { GetStatementDetailsResponse } from "../import_utils"
+import { useMemo } from "react"
 import { BankStatementImportLogColumnMap } from "@/types/Accounts/BankStatementImportLogColumnMap"
 
-type Mapping = Pick<BankStatementImportLogColumnMap, "index" | "maps_to" | "header_text" | "variable">
 
-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 CSVRawDataPreview = ({ data }: { data: GetStatementDetailsResponse }) => {
 
-const headerToState = (index?: number) => (index != null && index >= 0 ? index : null)
+    const column_mapping: Record<StandardColumnTypes, number> = useMemo(() => {
 
-const CSVRawDataPreview = ({
-    data,
-    mutate,
-}: {
-    data: GetStatementDetailsResponse
-    mutate: () => void
-}) => {
-    const isCompleted = data.doc.status === "Completed"
+        const col_map: Record<string, number> = {}
 
-    const [mapping, setMapping] = useState<Mapping[]>(() => toMapping(data.doc.column_mapping))
-    const [headerIndex, setHeaderIndex] = useState<number | null>(() =>
-        headerToState(data.doc.detected_header_index),
-    )
+        data.doc.column_mapping?.forEach(col => {
+            if (col.maps_to && col.maps_to !== "Do not import") {
+                col_map[col.maps_to] = col.index;
+            }
+        })
 
-    const { call: updateMapping, loading: savingMapping } = useUpdateColumnMapping()
-    const { call: setHeader, loading: savingHeader } = useSetHeaderIndex()
+        return col_map
 
-    const mappingRef = useRef(mapping)
-    const saveTimer = useRef<ReturnType<typeof setTimeout>>(undefined)
+    }, [data])
 
-    useEffect(() => () => clearTimeout(saveTimer.current), [])
+    const validColumns = Object.values(column_mapping)
 
-    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.")))
-    }
+    // 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]))
 
+    // Loop over the contents of the CSV file and show a preview - highlight the header row and the transaction rows
     return (
-        <RawTableGrid
-            rows={data.raw_data}
-            columnMapping={columnMappingRecord}
-            headerIndex={headerIndex}
-            editable={!isCompleted}
-            disabled={isCompleted || savingMapping || savingHeader}
-            onChangeMapping={onChangeMapping}
-            onSetHeader={onSetHeader}
-        />
+        <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 >
     )
 }
 
-export default CSVRawDataPreview
+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

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

@@ -14,7 +14,7 @@ import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip
 import { useFrappeEventListener, useFrappePostCall } from 'frappe-react-sdk'
 import { toast } from 'sonner'
 import ErrorBanner from '@/components/ui/error-banner'
-import { Link, useNavigate } from 'react-router'
+import { Link, useNavigate } from 'react-router-dom'
 import { useMemo, useState } from 'react'
 import { Progress } from '@/components/ui/progress'
 import { useSetAtom } from 'jotai'
@@ -142,16 +142,11 @@ const StatementDetails = ({ data }: Props) => {
                             <TableCell>
                                 <div className='flex items-center gap-2'>
                                     <BankLogo bank={bank} />
-                                    <span className="text-sm">{bank?.account_name}</span>
+                                    <span className="tracking-tight text-sm font-medium">{bank?.account_name}</span>
+                                    <span title="GL Account" className="text-sm">{bank?.account}</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>
@@ -163,11 +158,7 @@ const StatementDetails = ({ data }: Props) => {
                         </TableRow>
                         <TableRow>
                             <TableHead>{_("Transaction Dates")}</TableHead>
-                            {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>
-                            )}
+                            <TableCell>{_("{0} to {1}", [formatDate(data.doc.start_date, "Do MMMM YYYY"), formatDate(data.doc.end_date, "Do MMMM YYYY")])}</TableCell>
                         </TableRow>
                         <TableRow>
                             <TableHead>{_("Number of Transactions")}</TableHead>

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

@@ -1,129 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,362 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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,97 +1,6 @@
 import { BankStatementImportLog } from "@/types/Accounts/BankStatementImportLog"
-import { useFrappeGetCall, useFrappePostCall } from "frappe-react-sdk"
+import { useFrappeGetCall } 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,
@@ -121,7 +30,6 @@ export interface GetStatementDetailsResponse {
     date_format: string,
     raw_data: Array<Array<string>>,
     currency: string,
-    pdf_tables?: PDFTable[],
 }
 
 export const useGetStatementDetails = (id: string) => {
@@ -131,24 +39,4 @@ 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-ink-red-3'
+                return 'text-red-700'
             case 'doc':
             case 'docx':
                 return 'text-[#1A5CBD]'

banking/src/hooks/useCurrentCompany.ts

@@ -1,9 +1,7 @@
 import { useAtomValue } from "jotai"
 import { atomWithStorage } from "jotai/utils"
 
-export const selectedCompanyAtom = atomWithStorage<string>('bank-rec-selected-company', window.frappe?.boot?.user?.defaults?.company || '', undefined, {
-    getOnInit: true,
-})
+export const selectedCompanyAtom = atomWithStorage<string>('bank-rec-selected-company', window.frappe?.boot?.user?.defaults?.company || '')
 
 export const useCurrentCompany = () => {
     const selectedCompany = useAtomValue(selectedCompanyAtom)

banking/src/lib/amountFormula.ts

@@ -1,26 +0,0 @@
-import { Parser } from 'safe-expr-eval'
-
-const parser = new Parser()
-
-const PLAIN_NUMBER_PATTERN = /^-?\d+(\.\d+)?$/
-
-export function evaluateAmountFormula(expression: string, transactionAmount: number): number {
-    const trimmed = expression.trim()
-    if (!trimmed) {
-        return 0
-    }
-
-    if (PLAIN_NUMBER_PATTERN.test(trimmed)) {
-        return Number(trimmed)
-    }
-
-    try {
-        const result = parser.parse(trimmed).evaluate({ transaction_amount: transactionAmount })
-        if (typeof result !== 'number' || !Number.isFinite(result)) {
-            return 0
-        }
-        return result
-    } catch {
-        return 0
-    }
-}

banking/src/lib/frappe.ts

@@ -33,16 +33,6 @@ 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,7 +7,6 @@ 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"
@@ -17,7 +16,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, useFrappeUpdateDoc } from "frappe-react-sdk"
+import { useFrappeCreateDoc, useFrappeFileUpload, useFrappeGetDocList } from "frappe-react-sdk"
 import { useAtom, useAtomValue } from "jotai"
 import { ListIcon, Loader2Icon } from "lucide-react"
 import { useState } from "react"
@@ -31,15 +30,11 @@ 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 = () => {
 
@@ -49,18 +44,12 @@ const BankStatementImporter = () => {
 
         const id = `new-bank-statement-import-log-${Date.now()}`
 
-        // 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], {
+        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
                 {
@@ -78,7 +67,6 @@ 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>
@@ -101,7 +89,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, XLSX and PDF files.")}
+                                    {_("Upload your bank statement file to start the import process. We support CSV, and XLSX files.")}
                                 </p>
                             </div>
                             <div>
@@ -117,27 +105,10 @@ 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
@@ -166,10 +137,9 @@ const StatementInstructions = () => {
         <DialogContent className="min-w-7xl">
             <DialogHeader>
                 <DialogTitle>{_("Statement Import Instructions")}</DialogTitle>
-                <DialogDescription>{_("We support uploading CSV, XLSX, XLS and PDF files. Please make sure the file contains the correct columns.")}</DialogDescription>
+                <DialogDescription>{_("We support uploading CSV, XLSX and XLS 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>
@@ -261,13 +231,7 @@ 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>
-                                    {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>{formatDate(item.start_date, 'Do MMM YYYY')} to {formatDate(item.end_date, 'Do MMM YYYY')}</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,13 +9,12 @@ 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, mutate } = useGetStatementDetails(id ?? "")
+    const { data, isLoading, error } = useGetStatementDetails(id ?? "")
 
     useFrappeDocumentEventListener("Bank Statement Import Log", id ?? "", () => {
     })
@@ -43,13 +42,7 @@ const ViewBankStatementImportLog = () => {
             <ErrorBanner error={error} />
         </div>
     }
-    const isPdf = data.message.doc.file?.toLowerCase().endsWith('.pdf')
-
-    if (isPdf) {
-        return <PDFImport data={data} mutate={mutate} />
-    }
-
-    return <CSVImport data={data} mutate={mutate} />
+    return <CSVImport data={data} />
 }
 
 export default ViewBankStatementImportLog

banking/src/types/Accounts/BankAccount.ts

@@ -38,8 +38,6 @@ 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,6 +47,4 @@ 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
 }

erpnext/__init__.py

@@ -6,7 +6,7 @@ import frappe
 from frappe.model.document import Document
 from frappe.utils.user import is_website_user
 
-__version__ = "16.31.1"
+__version__ = "16.15.1"
 
 
 def get_default_company(user=None):

erpnext/accounts/custom/address.py

@@ -17,7 +17,7 @@ class ERPNextAddress(Address):
 
 	def link_address(self):
 		"""Link address based on owner"""
-		if self.get("is_your_company_address"):
+		if self.is_your_company_address:
 			return
 
 		return super().link_address()
@@ -28,9 +28,7 @@ class ERPNextAddress(Address):
 				self.is_your_company_address = 1
 
 	def validate_reference(self):
-		if self.get("is_your_company_address") and not [
-			row for row in self.links if row.link_doctype == "Company"
-		]:
+		if self.is_your_company_address and not [row for row in self.links if row.link_doctype == "Company"]:
 			frappe.throw(
 				_(
 					"Address needs to be linked to a Company. Please add a row for Company in the Links table."

erpnext/accounts/doctype/account/account.py

@@ -120,7 +120,6 @@ class Account(NestedSet):
 		self.validate_account_currency()
 		self.validate_root_company_and_sync_account_to_children()
 		self.validate_receivable_payable_account_type()
-		self.validate_stock_account_type_change()
 
 	def validate_parent_child_account_type(self):
 		if self.parent_account:
@@ -209,36 +208,6 @@ class Account(NestedSet):
 				frappe.msgprint(msg)
 				self.add_comment("Comment", msg)
 
-	def validate_stock_account_type_change(self):
-		doc_before_save = self.get_doc_before_save()
-		if not (doc_before_save and doc_before_save.account_type == "Stock"):
-			return
-
-		if self.account_type == "Stock":
-			return
-
-		if self.stock_ledger_entry_exists():
-			frappe.throw(
-				_(
-					"The account type of {0} cannot be changed from {1} because stock ledger entries exist against it."
-				).format(frappe.bold(self.name), frappe.bold(_("Stock")))
-			)
-
-	def stock_ledger_entry_exists(self):
-		from erpnext.stock import get_warehouse_account_map
-
-		warehouse_account = get_warehouse_account_map(self.company)
-		warehouses = [wh for wh, details in warehouse_account.items() if details.account == self.name]
-		if not warehouses:
-			return False
-
-		return bool(
-			frappe.db.count(
-				"Stock Ledger Entry",
-				filters={"warehouse": ("in", warehouses), "is_cancelled": 0},
-			)
-		)
-
 	def validate_root_details(self):
 		doc_before_save = self.get_doc_before_save()
 

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

@@ -24,8 +24,7 @@
 						"account_number": "11530"
 					},
 					"account_number": "115",
-					"is_group": 1,
-					"account_type": "Bank"
+					"is_group": 1
 				},
 				"Trade Receivables": {
 					"Trade Debtors": {
@@ -530,13 +529,6 @@
 					"account_number": "630",
 					"is_group": 1
 				},
-				"Accrued Manufacturing Expenses": {
-					"Accrued Expenses - Manufacturing": {
-						"account_number": "63510"
-					},
-					"account_number": "635",
-					"is_group": 1
-				},
 				"account_number": "63",
 				"is_group": 1
 			},
@@ -822,4 +814,4 @@
 			"root_type": "Expense"
 		}
 	}
-}
+}

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

@@ -22,12 +22,12 @@
 						"account_type": "Cash"
 					},
 					"Petty Cash Fund": {
-						"account_number": "1110",
+						"account_number": "1200",
 						"is_group": 1,
 						"root_type": "Asset",
 						"account_type": "Cash",
 						"Petty Cash Fund": {
-							"account_number": "1111",
+							"account_number": "1201",
 							"is_group": 0,
 							"root_type": "Asset",
 							"account_type": "Cash"
@@ -35,16 +35,10 @@
 					}
 				},
 				"Bank Accounts": {
-					"account_number": "1200",
+					"account_number": "1102",
 					"is_group": 1,
 					"root_type": "Asset",
-					"account_type": "Bank",
-					"Cash in Bank - Checking Account": {
-						"account_number": "1201",
-						"is_group": 0,
-						"root_type": "Asset",
-						"account_type": "Bank"
-					}
+					"account_type": "Bank"
 				},
 				"Advances to Officers & Employees": {
 					"account_number": "1290",
@@ -110,20 +104,25 @@
 						"account_number": "1511",
 						"is_group": 0,
 						"root_type": "Asset"
+					},
+					"Factory Overhead Variance": {
+						"account_number": "1512",
+						"is_group": 0,
+						"root_type": "Asset"
 					}
 				},
 				"Finished Goods": {
-					"account_number": "1540",
+					"account_number": "1520",
 					"is_group": 1,
 					"root_type": "Asset",
 					"Finished Goods Inventory": {
-						"account_number": "1541",
+						"account_number": "1531",
 						"is_group": 0,
 						"root_type": "Asset",
 						"account_type": "Stock"
 					},
 					"Inventory in Transit": {
-						"account_number": "1542",
+						"account_number": "1532",
 						"is_group": 0,
 						"root_type": "Asset",
 						"account_type": "Stock Adjustment"
@@ -269,7 +268,7 @@
 						"root_type": "Asset"
 					}
 				},
-				"Intangible Assets": {
+				"System Development": {
 					"account_number": "1940",
 					"is_group": 1,
 					"root_type": "Asset",
@@ -278,17 +277,6 @@
 						"is_group": 0,
 						"root_type": "Asset"
 					}
-				},
-				"Accumulated Amortization - Intangible Assets": {
-					"account_number": "1950",
-					"is_group": 1,
-					"root_type": "Asset",
-					"Accum Amortization - System Development": {
-						"account_number": "1951",
-						"is_group": 0,
-						"root_type": "Asset",
-						"account_type": "Accumulated Depreciation"
-					}
 				}
 			}
 		},
@@ -418,7 +406,8 @@
 				"Customer Deposits": {
 					"account_number": "2500",
 					"is_group": 0,
-					"root_type": "Liability"
+					"root_type": "Liability",
+					"account_type": "Payable"
 				}
 			},
 			"Non Current Liabilities": {
@@ -574,28 +563,6 @@
 						"is_group": 0,
 						"root_type": "Income"
 					}
-				},
-				"Exchange Gain": {
-					"account_number": "6030",
-					"is_group": 1,
-					"root_type": "Income",
-					"Exchange Gain - Detail": {
-						"account_number": "6031",
-						"is_group": 0,
-						"root_type": "Income",
-						"account_type": "Indirect Income"
-					}
-				},
-				"Gain on Asset Disposal": {
-					"account_number": "6040",
-					"is_group": 1,
-					"root_type": "Income",
-					"Gain on Asset Disposal - Detail": {
-						"account_number": "6041",
-						"is_group": 0,
-						"root_type": "Income",
-						"account_type": "Indirect Income"
-					}
 				}
 			}
 		},
@@ -608,7 +575,7 @@
 				"is_group": 1,
 				"root_type": "Expense",
 				"Cost of Goods Sold": {
-					"account_number": "5002",
+					"account_number": "5010",
 					"is_group": 0,
 					"root_type": "Expense",
 					"account_type": "Cost of Goods Sold"
@@ -861,61 +828,20 @@
 					"root_type": "Expense"
 				}
 			},
-			"Other Expenses": {
-				"account_number": "5200",
-				"is_group": 1,
-				"root_type": "Expense",
-				"Bank Charges": {
-					"account_number": "5201",
-					"is_group": 0,
-					"root_type": "Expense",
-					"account_type": "Indirect Expense"
-				},
-				"Interest Expenses Bank": {
-					"account_number": "5202",
-					"is_group": 0,
-					"root_type": "Expense",
-					"account_type": "Indirect Expense"
-				},
-				"Write Off": {
-					"account_number": "5203",
-					"is_group": 0,
-					"root_type": "Expense",
-					"account_type": "Indirect Expense"
-				},
-				"Exchange Loss": {
-					"account_number": "5204",
-					"is_group": 0,
-					"root_type": "Expense",
-					"account_type": "Indirect Expense"
-				},
-				"Loss on Asset Disposal": {
-					"account_number": "5205",
-					"is_group": 0,
-					"root_type": "Expense",
-					"account_type": "Indirect Expense"
-				}
-			},
-			"Provision For Income Tax": {
-				"account_number": "5300",
-				"is_group": 0,
-				"root_type": "Expense",
-				"account_type": "Tax"
-			},
 			"Stock Adjustment": {
-				"account_number": "5400",
+				"account_number": "5200",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Stock Adjustment"
 			},
 			"Round Off": {
-				"account_number": "5500",
+				"account_number": "5300",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Round Off"
 			},
 			"Expenses Included In Valuation": {
-				"account_number": "5600",
+				"account_number": "5400",
 				"is_group": 0,
 				"root_type": "Expense",
 				"account_type": "Expenses Included In Valuation"

erpnext/accounts/doctype/account/test_account.py

@@ -307,31 +307,6 @@ class TestAccount(ERPNextTestSuite):
 		acc.account_currency = "USD"
 		self.assertRaises(frappe.ValidationError, acc.save)
 
-	def test_stock_account_type_change_with_ledger_entries(self):
-		from erpnext.stock.doctype.stock_entry.stock_entry_utils import make_stock_entry
-
-		company = "_Test Company with perpetual inventory"
-		warehouse = "Stores - TCP1"
-		stock_account = get_warehouse_account(frappe.get_doc("Warehouse", warehouse))
-
-		make_stock_entry(
-			item_code="_Test Item",
-			target=warehouse,
-			company=company,
-			qty=5,
-			basic_rate=100,
-		)
-
-		account = frappe.get_doc("Account", stock_account)
-		self.assertEqual(account.account_type, "Stock")
-
-		account.account_type = ""
-		self.assertRaises(frappe.ValidationError, account.save)
-
-		account.reload()
-		account.account_name = f"{account.account_name} Updated"
-		account.save()  # non-type change stays allowed
-
 	def test_account_balance(self):
 		from erpnext.accounts.utils import get_balance_on
 

erpnext/accounts/doctype/accounting_period/accounting_period.py

@@ -5,7 +5,6 @@
 import frappe
 from frappe import _
 from frappe.model.document import Document
-from frappe.utils import getdate, nowdate
 
 
 class OverlapError(frappe.ValidationError):
@@ -37,20 +36,8 @@ class AccountingPeriod(Document):
 	# end: auto-generated types
 
 	def validate(self):
-		self.validate_dates()
 		self.validate_overlap()
 
-	def validate_dates(self):
-		if getdate(self.start_date) > getdate(self.end_date):
-			frappe.throw(_("Start Date cannot be after End Date"))
-
-		if getdate(self.end_date) > getdate(nowdate()):
-			frappe.throw(
-				_(
-					"Accounting Period cannot be created for a future date. End Date {0} is after today."
-				).format(frappe.bold(frappe.format(self.end_date, "Date")))
-			)
-
 	def before_insert(self):
 		self.bootstrap_doctypes_for_closing()
 

erpnext/accounts/doctype/accounting_period/test_accounting_period.py

@@ -3,7 +3,7 @@
 import unittest
 
 import frappe
-from frappe.utils import nowdate
+from frappe.utils import add_months, nowdate
 
 from erpnext.accounts.doctype.accounting_period.accounting_period import (
 	ClosedAccountingPeriod,
@@ -94,7 +94,7 @@ def create_accounting_period(**args):
 
 	accounting_period = frappe.new_doc("Accounting Period")
 	accounting_period.start_date = args.start_date or nowdate()
-	accounting_period.end_date = args.end_date or nowdate()
+	accounting_period.end_date = args.end_date or add_months(nowdate(), 1)
 	accounting_period.company = args.company or "_Test Company"
 	accounting_period.period_name = args.period_name or "_Test_Period_Name_1"
 	accounting_period.append("closed_documents", {"document_type": "Sales Invoice", "closed": 1})

erpnext/accounts/doctype/accounts_settings/accounts_settings.js

@@ -10,7 +10,7 @@ frappe.ui.form.on("Accounts Settings", {
 				},
 			};
 		});
-		if (!frm.naming_controller) frm.naming_controller = new frappe.ui.NamingSeriesController(frm);
+		if (!frm.naming_controller) frm.naming_controller = new erpnext.NamingSeriesController(frm);
 
 		frm.naming_controller.render_table("transaction_naming_html", get_transactions(frm));
 	},

erpnext/accounts/doctype/accounts_settings/accounts_settings.json

@@ -21,8 +21,6 @@
   "enable_common_party_accounting",
   "allow_multi_currency_invoices_against_single_party_account",
   "confirm_before_resetting_posting_date",
-  "stock_expense_section",
-  "book_stock_expense_gl_entries",
   "analytics_section",
   "enable_discounts_and_margin",
   "enable_accounting_dimensions",
@@ -77,8 +75,6 @@
   "over_billing_allowance",
   "credit_controller",
   "role_allowed_to_over_bill",
-  "enable_overdue_billing_threshold",
-  "role_allowed_to_bypass_overdue_billing",
   "column_break_11",
   "assets_tab",
   "asset_settings_section",
@@ -90,7 +86,6 @@
   "period_closing_settings_section",
   "ignore_account_closing_balance",
   "use_legacy_controller_for_pcv",
-  "pcv_job_timeout",
   "column_break_25",
   "reports_tab",
   "remarks_section",
@@ -275,21 +270,6 @@
    "label": "Role Allowed to over bill ",
    "options": "Role"
   },
-  {
-   "default": "0",
-   "description": "Block a new Sales Invoice when the customer's overdue amount exceeds the Overdue Limit set on the customer.",
-   "fieldname": "enable_overdue_billing_threshold",
-   "fieldtype": "Check",
-   "label": "Restrict Customer Over Billing"
-  },
-  {
-   "depends_on": "eval:doc.enable_overdue_billing_threshold",
-   "description": "Users with this role can still submit invoices for customers who have crossed their Overdue Limit.",
-   "fieldname": "role_allowed_to_bypass_overdue_billing",
-   "fieldtype": "Link",
-   "label": "Role Allowed to Bypass Over Billing Restriction",
-   "options": "Role"
-  },
   {
    "fieldname": "period_closing_settings_section",
    "fieldtype": "Section Break"
@@ -631,14 +611,6 @@
    "fieldtype": "Check",
    "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",
    "fieldname": "role_to_notify_on_depreciation_failure",
@@ -768,18 +740,6 @@
    "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"
-  },
-  {
-   "fieldname": "stock_expense_section",
-   "fieldtype": "Section Break",
-   "label": "Stock Expense Accounting"
-  },
-  {
-   "default": "0",
-   "description": "Books Purchase Expense and Expenses Added To Stock account pairs against stock value. On enabling this, the accounts become mandatory in Company or Item Defaults for Purchase Receipt, Purchase Invoice, Stock Entry, Stock Reconciliation and Landed Cost Voucher",
-   "fieldname": "book_stock_expense_gl_entries",
-   "fieldtype": "Check",
-   "label": "Book Stock Expense GL Entries"
   }
  ],
  "grid_page_length": 50,
@@ -788,7 +748,7 @@
  "index_web_pages_for_search": 1,
  "issingle": 1,
  "links": [],
- "modified": "2026-07-27 12:00:00.000000",
+ "modified": "2026-06-15 18:26:50.778723",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Accounts Settings",

erpnext/accounts/doctype/accounts_settings/accounts_settings.py

@@ -62,7 +62,6 @@ class AccountsSettings(Document):
 		book_asset_depreciation_entry_automatically: DF.Check
 		book_deferred_entries_based_on: DF.Literal["Days", "Months"]
 		book_deferred_entries_via_journal_entry: DF.Check
-		book_stock_expense_gl_entries: DF.Check
 		book_tax_discount_loss: DF.Check
 		calculate_depr_using_total_days: DF.Check
 		check_supplier_invoice_uniqueness: DF.Check
@@ -78,7 +77,6 @@ class AccountsSettings(Document):
 		enable_fuzzy_matching: DF.Check
 		enable_immutable_ledger: DF.Check
 		enable_loyalty_point_program: DF.Check
-		enable_overdue_billing_threshold: DF.Check
 		enable_party_matching: DF.Check
 		enable_subscription: DF.Check
 		exchange_gain_loss_posting_date: DF.Literal["Invoice", "Payment", "Reconciliation Date"]
@@ -92,12 +90,10 @@ 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
 		receivable_payable_fetch_method: DF.Literal["Buffered Cursor", "UnBuffered Cursor"]
 		receivable_payable_remarks_length: DF.Int
 		reconciliation_queue_size: DF.Int
 		repost_allowed_types: DF.Table[RepostAllowedTypes]
-		role_allowed_to_bypass_overdue_billing: DF.Link | None
 		role_allowed_to_over_bill: DF.Link | None
 		role_to_notify_on_depreciation_failure: DF.Link | None
 		role_to_override_stop_action: DF.Link | None
@@ -153,10 +149,6 @@ class AccountsSettings(Document):
 			toggle_subscription_sections(not self.enable_subscription)
 			clear_cache = True
 
-		if old_doc.enable_overdue_billing_threshold != self.enable_overdue_billing_threshold:
-			toggle_overdue_billing_threshold_field(not self.enable_overdue_billing_threshold)
-			clear_cache = True
-
 		if clear_cache:
 			frappe.clear_cache()
 
@@ -248,10 +240,6 @@ def toggle_subscription_sections(hide):
 		create_property_setter_for_hiding_field(doctype, "subscription_section", hide)
 
 
-def toggle_overdue_billing_threshold_field(hide):
-	create_property_setter_for_hiding_field("Customer Credit Limit", "overdue_billing_threshold", hide)
-
-
 def create_property_setter_for_hiding_field(doctype, field_name, hide):
 	make_property_setter(
 		doctype,

erpnext/accounts/doctype/advance_payment_ledger_entry/test_advance_payment_ledger_entry.py

@@ -22,13 +22,11 @@ class TestAdvancePaymentLedgerEntry(ERPNextTestSuite, AccountsTestMixin):
 	"""
 
 	def setUp(self):
-		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"
+		self.create_company()
+		self.create_usd_receivable_account()
+		self.create_usd_payable_account()
+		self.create_item()
+		self.clear_old_entries()
 
 	def create_sales_order(self, qty=1, rate=100, currency="INR", do_not_submit=False):
 		"""

erpnext/accounts/doctype/bank_account/bank_account.json

@@ -27,7 +27,6 @@
   "column_break_12",
   "branch_code",
   "bank_account_no",
-  "statement_password",
   "address_and_contact",
   "address_html",
   "column_break_13",
@@ -150,12 +149,6 @@
    "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,7 +41,6 @@ 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):
@@ -107,7 +106,7 @@ def get_party_bank_account(party_type, party):
 	)
 
 
-def get_default_company_bank_account(company, party_type, party, ignore_permissions=True):
+def get_default_company_bank_account(company, party_type, party):
 	default_company_bank_account = frappe.db.get_value(party_type, party, "default_bank_account")
 	if default_company_bank_account:
 		if company != frappe.get_cached_value("Bank Account", default_company_bank_account, "company"):
@@ -118,14 +117,6 @@ def get_default_company_bank_account(company, party_type, party, ignore_permissi
 			"Bank Account", {"company": company, "is_company_account": 1, "is_default": 1}
 		)
 
-	if not ignore_permissions:
-		default_company_bank_account = (
-			default_company_bank_account
-			if default_company_bank_account
-			and frappe.get_cached_doc("Bank Account", default_company_bank_account).has_permission("select")
-			else None
-		)
-
 	return default_company_bank_account
 
 

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.json

@@ -1,6 +1,5 @@
 {
  "actions": [],
- "allow_bulk_edit": 1,
  "allow_rename": 1,
  "creation": "2026-04-11 19:48:13.622253",
  "doctype": "DocType",
@@ -8,8 +7,7 @@
  "field_order": [
   "bank_account",
   "date",
-  "balance",
-  "company"
+  "balance"
  ],
  "fields": [
   {
@@ -33,20 +31,12 @@
    "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-06-16 22:17:48.007982",
+ "modified": "2026-04-11 19:49:45.374695",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Account Balance",

erpnext/accounts/doctype/bank_account_balance/bank_account_balance.py

@@ -16,7 +16,6 @@ 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_guarantee/bank_guarantee.js

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

erpnext/accounts/doctype/bank_reconciliation_tool/bank_reconciliation_tool.py

@@ -64,7 +64,7 @@ def get_bank_transactions(
 		filters.append(["date", "<=", to_date])
 	if from_date:
 		filters.append(["date", ">=", from_date])
-	transactions = frappe.get_list(
+	transactions = frappe.get_all(
 		"Bank Transaction",
 		fields=[
 			"date",
@@ -93,7 +93,6 @@ def get_bank_transactions(
 @frappe.whitelist()
 def get_account_balance(bank_account: str, till_date: str | date, company: str):
 	# returns account balance till the specified date
-	frappe.has_permission("Bank Account", "read", bank_account, throw=True)
 	account = frappe.db.get_value("Bank Account", bank_account, "account")
 	filters = frappe._dict(
 		{
@@ -1079,7 +1078,7 @@ def reconcile_vouchers(bank_transaction_name: str | int, vouchers: str, is_new_v
 @frappe.whitelist()
 def get_linked_payments(
 	bank_transaction_name: str | int,
-	document_types: str | list[str] | None = None,
+	document_types: list[str] | None = None,
 	from_date: str | date | None = None,
 	to_date: str | date | None = None,
 	filter_by_reference_date: bool | None = None,

erpnext/accounts/doctype/bank_reconciliation_tool/test_bank_reconciliation_tool.py

@@ -17,10 +17,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankReconciliationTool(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
-		self.debit_to = "Debtors - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		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.py

@@ -143,30 +143,6 @@ def preprocess_mt940_content(content: str) -> str:
 	return processed_content
 
 
-MT940_CUSTOMER_REFERENCE_MAX_LEN = 16
-
-
-def get_transaction_reference(txn_data: dict) -> str:
-	"""Extract the per-transaction reference from an MT940 :61: tag.
-
-	The mt940 library exposes ``transaction_reference`` from the :20: tag, which is the
-	statement-level reference and identical for every transaction in a statement. The
-	real per-transaction reference is ``customer_reference`` (with any overflow captured
-	into ``extra_details`` when a bank emits a single-line :61: longer than 16 chars).
-	"""
-	customer_reference = (txn_data.get("customer_reference") or "").strip()
-
-	if len(customer_reference) == MT940_CUSTOMER_REFERENCE_MAX_LEN:
-		customer_reference += (txn_data.get("extra_details") or "").strip()
-
-	if customer_reference and customer_reference.upper() != "NONREF":
-		return customer_reference
-
-	return (txn_data.get("bank_reference") or "").strip() or (
-		txn_data.get("transaction_reference") or ""
-	).strip()
-
-
 @frappe.whitelist()
 def convert_mt940_to_csv(data_import, mt940_file_path):
 	doc = frappe.get_doc("Bank Statement Import", data_import)
@@ -214,8 +190,8 @@ def convert_mt940_to_csv(data_import, mt940_file_path):
 
 		deposit = amount_value if amount_value > 0 else ""
 		withdrawal = abs(amount_value) if amount_value < 0 else ""
-		description = txn.data.get("transaction_details") or txn.data.get("extra_details") or ""
-		reference = get_transaction_reference(txn.data)
+		description = txn.data.get("extra_details") or ""
+		reference = txn.data.get("transaction_reference") or ""
 		currency = txn.data.get("currency", "")
 
 		writer.writerow([date_str, deposit, withdrawal, description, reference, doc.bank_account, currency])

erpnext/accounts/doctype/bank_statement_import/test_bank_statement_import.py

@@ -1,10 +1,7 @@
 # Copyright (c) 2020, Frappe Technologies and Contributors
 # See license.txt
 
-import mt940
-
 from erpnext.accounts.doctype.bank_statement_import.bank_statement_import import (
-	get_transaction_reference,
 	is_mt940_format,
 	preprocess_mt940_content,
 )
@@ -191,135 +188,6 @@ class TestBankStatementImport(ERPNextTestSuite):
 		self.assertIn(":20:STMTREF167619", result)  # Reference should remain unchanged
 		self.assertIn("UPI/TEST USER/123456789/PaidViaTestApp", result)
 
-	def test_get_transaction_reference_uses_customer_reference(self):
-		"""Per-transaction reference must come from :61: customer_reference, not :20:."""
-		self.assertEqual(
-			get_transaction_reference(
-				{"customer_reference": "UPI-100000000001", "transaction_reference": "STMTREF12345"}
-			),
-			"UPI-100000000001",
-		)
-
-	def test_get_transaction_reference_rejoins_overflow(self):
-		"""When a bank emits a single-line :61: with >16-char reference, the regex
-		splits the tail into extra_details. We must rejoin them."""
-		self.assertEqual(
-			get_transaction_reference(
-				{
-					"customer_reference": "NEFTINW-12345678",
-					"extra_details": "90",
-					"transaction_reference": "STMTREF12345",
-				}
-			),
-			"NEFTINW-1234567890",
-		)
-
-	def test_get_transaction_reference_falls_back_to_bank_reference_on_nonref(self):
-		"""NONREF is the MT940 'no customer reference' sentinel; prefer bank_reference."""
-		self.assertEqual(
-			get_transaction_reference(
-				{
-					"customer_reference": "NONREF",
-					"bank_reference": "1234567890123456",
-					"transaction_reference": "STMTREF12345",
-				}
-			),
-			"1234567890123456",
-		)
-
-	def test_get_transaction_reference_falls_back_to_bank_reference_on_nonref_with_extra_details(self):
-		"""NONREF sentinel must trigger the bank_reference fallback even when
-		extra_details is populated. Without the 16-char gate, the old naive concat
-		would produce a junk reference like 'NONREFsome info' and bypass the check."""
-		self.assertEqual(
-			get_transaction_reference(
-				{
-					"customer_reference": "NONREF",
-					"extra_details": "some info",
-					"bank_reference": "1234567890123456",
-					"transaction_reference": "STMTREF12345",
-				}
-			),
-			"1234567890123456",
-		)
-
-	def test_get_transaction_reference_does_not_append_extra_details_below_16_chars(self):
-		"""When customer_reference is below the 16-char cap, extra_details is a
-		genuine supplementary-info field from :61: — not overflow — and must not
-		be appended to the reference."""
-		self.assertEqual(
-			get_transaction_reference(
-				{
-					"customer_reference": "TBMS-123456789",
-					"extra_details": "note field",
-					"transaction_reference": "STMTREF12345",
-				}
-			),
-			"TBMS-123456789",
-		)
-
-	def test_get_transaction_reference_keeps_noref_literal(self):
-		"""Bare 'NOREF' (without bank_reference) stays as-is; still better than the
-		statement-level reference which is identical across all transactions."""
-		self.assertEqual(
-			get_transaction_reference(
-				{
-					"customer_reference": "NOREF",
-					"bank_reference": None,
-					"transaction_reference": "STMTREF12345",
-				}
-			),
-			"NOREF",
-		)
-
-	def test_mt940_parse_per_transaction_reference_mapping(self):
-		"""End-to-end: every transaction in a statement must get its own distinct
-		reference from :61: customer_reference, never the statement-level :20: reference."""
-		mt940_content = """{1:F0112345678901X0000000000}{2:I94012345678901XN}{4:
-:20:STMTREF12345
-:25:1234567890
-:28C:12345/1
-:60F:C250716INR88123,38
-:61:2509280928D5000,00NMSCUPI-100000000001
-:86:UPI/TEST PAYEE ONE/111111111111/TestApp
-:61:2509190919D2606,00NMSCUPI-100000000002
-:86:UPI/TEST PAYEE TWO/222222222222/TestApp
-:61:2509190919D900,00NMSCUPI-100000000003
-:86:UPI/TEST PAYEE THREE/333333333333/TestApp
-:61:2508140814D5000,00NMSCUPI-100000000004
-:86:UPI/TEST PAYEE FOUR/444444444444/TestApp
-:61:2508060806D2000,00NMSCUPI-100000000005
-:86:UPI/TEST PAYEE FIVE/555555555555/TestApp
-:61:2508030803D1066,00NMSC123456789012
-:86:PCD/1234/TEST MERCHANT/01234567890123/12:00
-:61:2507310731D305,62NMSCTBMS-123456789
-:86:Chrg: Debit Card Annual Fee 1234 for 2025
-:61:2507240724C1,00NMSCNEFTINW-1234567890
-:86:NEFT TEST123456789 TEST SERVICES
-:61:2507170717C100000,00NMSCNOREF
-:86:BY CLG INST 123456/01-01-25/TESTBANK/TESTCITY
-:62F:C250930INR100000,00
--}"""
-		transactions = list(mt940.parse(preprocess_mt940_content(mt940_content)))
-		references = [get_transaction_reference(t.data) for t in transactions]
-
-		self.assertEqual(
-			references,
-			[
-				"UPI-100000000001",
-				"UPI-100000000002",
-				"UPI-100000000003",
-				"UPI-100000000004",
-				"UPI-100000000005",
-				"123456789012",
-				"TBMS-123456789",
-				"NEFTINW-1234567890",
-				"NOREF",
-			],
-		)
-		# No transaction should carry the statement-level reference from :20:
-		self.assertNotIn("STMTREF12345", references)
-
 	def test_preprocess_mt940_content_whitespace_variants(self):
 		"""Test handling of whitespace and different line endings"""
 		# Test with trailing spaces

erpnext/accounts/doctype/bank_statement_import_log/bank_statement_import_log.json

@@ -28,8 +28,7 @@
   "detected_transaction_starting_index",
   "detected_transaction_ending_index",
   "section_break_yulq",
-  "column_mapping",
-  "pdf_tables"
+  "column_mapping"
  ],
  "fields": [
   {
@@ -54,6 +53,7 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Closing Balance",
+   "non_negative": 1,
    "options": "currency"
   },
   {
@@ -128,13 +128,6 @@
    "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",
@@ -190,7 +183,7 @@
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2026-07-09 17:55:25.615942",
+ "modified": "2026-05-08 17:55:25.615942",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Bank Statement Import Log",

erpnext/accounts/doctype/bank_statement_import_log/test_bank_statement_import_log.py

@@ -7,18 +7,7 @@ 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
@@ -26,9 +15,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankStatementImportLog(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()
@@ -124,346 +113,6 @@ 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/test_bank_transaction.py

@@ -104,36 +104,6 @@ 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(

erpnext/accounts/doctype/bank_transaction_rule/bank_transaction_rule.py

@@ -9,48 +9,6 @@ from frappe.model.document import Document
 
 from erpnext.accounts.doctype.bank_transaction.bank_transaction import BankTransaction
 
-PLAIN_NUMBER_PATTERN = re.compile(r"^-?\d+(\.\d+)?$")
-# Tokens accepted by safe-expr-eval on the frontend (must stay in sync).
-ALLOWED_FORMULA_TOKEN = re.compile(r"\s+|transaction_amount|\d+(?:\.\d+)?|[+\-*/%^()]")
-PYTHON_ONLY_OPERATORS = ("**", "//")
-
-
-def _is_expr_eval_formula(formula: str) -> bool:
-	position = 0
-	while position < len(formula):
-		match = ALLOWED_FORMULA_TOKEN.match(formula, position)
-		if not match:
-			return False
-		position = match.end()
-
-	return formula.count("(") == formula.count(")")
-
-
-def validate_amount_formula(formula: str) -> None:
-	if not formula:
-		return
-
-	stripped = formula.strip()
-	if PLAIN_NUMBER_PATTERN.match(stripped):
-		return
-
-	if any(operator in stripped for operator in PYTHON_ONLY_OPERATORS):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	if not _is_expr_eval_formula(stripped):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	# expr-eval uses ^ for exponentiation; translate for a smoke-test evaluation only.
-	python_formula = stripped.replace("^", "**")
-
-	try:
-		result = frappe.safe_eval(python_formula, eval_globals=None, eval_locals={"transaction_amount": 1})
-	except Exception:
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
-	if not isinstance(result, (int | float)):
-		frappe.throw(_("Invalid debit/credit formula: {0}").format(formula))
-
 
 class BankTransactionRule(Document):
 	# begin: auto-generated types
@@ -128,11 +86,6 @@ class BankTransactionRule(Document):
 							frappe.throw(
 								_("The last account row must not have any debit or credit amounts set.")
 							)
-					else:
-						if account.debit:
-							validate_amount_formula(account.debit)
-						if account.credit:
-							validate_amount_formula(account.credit)
 
 		# Validate regex
 		for rule in self.description_rules:

erpnext/accounts/doctype/bank_transaction_rule/test_bank_transaction_rule.py

@@ -11,11 +11,9 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.bank = "HDFC - _TC"
-		self.debit_to = "Debtors - _TC"
-		self.cash = "Cash - _TC"
+		self.create_company()
+		self.create_customer()
+		self.clear_old_entries()
 		bank_dt = qb.DocType("Bank")
 		qb.from_(bank_dt).delete().where(bank_dt.name == "HDFC").run()
 		self.create_bank_account()
@@ -231,45 +229,3 @@ class TestBankTransactionRule(ERPNextTestSuite, AccountsTestMixin):
 		doc = self._rule("bad_rx", [{"check": "Regex", "value": "["}])
 		with self.assertRaises(ValidationError):
 			doc.insert()
-
-	def _multiple_accounts_rule(self, prefix: str, accounts, **fields):
-		return self._rule(
-			prefix,
-			[{"check": "Contains", "value": "x"}],
-			classify_as="Bank Entry",
-			bank_entry_type="Multiple Accounts",
-			accounts=accounts,
-			**fields,
-		)
-
-	def test_validate_bank_entry_multiple_valid_amount_formulas(self):
-		doc = self._multiple_accounts_rule(
-			"be_formula",
-			accounts=[
-				{"account": self.bank, "debit": "200", "credit": ""},
-				{"account": self.cash, "debit": "", "credit": "transaction_amount * 0.25"},
-				{"account": self.cash, "debit": "", "credit": ""},
-			],
-		)
-		doc.insert()
-		self.assertTrue(doc.name)
-
-	def test_validate_bank_entry_multiple_invalid_amount_formulas(self):
-		malicious_formulas = [
-			"__import__('os')",
-			"eval('1+1')",
-			"open('/etc/passwd')",
-			"transaction_amount ** 2",
-			"transaction_amount // 2",
-		]
-		for formula in malicious_formulas:
-			with self.subTest(formula=formula):
-				doc = self._multiple_accounts_rule(
-					"be_bad_formula",
-					accounts=[
-						{"account": self.bank, "debit": formula, "credit": ""},
-						{"account": self.cash, "debit": "", "credit": ""},
-					],
-				)
-				with self.assertRaises(ValidationError):
-					doc.insert()

erpnext/accounts/doctype/budget/budget.js

@@ -136,9 +136,6 @@ 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

@@ -159,9 +159,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 its Root Type is not of Income or Expense"
-				).format(self.account)
+				_("Budget cannot be assigned against {0}, as it's not an Income or Expense account").format(
+					self.account
+				)
 			)
 
 	def set_null_value(self):
@@ -355,8 +355,8 @@ class Budget(Document):
 		if self.should_regenerate_budget_distribution():
 			return
 
-		total_amount = sum(flt(d.amount) for d in self.budget_distribution)
-		total_percent = sum(flt(d.percent) for d in self.budget_distribution)
+		total_amount = sum(d.amount for d in self.budget_distribution)
+		total_percent = sum(d.percent for d in self.budget_distribution)
 
 		if flt(abs(total_amount - self.budget_amount), 2) > 0.10:
 			frappe.throw(

erpnext/accounts/doctype/budget_distribution/budget_distribution.json

@@ -18,7 +18,6 @@
    "in_list_view": 1,
    "label": "Start Date",
    "read_only": 1,
-   "reqd": 1,
    "search_index": 1
   },
   {
@@ -26,29 +25,26 @@
    "fieldtype": "Date",
    "in_list_view": 1,
    "label": "End Date",
-   "read_only": 1,
-   "reqd": 1
+   "read_only": 1
   },
   {
    "fieldname": "amount",
    "fieldtype": "Currency",
    "in_list_view": 1,
-   "label": "Amount",
-   "reqd": 1
+   "label": "Amount"
   },
   {
    "fieldname": "percent",
    "fieldtype": "Percent",
    "in_list_view": 1,
-   "label": "Percent",
-   "reqd": 1
+   "label": "Percent"
   }
  ],
  "grid_page_length": 50,
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2026-06-18 11:23:17.669733",
+ "modified": "2025-11-03 13:18:28.398198",
  "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
+		end_date: DF.Date | None
 		parent: DF.Data
 		parentfield: DF.Data
 		parenttype: DF.Data
 		percent: DF.Percent
-		start_date: DF.Date
+		start_date: DF.Date | None
 	# end: auto-generated types
 
 	pass

erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py

@@ -75,10 +75,7 @@ def validate_company(company):
 
 @frappe.whitelist()
 def import_coa(file_name, company):
-	frappe.only_for("Accounts Manager")
-
 	# delete existing data for accounts
-	frappe.has_permission("Company", "write", company, throw=True)
 	unset_existing_data(company)
 
 	# create accounts
@@ -218,7 +215,6 @@ def build_forest(data):
 		for row in data:
 			account_name, parent_account, account_number, parent_account_number = row[0:4]
 			if account_number:
-				account_number = cstr(account_number).strip()
 				account_name = f"{account_number} - {account_name}"
 			if parent_account_number:
 				parent_account_number = cstr(parent_account_number).strip()
@@ -455,7 +451,6 @@ 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
@@ -467,7 +462,8 @@ def unset_existing_data(company):
 		"Sales Taxes and Charges Template",
 		"Purchase Taxes and Charges Template",
 	]:
-		frappe.get_query(doctype, delete=True, filters={"company": company}, ignore_permissions=False).run()
+		dt = frappe.qb.DocType(doctype)
+		frappe.qb.from_(dt).where(dt.company == company).delete().run()
 
 
 def set_default_accounts(company):

erpnext/accounts/doctype/dunning/dunning.js

@@ -169,10 +169,23 @@ frappe.ui.form.on("Dunning", {
 	},
 	get_dunning_letter_text: function (frm) {
 		if (frm.doc.dunning_type) {
-			frm.call("get_dunning_letter_text").then((r) => {
-				if (!r.exc) {
-					frm.refresh_fields();
-				}
+			frappe.call({
+				method: "erpnext.accounts.doctype.dunning.dunning.get_dunning_letter_text",
+				args: {
+					dunning_type: frm.doc.dunning_type,
+					language: frm.doc.language,
+					doc: frm.doc,
+				},
+				callback: function (r) {
+					if (r.message) {
+						frm.set_value("body_text", r.message.body_text);
+						frm.set_value("closing_text", r.message.closing_text);
+						frm.set_value("language", r.message.language);
+					} else {
+						frm.set_value("body_text", "");
+						frm.set_value("closing_text", "");
+					}
+				},
 			});
 		}
 	},

erpnext/accounts/doctype/dunning/dunning.py

@@ -163,46 +163,6 @@ class Dunning(AccountsController):
 			"Serial and Batch Bundle",
 		]
 
-	@frappe.whitelist()
-	def get_dunning_letter_text(self):
-		DOCTYPE = "Dunning Letter Text"
-		FIELDS = ["body_text", "closing_text", "language"]
-
-		if not self.dunning_type:
-			return
-
-		filters = {"parent": self.dunning_type, "is_default_language": 1}
-
-		if self.language:
-			filters.pop("is_default_language")
-			filters["language"] = self.language
-
-		letter_text = frappe.db.get_value(DOCTYPE, filters, FIELDS, as_dict=True)
-
-		if not letter_text:
-			msg = (
-				_("Dunning Letter for Dunning Type {0} in language '{1}' not found.").format(
-					frappe.bold(self.dunning_type), frappe.bold(self.language)
-				)
-				if self.language
-				else _("Dunning Letter for Dunning Type {0} not found.").format(
-					frappe.bold(self.dunning_type)
-				)
-			)
-			frappe.msgprint(msg, alert=True, indicator="yellow")
-
-		self.body_text = (
-			frappe.render_template(letter_text.body_text, self.as_dict(), restrict_globals=True)
-			if letter_text
-			else None
-		)
-		self.closing_text = (
-			frappe.render_template(letter_text.closing_text, self.as_dict(), restrict_globals=True)
-			if letter_text
-			else None
-		)
-		self.language = letter_text.language if letter_text else self.language
-
 
 def update_linked_dunnings(doc, previous_outstanding_amount):
 	if (
@@ -281,3 +241,35 @@ def get_linked_dunnings_as_per_state(sales_invoice, state):
 			& (overdue_payment.sales_invoice == sales_invoice)
 		)
 	).run(as_dict=True)
+
+
+@frappe.whitelist()
+def get_dunning_letter_text(dunning_type: str, doc: str | dict, language: str | None = None) -> dict:
+	DOCTYPE = "Dunning Letter Text"
+	FIELDS = ["body_text", "closing_text", "language"]
+
+	if isinstance(doc, str):
+		doc = json.loads(doc)
+
+	if not language:
+		language = doc.get("language")
+
+	letter_text = None
+	if language:
+		letter_text = frappe.db.get_value(
+			DOCTYPE, {"parent": dunning_type, "language": language}, FIELDS, as_dict=1
+		)
+
+	if not letter_text:
+		letter_text = frappe.db.get_value(
+			DOCTYPE, {"parent": dunning_type, "is_default_language": 1}, FIELDS, as_dict=1
+		)
+
+	if not letter_text:
+		return {}
+
+	return {
+		"body_text": frappe.render_template(letter_text.body_text, doc),
+		"closing_text": frappe.render_template(letter_text.closing_text, doc),
+		"language": letter_text.language,
+	}

erpnext/accounts/doctype/dunning_type/dunning_type.py

@@ -3,10 +3,7 @@
 
 
 import frappe
-from frappe import _
 from frappe.model.document import Document
-from frappe.utils import comma_and
-from frappe.utils.jinja import validate_template
 
 
 class DunningType(Document):
@@ -33,134 +30,3 @@ class DunningType(Document):
 	def autoname(self):
 		company_abbr = frappe.get_value("Company", self.company, "abbr")
 		self.name = f"{self.dunning_type} - {company_abbr}"
-
-	def validate(self):
-		self.validate_dunning_letter_text()
-		self.validate_income_account()
-		self.validate_cost_center()
-		self.set_default_dunning_type()
-
-	def validate_dunning_letter_text(self):
-		self.validate_languages()
-		self.validate_is_default_language()
-		self.validate_dunning_letter_text_templates()
-
-	def validate_income_account(self):
-		if not self.income_account:
-			return
-
-		account = frappe.get_cached_doc("Account", self.income_account)
-
-		msg = []
-		if account.company != self.company:
-			msg.append(
-				_(
-					"{0} doesn't belong to Company {1}. Please select an Income Account that belongs to Company {1}."
-				).format(frappe.bold(self.income_account), frappe.bold(self.company))
-			)
-
-		if account.disabled:
-			msg.append(
-				_("{0} is disabled. Please select a valid Income Account.").format(
-					frappe.bold(self.income_account)
-				)
-			)
-
-		if account.root_type != "Income":
-			msg.append(
-				_("{0} is not an Income Account. Please select a valid Income Account.").format(
-					frappe.bold(self.income_account)
-				)
-			)
-
-		if account.is_group:
-			msg.append(
-				_("{0} is a group account. Please select a non-group Income Account.").format(
-					frappe.bold(self.income_account)
-				)
-			)
-
-		if msg:
-			frappe.msgprint(
-				msg,
-				title=_("Income Account Validation Error"),
-				as_list=True,
-				raise_exception=frappe.ValidationError,
-			)
-
-	def validate_cost_center(self):
-		if not self.cost_center:
-			return
-
-		cost_center = frappe.get_cached_doc("Cost Center", self.cost_center)
-
-		msg = []
-		if cost_center.company != self.company:
-			msg.append(
-				_(
-					"{0} doesn't belong to Company {1}. Please select a Cost Center that belongs to Company {1}."
-				).format(frappe.bold(self.cost_center), frappe.bold(self.company))
-			)
-
-		if cost_center.disabled:
-			msg.append(
-				_("{0} is disabled. Please select an enabled Cost Center.").format(
-					frappe.bold(self.cost_center)
-				)
-			)
-
-		if cost_center.is_group:
-			msg.append(
-				_("{0} is a group Cost Center. Please select a non-group Cost Center.").format(
-					frappe.bold(self.cost_center)
-				)
-			)
-
-		if msg:
-			frappe.msgprint(
-				msg,
-				title=_("Cost Center Validation Error"),
-				as_list=True,
-				raise_exception=frappe.ValidationError,
-			)
-
-	def validate_languages(self):
-		languages = [d.language for d in self.dunning_letter_text]
-
-		if len(languages) == len(set(languages)):
-			return
-
-		frappe.throw(_("Duplicate languages found on Dunning Letter Text. Keep only one of them."))
-
-	def validate_is_default_language(self):
-		is_default_language_list = [
-			d.language for d in self.dunning_letter_text if d.is_default_language == 1
-		]
-
-		if len(is_default_language_list) <= 1:
-			return
-
-		frappe.throw(
-			_("{0} languages are marked as default languages. Please select only one of them.").format(
-				comma_and(is_default_language_list, add_quotes=True)
-			)
-		)
-
-	def validate_dunning_letter_text_templates(self):
-		for d in self.dunning_letter_text:
-			if d.body_text:
-				validate_template(d.body_text, restrict_globals=True)
-
-			if d.closing_text:
-				validate_template(d.closing_text, restrict_globals=True)
-
-	def set_default_dunning_type(self):
-		if self.is_default != 1:
-			return
-
-		frappe.db.set_value(
-			"Dunning Type",
-			{"company": self.company, "is_default": 1, "name": ["!=", self.name]},
-			"is_default",
-			0,
-		)

erpnext/accounts/doctype/dunning_type/test_dunning_type.py

@@ -1,200 +1,10 @@
 # Copyright (c) 2020, Frappe Technologies Pvt. Ltd. and Contributors
 # See license.txt
-
-import frappe
+# import frappe
+import unittest
 
 from erpnext.tests.utils import ERPNextTestSuite
 
 
-def make_dunning_type(dunning_type, company="_Test Company", **kwargs):
-	doc = frappe.new_doc("Dunning Type")
-	doc.dunning_type = dunning_type
-	doc.company = company
-	doc.dunning_fee = kwargs.get("dunning_fee", 100)
-	doc.rate_of_interest = kwargs.get("rate_of_interest", 5)
-	doc.is_default = kwargs.get("is_default", 0)
-
-	if "income_account" in kwargs:
-		doc.income_account = kwargs["income_account"]
-	elif kwargs.get("income_account") is not False:
-		doc.income_account = "Sales - _TC" if company == "_Test Company" else "Sales - _TC1"
-
-	if "cost_center" in kwargs:
-		doc.cost_center = kwargs["cost_center"]
-	elif kwargs.get("cost_center") is not False:
-		doc.cost_center = "Main - _TC" if company == "_Test Company" else "Main - _TC1"
-
-	for row in kwargs.get("dunning_letter_text", [{"language": "en", "body_text": "Test body"}]):
-		doc.append("dunning_letter_text", row)
-
-	return doc
-
-
 class TestDunningType(ERPNextTestSuite):
-	def test_income_account_must_belong_to_company(self):
-		doc = make_dunning_type("_Test Dunning Wrong Company Account", income_account="Sales - _TC1")
-		self.assertRaisesRegex(frappe.ValidationError, "doesn't belong to Company", doc.insert)
-
-	def test_income_account_must_not_be_disabled(self):
-		disabled_account = frappe.get_doc(
-			{
-				"doctype": "Account",
-				"account_name": "_Test Disabled Income Account",
-				"parent_account": "Direct Income - _TC",
-				"company": "_Test Company",
-				"account_type": "Income Account",
-				"disabled": 1,
-			}
-		).insert()
-
-		doc = make_dunning_type("_Test Dunning Disabled Account", income_account=disabled_account.name)
-		self.assertRaisesRegex(frappe.ValidationError, "is disabled", doc.insert)
-
-	def test_income_account_must_be_income_type(self):
-		doc = make_dunning_type("_Test Dunning Non Income Account", income_account="Debtors - _TC")
-		self.assertRaisesRegex(frappe.ValidationError, "is not an Income Account", doc.insert)
-
-	def test_income_account_must_not_be_group(self):
-		doc = make_dunning_type("_Test Dunning Group Account", income_account="Income - _TC")
-		self.assertRaisesRegex(frappe.ValidationError, "is a group account", doc.insert)
-
-	def test_income_account_is_optional(self):
-		doc = make_dunning_type("_Test Dunning No Income Account", income_account=False)
-		doc.insert()
-		self.assertFalse(doc.income_account)
-
-	def test_valid_income_account_passes(self):
-		doc = make_dunning_type("_Test Dunning Valid Income Account", income_account="Sales - _TC")
-		doc.insert()
-		self.assertEqual(doc.income_account, "Sales - _TC")
-
-	def test_cost_center_must_belong_to_company(self):
-		doc = make_dunning_type("_Test Dunning Wrong Company CC", cost_center="Main - _TC1")
-		self.assertRaisesRegex(frappe.ValidationError, "doesn't belong to Company", doc.insert)
-
-	def test_cost_center_must_not_be_disabled(self):
-		disabled_cc = frappe.get_doc(
-			{
-				"doctype": "Cost Center",
-				"cost_center_name": "_Test Disabled Cost Center",
-				"parent_cost_center": "_Test Company - _TC",
-				"company": "_Test Company",
-				"disabled": 1,
-			}
-		).insert()
-
-		doc = make_dunning_type("_Test Dunning Disabled CC", cost_center=disabled_cc.name)
-		self.assertRaisesRegex(frappe.ValidationError, "is disabled", doc.insert)
-
-	def test_cost_center_must_not_be_group(self):
-		doc = make_dunning_type("_Test Dunning Group CC", cost_center="_Test Company - _TC")
-		self.assertRaisesRegex(frappe.ValidationError, "is a group Cost Center", doc.insert)
-
-	def test_cost_center_is_optional(self):
-		doc = make_dunning_type("_Test Dunning No CC", cost_center=False)
-		doc.insert()
-		self.assertFalse(doc.cost_center)
-
-	def test_valid_cost_center_passes(self):
-		doc = make_dunning_type("_Test Dunning Valid CC", cost_center="Main - _TC")
-		doc.insert()
-		self.assertEqual(doc.cost_center, "Main - _TC")
-
-	def test_duplicate_languages_not_allowed(self):
-		doc = make_dunning_type(
-			"_Test Dunning Duplicate Language",
-			dunning_letter_text=[
-				{"language": "en", "body_text": "Body one"},
-				{"language": "en", "body_text": "Body two"},
-			],
-		)
-		self.assertRaisesRegex(frappe.ValidationError, "Duplicate languages found", doc.insert)
-
-	def test_unique_languages_allowed(self):
-		doc = make_dunning_type(
-			"_Test Dunning Unique Languages",
-			dunning_letter_text=[
-				{"language": "en", "body_text": "Body one"},
-				{"language": "de", "body_text": "Body two"},
-			],
-		)
-		doc.insert()
-		self.assertEqual(len(doc.dunning_letter_text), 2)
-
-	def test_only_one_default_language_allowed(self):
-		doc = make_dunning_type(
-			"_Test Dunning Multiple Default Language",
-			dunning_letter_text=[
-				{"language": "en", "body_text": "Body one", "is_default_language": 1},
-				{"language": "de", "body_text": "Body two", "is_default_language": 1},
-			],
-		)
-		self.assertRaisesRegex(
-			frappe.ValidationError, "languages are marked as default languages", doc.insert
-		)
-
-	def test_single_default_language_allowed(self):
-		doc = make_dunning_type(
-			"_Test Dunning Single Default Language",
-			dunning_letter_text=[
-				{"language": "en", "body_text": "Body one", "is_default_language": 1},
-				{"language": "de", "body_text": "Body two", "is_default_language": 0},
-			],
-		)
-		doc.insert()
-		self.assertEqual(doc.dunning_letter_text[0].is_default_language, 1)
-
-	def test_invalid_jinja_template_in_body_text_raises(self):
-		doc = make_dunning_type(
-			"_Test Dunning Invalid Body Template",
-			dunning_letter_text=[{"language": "en", "body_text": "{{ unclosed"}],
-		)
-		self.assertRaisesRegex(frappe.ValidationError, "Syntax error in template", doc.insert)
-
-	def test_invalid_jinja_template_in_closing_text_raises(self):
-		doc = make_dunning_type(
-			"_Test Dunning Invalid Closing Template",
-			dunning_letter_text=[
-				{"language": "en", "body_text": "Valid body", "closing_text": "{{ unclosed"}
-			],
-		)
-		self.assertRaisesRegex(frappe.ValidationError, "Syntax error in template", doc.insert)
-
-	def test_valid_jinja_template_passes(self):
-		doc = make_dunning_type(
-			"_Test Dunning Valid Template",
-			dunning_letter_text=[
-				{
-					"language": "en",
-					"body_text": "Outstanding amount is {{ outstanding_amount }}",
-					"closing_text": "Regards, {{ company }}",
-				}
-			],
-		)
-		doc.insert()
-		self.assertTrue(doc.name)
-
-	def test_set_default_dunning_type_unsets_previous_default(self):
-		first = make_dunning_type("_Test Dunning Default One", is_default=1)
-		first.insert()
-		self.assertEqual(frappe.db.get_value("Dunning Type", first.name, "is_default"), 1)
-
-		second = make_dunning_type("_Test Dunning Default Two", is_default=1)
-		second.insert()
-
-		self.assertEqual(frappe.db.get_value("Dunning Type", first.name, "is_default"), 0)
-		self.assertEqual(frappe.db.get_value("Dunning Type", second.name, "is_default"), 1)
-
-	def test_set_default_dunning_type_scoped_per_company(self):
-		company_1 = make_dunning_type("_Test Dunning Default Co1", is_default=1)
-		company_1.insert()
-
-		company_2 = make_dunning_type(
-			"_Test Dunning Default Co2",
-			company="_Test Company 1",
-			is_default=1,
-		)
-		company_2.insert()
-
-		self.assertEqual(frappe.db.get_value("Dunning Type", company_1.name, "is_default"), 1)
-		self.assertEqual(frappe.db.get_value("Dunning Type", company_2.name, "is_default"), 1)
+	pass

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js

@@ -22,27 +22,17 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 	refresh: function (frm) {
 		if (frm.doc.docstatus == 1) {
 			frappe.call({
-				method: "check_journal_and_reversal",
+				method: "check_journal_entry_condition",
 				doc: frm.doc,
 				callback: function (r) {
 					if (r.message) {
-						if (!r.message.journals_posted) {
-							frm.add_custom_button(
-								__("Journal Entries"),
-								function () {
-									return frm.events.make_jv(frm);
-								},
-								__("Create")
-							);
-						} else if (!r.message.reversals_posted) {
-							frm.add_custom_button(
-								__("Reversal Journal Entries"),
-								function () {
-									return frm.events.make_reverse_journal(frm);
-								},
-								__("Create")
-							);
-						}
+						frm.add_custom_button(
+							__("Journal Entries"),
+							function () {
+								return frm.events.make_jv(frm);
+							},
+							__("Create")
+						);
 					}
 				},
 			});
@@ -110,14 +100,6 @@ frappe.ui.form.on("Exchange Rate Revaluation", {
 			},
 		});
 	},
-	make_reverse_journal: function (frm) {
-		frappe.call({
-			method: "make_reverse_journal",
-			doc: frm.doc,
-			freeze: true,
-			freeze_message: __("Reversing Journals..."),
-		});
-	},
 });
 
 frappe.ui.form.on("Exchange Rate Revaluation Account", {

erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py

@@ -8,7 +8,7 @@ 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.utils import flt, get_link_to_form, nowdate
+from frappe.utils import flt, get_link_to_form
 
 import erpnext
 from erpnext.accounts.doctype.journal_entry.journal_entry import get_balance_on
@@ -90,31 +90,25 @@ class ExchangeRateRevaluation(Document):
 		)
 
 	def on_cancel(self):
-		self.ignore_linked_doctypes = ["GL Entry", "Payment Ledger Entry"]
+		self.ignore_linked_doctypes = "GL Entry"
 
 	@frappe.whitelist()
-	def check_journal_and_reversal(self):
+	def check_journal_entry_condition(self):
 		exchange_gain_loss_account = self.get_for_unrealized_gain_loss_account()
 
-		journals_posted = False
-		reversals_posted = False
-
-		je = qb.DocType("Journal Entry")
 		jea = qb.DocType("Journal Entry Account")
 		journals = (
-			qb.from_(je)
-			.join(jea)
-			.on(je.name == jea.parent)
-			.select(je.name)
+			qb.from_(jea)
+			.select(jea.parent)
 			.distinct()
 			.where(
 				(jea.reference_type == "Exchange Rate Revaluation")
 				& (jea.reference_name == self.name)
 				& (jea.docstatus == 1)
-				& (je.reversal_of.isnull())  # omit journals that have reversals
 			)
-			.run(pluck="name")
+			.run()
 		)
+
 		if journals:
 			gle = qb.DocType("GL Entry")
 			total_amt = (
@@ -129,31 +123,12 @@ class ExchangeRateRevaluation(Document):
 				.run()
 			)
 
-			if total_amt and total_amt[0][0] == self.total_gain_loss:
-				journals_posted = True
+			if total_amt and total_amt[0][0] != self.total_gain_loss:
+				return True
 			else:
-				journals_posted = False
+				return False
 
-		# reverse journals
-		reverse_journals = (
-			qb.from_(je)
-			.join(jea)
-			.on(je.name == jea.parent)
-			.select(je.name)
-			.where(
-				(jea.reference_type == "Exchange Rate Revaluation")
-				& (jea.reference_name == self.name)
-				& (jea.docstatus == 1)
-				& (je.reversal_of.notnull())
-			)
-			.run(pluck="name")
-		)
-		if reverse_journals:
-			reversals_posted = True
-		else:
-			reversals_posted = False
-
-		return {"journals_posted": journals_posted, "reversals_posted": reversals_posted}
+		return True
 
 	def fetch_and_calculate_accounts_data(self):
 		accounts = self.get_accounts_data()
@@ -367,7 +342,6 @@ class ExchangeRateRevaluation(Document):
 
 	@frappe.whitelist()
 	def make_jv_entries(self):
-		frappe.has_permission("Journal Entry", "write", throw=True)
 		zero_balance_jv = self.make_jv_for_zero_balance()
 		if zero_balance_jv:
 			frappe.msgprint(
@@ -594,50 +568,6 @@ class ExchangeRateRevaluation(Document):
 		journal_entry.save()
 		return journal_entry
 
-	@frappe.whitelist()
-	def make_reverse_journal(self):
-		frappe.has_permission("Journal Entry", "write", throw=True)
-		je = qb.DocType("Journal Entry")
-		jea = qb.DocType("Journal Entry Account")
-		journals = (
-			qb.from_(je)
-			.join(jea)
-			.on(je.name == jea.parent)
-			.select(je.name)
-			.distinct()
-			.where(
-				(jea.reference_type == "Exchange Rate Revaluation")
-				& (jea.reference_name == self.name)
-				& (jea.docstatus == 1)
-				& (je.reversal_of.isnull())  # omit journals that have reversals
-			)
-			.run(pluck="name")
-		)
-		if journals:
-			from erpnext.accounts.doctype.journal_entry.journal_entry import make_reverse_journal_entry
-
-			if drafts := frappe.db.get_all(
-				"Journal Entry",
-				filters={"docstatus": 0, "reversal_of": ["in", journals]},
-				pluck="name",
-				as_list=1,
-			):
-				part = "journals are" if len(drafts) > 1 else "journal is"
-				doc_links = ", ".join(["{}".format(get_link_to_form("Journal Entry", x)) for x in drafts])
-				frappe.throw(
-					msg=_("Reverse {0} already available in draft status: {1}").format(part, doc_links),
-				)
-			else:
-				for x in journals:
-					reversal = make_reverse_journal_entry(x)
-					reversal.posting_date = nowdate()
-					reversal.save()
-					frappe.msgprint(
-						_("A draft reverse journal for {0} has been created: {1}").format(
-							frappe.bold(x), get_link_to_form("Journal Entry", reversal.name)
-						)
-					)
-
 
 def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 	"""
@@ -686,10 +616,6 @@ def calculate_exchange_rate_using_last_gle(company, account, party_type, party):
 def get_account_details(
 	company, posting_date, account, party_type=None, party=None, rounding_loss_allowance: float | None = None
 ):
-	if not account:
-		return
-	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

@@ -9,19 +9,28 @@ from frappe.utils import add_days, flt, today
 
 from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
+from erpnext.accounts.test.accounts_mixin import AccountsTestMixin
 from erpnext.tests.utils import ERPNextTestSuite
 
 
-class TestExchangeRateRevaluation(ERPNextTestSuite):
+class TestExchangeRateRevaluation(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		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.create_company()
+		self.create_usd_receivable_account()
+		self.create_item()
+		self.create_customer()
+		self.clear_old_entries()
 		self.set_system_and_company_settings()
 
 	def set_system_and_company_settings(self):
+		# set number and currency precision
+		system_settings = frappe.get_doc("System Settings")
+		system_settings.float_precision = 2
+		system_settings.currency_precision = 2
+		system_settings.language = "en"
+		system_settings.time_zone = "Asia/Kolkata"
+		system_settings.save()
+
 		# Using Exchange Gain/Loss account for unrealized as well.
 		company_doc = frappe.get_doc("Company", self.company)
 		company_doc.unrealized_exchange_gain_loss_account = company_doc.exchange_gain_loss_account
@@ -123,8 +132,7 @@ class TestExchangeRateRevaluation(ERPNextTestSuite):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		ret = err.check_journal_and_reversal()
-		self.assertFalse(ret.get("journals_posted"))
+		self.assertTrue(err.check_journal_entry_condition())
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()
@@ -213,8 +221,7 @@ class TestExchangeRateRevaluation(ERPNextTestSuite):
 		err = err.save().submit()
 
 		# Create JV for ERR
-		ret = err.check_journal_and_reversal()
-		self.assertFalse(ret.get("journals_posted"))
+		self.assertTrue(err.check_journal_entry_condition())
 		err_journals = err.make_jv_entries()
 		je = frappe.get_doc("Journal Entry", err_journals.get("zero_balance_jv"))
 		je = je.submit()
@@ -291,97 +298,3 @@ class TestExchangeRateRevaluation(ERPNextTestSuite):
 
 		for key, _val in expected_data.items():
 			self.assertEqual(expected_data.get(key), account_details.get(key))
-
-	@ERPNextTestSuite.change_settings(
-		"Accounts Settings",
-		{"allow_multi_currency_invoices_against_single_party_account": 1, "allow_stale": 0},
-	)
-	def test_05_revaluation_journal_reversal(self):
-		"""
-		Test reversing of revaluation journals
-		"""
-		si = create_sales_invoice(
-			item=self.item,
-			company=self.company,
-			customer="_Test Customer 1",
-			debit_to=self.debtors_usd,
-			posting_date=today(),
-			parent_cost_center=self.cost_center,
-			cost_center=self.cost_center,
-			rate=100,
-			price_list_rate=100,
-			do_not_submit=1,
-		)
-		si.currency = "USD"
-		si.conversion_rate = 80
-		si.save().submit()
-
-		err = frappe.new_doc("Exchange Rate Revaluation")
-		err.company = self.company
-		err.posting_date = today()
-		err.fetch_and_calculate_accounts_data()
-		self.assertEqual(len(err.accounts), 1)
-		err.save().submit()
-
-		gain_loss_account = err.get_for_unrealized_gain_loss_account()
-		usd_account = err.accounts[0].account
-		old_balance = err.accounts[0].balance_in_base_currency
-		new_balance = err.accounts[0].new_balance_in_base_currency
-		total_gain_loss = err.total_gain_loss
-
-		# Create JV for ERR
-		ret = err.check_journal_and_reversal()
-		self.assertFalse(ret.get("journals_posted"))
-		err_journals = err.make_jv_entries()
-		je = frappe.get_doc("Journal Entry", err_journals.get("revaluation_jv"))
-		je = je.submit()
-
-		je.reload()
-		self.assertEqual(je.voucher_type, "Exchange Rate Revaluation")
-		self.assertEqual(len(je.accounts), 3)
-		# A gain is credited to the gain/loss account, a loss is debited. The current
-		# exchange rate (from master data) may sit either side of the booked rate, so
-		# derive the column from the sign instead of assuming a gain.
-		gain_loss_debit = abs(total_gain_loss) if total_gain_loss < 0 else 0.0
-		gain_loss_credit = total_gain_loss if total_gain_loss > 0 else 0.0
-		expected = [
-			(usd_account, new_balance, 0.0, 100.0, 0.0),
-			(usd_account, 0.0, old_balance, 0.0, 100.0),
-			(gain_loss_account, gain_loss_debit, gain_loss_credit, gain_loss_debit, gain_loss_credit),
-		]
-		actual = []
-		for acc in je.accounts:
-			actual.append(
-				(
-					acc.account,
-					acc.debit,
-					acc.credit,
-					acc.debit_in_account_currency,
-					acc.credit_in_account_currency,
-				)
-			)
-		self.assertEqual(expected, actual)
-
-		# Assert reversals are not posted
-		ret = err.check_journal_and_reversal()
-		self.assertTrue(ret.get("journals_posted"))
-		self.assertFalse(ret.get("reversals_posted"))
-
-		err.make_reverse_journal()
-		# submit
-		draft = frappe.db.get_all(
-			"Journal Entry",
-			filters={"docstatus": 0, "reversal_of": je.name, "voucher_type": "Exchange Rate Revaluation"},
-			pluck="name",
-			as_list=1,
-		)
-		self.assertIsNotNone(draft)
-		frappe.get_doc("Journal Entry", draft[0]).submit()
-		ret = err.check_journal_and_reversal()
-		self.assertTrue(ret.get("journals_posted"))
-		self.assertTrue(ret.get("reversals_posted"))
-
-		reverse_jv = frappe.db.get_all(
-			"Journal Entry", filters={"reversal_of": err_journals.get("revaluation_jv")}, pluck="name"
-		)
-		self.assertIsNotNone(reverse_jv)

erpnext/accounts/doctype/financial_report_template/financial_report_engine.py

@@ -1853,51 +1853,28 @@ class GrowthViewTransformer:
 		self.formatted_rows = context.raw_data.get("formatted_data", [])
 		self.period_list = context.period_list
 
-	def transform(self):
+	def transform(self) -> None:
 		for row_data in self.formatted_rows:
 			if row_data.get("is_blank_line"):
 				continue
 
-			if row_data.get("segment_values"):
-				self._transform_segmented_row(row_data)
-			else:
-				self._transform_single_row(row_data)
+			transformed_values = {}
+			for i in range(len(self.period_list)):
+				current_period = self.period_list[i]["key"]
 
-	def _compute_growth_values(self, source: dict) -> dict:
-		transformed = {}
+				current_value = row_data[current_period]
+				previous_value = row_data[self.period_list[i - 1]["key"]] if i != 0 else 0
 
-		for i, period in enumerate(self.period_list):
-			current_period = period["key"]
-			current_value = source.get(current_period)
+				if i == 0:
+					transformed_values[current_period] = current_value
+				else:
+					growth_percent = self._calculate_growth(previous_value, current_value)
+					transformed_values[current_period] = growth_percent
 
-			if current_value in (None, ""):
-				continue
-
-			if i == 0:
-				transformed[current_period] = current_value
-			else:
-				previous_period = self.period_list[i - 1]["key"]
-				previous_value = source.get(previous_period) or 0
-				transformed[current_period] = self._calculate_growth(previous_value, current_value)
-
-		return transformed
-
-	def _transform_single_row(self, row_data: dict):
-		row_data.update(self._compute_growth_values(row_data))
-
-	def _transform_segmented_row(self, row_data: dict):
-		for seg_id, seg_data in row_data.get("segment_values", {}).items():
-			if seg_data.get("is_blank_line"):
-				continue
-
-			transformed = self._compute_growth_values(seg_data)
-			seg_data.update(transformed)
-
-			for period_key, value in transformed.items():
-				row_data[f"{seg_id}_{period_key}"] = value
+			row_data.update(transformed_values)
 
 	def _calculate_growth(self, previous_value: float, current_value: float) -> float | None:
-		if current_value in (None, ""):
+		if current_value is None:
 			return None
 
 		if previous_value == 0 and current_value > 0:

erpnext/accounts/doctype/journal_entry/journal_entry.js

@@ -71,7 +71,7 @@ frappe.ui.form.on("Journal Entry", {
 
 	refresh: function (frm) {
 		if (frm.doc.reversal_of && (frm.is_new() || frm.doc.docstatus == 0)) {
-			erpnext.journal_entry.lock_reversal_entry(frm);
+			frm.set_read_only();
 		}
 
 		erpnext.toggle_naming_series();
@@ -564,14 +564,6 @@ $.extend(erpnext.journal_entry, {
 		});
 	},
 
-	lock_reversal_entry: function (frm) {
-		frm.fields
-			.filter((field) => field.has_input)
-			.filter((field) => !["posting_date", "custom_remark", "remark"].includes(field.df.fieldname))
-			.forEach((field) => frm.set_df_property(field.df.fieldname, "read_only", 1));
-		frm.set_df_property("accounts", "read_only", 1);
-	},
-
 	set_debit_credit_in_company_currency: function (frm, cdt, cdn) {
 		var row = locals[cdt][cdn];
 

erpnext/accounts/doctype/journal_entry/journal_entry.py

@@ -19,7 +19,6 @@ from erpnext.accounts.doctype.repost_accounting_ledger.repost_accounting_ledger
 	validate_docs_for_voucher_types,
 )
 from erpnext.accounts.doctype.tax_withholding_entry.tax_withholding_entry import JournalTaxWithholding
-from erpnext.accounts.general_ledger import validate_opening_entry_against_pcv
 from erpnext.accounts.party import get_party_account
 from erpnext.accounts.utils import (
 	cancel_exchange_gain_loss_journal,
@@ -132,9 +131,6 @@ class JournalEntry(AccountsController):
 		if not self.is_opening:
 			self.is_opening = "No"
 
-		if self.is_opening == "Yes":
-			validate_opening_entry_against_pcv(self.company)
-
 		self.clearance_date = None
 
 		self.validate_party()
@@ -417,12 +413,11 @@ class JournalEntry(AccountsController):
 
 	def update_journal_entry_link_on_depr_schedule(self, asset, je_row):
 		depr_schedule = get_depr_schedule(asset.name, "Active", self.finance_book)
-		precision = je_row.precision("debit")
 		for d in depr_schedule or []:
 			if (
 				d.schedule_date == self.posting_date
 				and not d.journal_entry
-				and flt(d.depreciation_amount, precision) == flt(je_row.debit, precision)
+				and d.depreciation_amount == flt(je_row.debit)
 			):
 				frappe.db.set_value("Depreciation Schedule", d.name, "journal_entry", self.name)
 

erpnext/accounts/doctype/journal_entry/journal_entry_list.js

@@ -1,10 +1,7 @@
 frappe.listview_settings["Journal Entry"] = {
-	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "remark", "reversal_of"],
+	add_fields: ["voucher_type", "posting_date", "total_debit", "company", "remark"],
 	get_indicator: function (doc) {
 		if (doc.docstatus === 1) {
-			if (doc.reversal_of && doc.voucher_type == "Exchange Rate Revaluation") {
-				return [__("Reversal Of Exchange Rate Revaluation"), "blue"];
-			}
 			return [__(doc.voucher_type), "blue", `voucher_type,=,${doc.voucher_type}`];
 		}
 	},

erpnext/accounts/doctype/ledger_health/test_ledger_health.py

@@ -12,11 +12,10 @@ from erpnext.tests.utils import ERPNextTestSuite
 
 class TestLedgerHealth(ERPNextTestSuite, AccountsTestMixin):
 	def setUp(self):
-		self.company = "_Test Company"
-		self.customer = "_Test Customer"
-		self.debit_to = "Debtors - _TC"
-		self.income_account = "Sales - _TC"
+		self.create_company()
+		self.create_customer()
 		self.configure_monitoring_tool()
+		self.clear_old_entries()
 
 	def configure_monitoring_tool(self):
 		monitor_settings = frappe.get_doc("Ledger Health Monitor")

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js

@@ -24,22 +24,15 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 				setTimeout(
 					() => {
 						frm.doc.import_in_progress = false;
+						frm.clear_table("invoices");
+						frm.refresh_fields();
 						frm.page.clear_indicator();
 						frm.dashboard.hide_progress();
 
-						if (!data.errors) {
-							frm.clear_table("invoices");
-							frm.refresh_fields();
-							const message =
-								frm.doc.invoice_type == "Sales"
-									? __("Opening Sales Invoice(s) have been created.")
-									: __("Opening Purchase Invoice(s) have been created.");
-							frappe.show_alert({
-								message: message,
-								indicator: "green",
-							});
+						if (frm.doc.invoice_type == "Sales") {
+							frappe.msgprint(__("Opening Sales Invoices have been created."));
 						} else {
-							frm.refresh_fields();
+							frappe.msgprint(__("Opening Purchase Invoices have been created."));
 						}
 					},
 					1500,
@@ -81,31 +74,29 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	setup_company_filters: function (frm) {
-		frm.events.apply_company_query_filter(frm, "cost_center", "invoices", { is_group: 0 });
-		frm.events.apply_company_query_filter(frm, "project", "invoices");
-		frm.events.apply_company_query_filter(frm, "project");
-		frm.events.apply_company_query_filter(frm, "cost_center", undefined, { is_group: 0 });
-		frm.events.apply_company_query_filter(frm, "temporary_opening_account", "invoices", {
-			account_type: "Temporary",
-			is_group: 0,
-		});
-	},
-
-	apply_company_query_filter: function (frm, field_name, child_doctype = null, filters = {}) {
-		const query = function (doc) {
+		frm.set_query("cost_center", "invoices", function (doc, cdt, cdn) {
 			return {
 				filters: {
 					company: doc.company,
-					...filters,
 				},
 			};
-		};
+		});
 
-		if (child_doctype) {
-			frm.set_query(field_name, child_doctype, query);
-		} else {
-			frm.set_query(field_name, query);
-		}
+		frm.set_query("cost_center", function (doc) {
+			return {
+				filters: {
+					company: doc.company,
+				},
+			};
+		});
+
+		frm.set_query("temporary_opening_account", "invoices", function (doc, cdt, cdn) {
+			return {
+				filters: {
+					company: doc.company,
+				},
+			};
+		});
 	},
 
 	company: function (frm) {
@@ -129,6 +120,11 @@ frappe.ui.form.on("Opening Invoice Creation Tool", {
 	},
 
 	invoice_type: function (frm) {
+		$.each(frm.doc.invoices, (idx, row) => {
+			row.party_type = frm.doc.invoice_type == "Sales" ? "Customer" : "Supplier";
+			frappe.model.set_value(row.doctype, row.name, "party", "");
+			frappe.model.set_value(row.doctype, row.name, "party_name", "");
+		});
 		frm.clear_table("invoices");
 		frm.refresh_fields();
 		frm.trigger("update_party_labels");
@@ -223,19 +219,7 @@ frappe.ui.form.on("Opening Invoice Creation Tool Item", {
 		});
 	},
 
-	invoices_add: (frm, cdt, cdn) => {
-		const row = frappe.get_doc(cdt, cdn);
-		const field_copy = [];
-
-		["project", "cost_center"].forEach((fieldname) => {
-			if (frm.doc[fieldname]) {
-				frappe.model.set_value(cdt, cdn, fieldname, frm.doc[fieldname]);
-			} else {
-				field_copy.push(fieldname);
-			}
-		});
-
-		frm.script_manager.copy_from_first_row("invoices", row, field_copy);
+	invoices_add: (frm) => {
 		frm.trigger("update_invoice_table");
 	},
 });

erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py

@@ -133,17 +133,6 @@ class OpeningInvoiceCreationTool(Document):
 			if not row.get(scrub(d)):
 				frappe.throw(mandatory_error_msg.format(row.idx, d, self.invoice_type))
 
-		self.validate_temporary_opening_account(row)
-
-	def validate_temporary_opening_account(self, row):
-		account_type = frappe.get_cached_value("Account", row.temporary_opening_account, "account_type")
-		if account_type != "Temporary":
-			frappe.throw(
-				_("Row #{0}: {1} account is not of type {2}").format(
-					row.idx, row.temporary_opening_account, "Temporary"
-				)
-			)
-
 	def get_invoices(self):
 		invoices = []
 		for row in self.invoices:
@@ -214,7 +203,6 @@ class OpeningInvoiceCreationTool(Document):
 					"description": row.item_name or "Opening Invoice Item",
 					income_expense_account_field: row.temporary_opening_account,
 					"cost_center": cost_center,
-					"project": row.get("project") or self.get("project"),
 				}
 			)
 
@@ -281,20 +269,12 @@ class OpeningInvoiceCreationTool(Document):
 def start_import(invoices):
 	errors = 0
 	names = []
-	total = len(invoices)
 	for idx, d in enumerate(invoices):
-		# Scope each invoice to a savepoint so a failure only undoes that invoice.
-		# A plain rollback() would discard the whole transaction — including invoices
-		# imported earlier in this batch and the error logs of earlier failures (the
-		# latter only survive on mariadb because the Error Log table is MyISAM; on
-		# postgres they would be lost). Rolling back to a savepoint keeps both.
-		savepoint = f"opening_invoice_{frappe.generate_hash(length=8)}"
-		frappe.db.savepoint(savepoint)
-		is_last = idx == total - 1
 		try:
 			invoice_number = None
 			if d.invoice_number:
 				invoice_number = d.invoice_number
+			publish(idx, len(invoices), d.doctype)
 			doc = frappe.get_doc(d)
 			doc.flags.ignore_mandatory = True
 			doc.insert(set_name=invoice_number)
@@ -302,12 +282,10 @@ def start_import(invoices):
 			if not frappe.in_test:
 				frappe.db.commit()
 			names.append(doc.name)
-			publish(idx, total, d.doctype, errors=errors if is_last else None)
 		except Exception:
 			errors += 1
 			frappe.db.rollback()
 			doc.log_error("Opening invoice creation failed")
-			publish(idx, total, d.doctype, errors=errors if is_last else None)
 	if errors:
 		frappe.msgprint(
 			_("You had {} errors while creating opening invoices. Check {} for more details").format(
@@ -319,7 +297,7 @@ def start_import(invoices):
 	return names
 
 
-def publish(index, total, doctype, errors=None):
+def publish(index, total, doctype):
 	frappe.publish_realtime(
 		"opening_invoice_creation_progress",
 		dict(
@@ -327,7 +305,6 @@ def publish(index, total, doctype, errors=None):
 			message=_("Creating {} out of {} {}").format(index + 1, total, doctype),
 			count=index + 1,
 			total=total,
-			errors=errors,
 		),
 		user=frappe.session.user,
 	)

erpnext/accounts/doctype/opening_invoice_creation_tool/test_opening_invoice_creation_tool.py

@@ -2,12 +2,10 @@
 # See license.txt
 
 import frappe
-from frappe.utils import add_days, today
 
 from erpnext.accounts.doctype.opening_invoice_creation_tool.opening_invoice_creation_tool import (
 	get_temporary_opening_account,
 )
-from erpnext.projects.doctype.project.test_project import make_project
 from erpnext.tests.utils import ERPNextTestSuite
 
 
@@ -16,26 +14,21 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self,
 		invoice_type="Sales",
 		company=None,
-		invoices=None,
-		project=None,
-		cost_center=None,
+		party_1=None,
+		party_2=None,
+		invoice_number=None,
 		department=None,
-		return_doc=False,
 	):
 		doc = frappe.get_single("Opening Invoice Creation Tool")
 		args = get_opening_invoice_creation_dict(
 			invoice_type=invoice_type,
 			company=company,
-			invoices=invoices,
-			project=project,
-			cost_center=cost_center,
+			party_1=party_1,
+			party_2=party_2,
+			invoice_number=invoice_number,
 			department=department,
 		)
 		doc.update(args)
-
-		if return_doc:
-			return doc
-
 		return doc.make_invoices()
 
 	def test_opening_sales_invoice_creation(self):
@@ -44,8 +37,8 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["customer", "outstanding_amount", "status"],
-			0: ["_Test Customer", 200, "Overdue"],
-			1: ["_Test Customer 1", 200, "Overdue"],
+			0: ["_Test Customer", 300, "Overdue"],
+			1: ["_Test Customer 1", 250, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value)
 
@@ -62,34 +55,48 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 			for field_idx, field in enumerate(expected_value["keys"]):
 				self.assertEqual(si.get(field, ""), expected_value[invoice_idx][field_idx])
 
-	def test_opening_invoice_requires_temporary_account_type(self):
-		doc = self.make_invoices(company="_Test Opening Invoice Company", return_doc=True)
-		doc.invoices[0].temporary_opening_account = "Sales - _TOIC"
-		self.assertRaises(frappe.ValidationError, doc.make_invoices)
-
 	def test_opening_purchase_invoice_creation(self):
 		invoices = self.make_invoices(invoice_type="Purchase", company="_Test Opening Invoice Company")
 
 		self.assertEqual(len(invoices), 2)
 		expected_value = {
 			"keys": ["supplier", "outstanding_amount", "status"],
-			0: ["_Test Supplier", 200, "Overdue"],
-			1: ["_Test Supplier 1", 200, "Overdue"],
+			0: ["_Test Supplier", 300, "Overdue"],
+			1: ["_Test Supplier 1", 250, "Overdue"],
 		}
 		self.check_expected_values(invoices, expected_value, "Purchase")
 
 	def test_opening_sales_invoice_creation_with_missing_debit_account(self):
+		company = "_Test Opening Invoice Company"
 		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
 
-		old_default_receivable_account = frappe.db.get_value(
-			"Company", "_Test Opening Invoice Company", "default_receivable_account"
-		)
-		frappe.db.set_value("Company", "_Test Opening Invoice Company", "default_receivable_account", "")
+		old_default_receivable_account = frappe.db.get_value("Company", company, "default_receivable_account")
+		frappe.db.set_value("Company", company, "default_receivable_account", "")
 
-		self.make_invoices(
-			company="_Test Opening Invoice Company",
-			invoices=[{"party": party_1}, {"party": party_2}],
-		)
+		if not frappe.db.exists("Cost Center", "_Test Opening Invoice Company - _TOIC"):
+			cc = frappe.get_doc(
+				{
+					"doctype": "Cost Center",
+					"cost_center_name": "_Test Opening Invoice Company",
+					"is_group": 1,
+					"company": "_Test Opening Invoice Company",
+				}
+			)
+			cc.insert(ignore_mandatory=True)
+			cc2 = frappe.get_doc(
+				{
+					"doctype": "Cost Center",
+					"cost_center_name": "Main",
+					"is_group": 0,
+					"company": "_Test Opening Invoice Company",
+					"parent_cost_center": cc.name,
+				}
+			)
+			cc2.insert()
+
+		frappe.db.set_value("Company", company, "cost_center", "Main - _TOIC")
+
+		self.make_invoices(company="_Test Opening Invoice Company", party_1=party_1, party_2=party_2)
 
 		# Check if missing debit account error raised
 		error_log = frappe.db.exists(
@@ -99,107 +106,71 @@ class TestOpeningInvoiceCreationTool(ERPNextTestSuite):
 		self.assertTrue(error_log)
 
 		# teardown
-		frappe.db.set_value(
-			"Company",
-			"_Test Opening Invoice Company",
-			"default_receivable_account",
-			old_default_receivable_account,
-		)
+		frappe.db.set_value("Company", company, "default_receivable_account", old_default_receivable_account)
 
 	def test_renaming_of_invoice_using_invoice_number_field(self):
+		company = "_Test Opening Invoice Company"
 		party_1, party_2 = make_customer("Customer A"), make_customer("Customer B")
-		invoices = self.make_invoices(
-			company="_Test Opening Invoice Company",
-			invoices=[
-				{"party": party_1, "invoice_number": "TEST-NEW-INV-11"},
-				{"party": party_2},
-			],
+		self.make_invoices(
+			company=company, party_1=party_1, party_2=party_2, invoice_number="TEST-NEW-INV-11"
 		)
 
-		self.assertEqual(invoices[0], "TEST-NEW-INV-11")
+		sales_inv1 = frappe.get_all("Sales Invoice", filters={"customer": "Customer A"})[0].get("name")
+		sales_inv2 = frappe.get_all("Sales Invoice", filters={"customer": "Customer B"})[0].get("name")
+		self.assertEqual(sales_inv1, "TEST-NEW-INV-11")
+
+		# teardown
+		for inv in [sales_inv1, sales_inv2]:
+			doc = frappe.get_doc("Sales Invoice", inv)
+			doc.cancel()
 
 	def test_opening_invoice_with_accounting_dimension(self):
 		invoices = self.make_invoices(
 			invoice_type="Sales", company="_Test Opening Invoice Company", department="Sales - _TOIC"
 		)
 
-		for invoice in invoices:
-			self.assertEqual(frappe.db.get_value("Sales Invoice", invoice, "department"), "Sales - _TOIC")
-
-	def test_opening_entry_project_linking(self):
-		doc = self.make_invoices(
-			company="_Test Opening Invoice Company", invoice_type="Sales", return_doc=True
-		)
-		project_1 = make_project(
-			{"project_name": "Test Opening Invoice projecty 01", "company": "_Test Opening Invoice Company"}
-		)
-		project_2 = make_project(
-			{"project_name": "Test Opening Invoice projecty 02", "company": "_Test Opening Invoice Company"}
-		)
-		doc.invoices[0].project = project_1.name
-		doc.invoices[1].project = project_2.name
-		invoices = doc.make_invoices()
-		sales_invoice_1 = frappe.get_doc("Sales Invoice", invoices[0])
-		sales_invoice_2 = frappe.get_doc("Sales Invoice", invoices[1])
-
-		self.assertEqual(sales_invoice_1.items[0].project, project_1.name)
-		self.assertEqual(sales_invoice_2.items[0].project, project_2.name)
+		expected_value = {
+			"keys": ["customer", "outstanding_amount", "status", "department"],
+			0: ["_Test Customer", 300, "Overdue", "Sales - _TOIC"],
+			1: ["_Test Customer 1", 250, "Overdue", "Sales - _TOIC"],
+		}
+		self.check_expected_values(invoices, expected_value, invoice_type="Sales")
 
 
 def get_opening_invoice_creation_dict(**args):
 	party = "Customer" if args.get("invoice_type", "Sales") == "Sales" else "Supplier"
 	company = args.get("company", "_Test Company")
-	default_invoices = []
-	default_invoice_rows = [
-		{
-			"qty": 1.0,
-			"outstanding_amount": 200,
-			"party": f"_Test {party}",
-			"item_name": "Opening Item",
-			"due_date": add_days(today(), -10),
-			"posting_date": add_days(today(), -15),
-			"temporary_opening_account": get_temporary_opening_account(company),
-		},
-		{
-			"qty": 1.0,
-			"outstanding_amount": 200,
-			"party": f"_Test {party} 1",
-			"item_name": "Opening Item",
-			"due_date": add_days(today(), -10),
-			"posting_date": add_days(today(), -15),
-			"temporary_opening_account": get_temporary_opening_account(company),
-		},
-	]
-
-	for row in args.get("invoices") or default_invoice_rows:
-		default_invoices.append(
-			{
-				"qty": row.get("qty") or 1.0,
-				"outstanding_amount": row.get("outstanding_amount") or 200,
-				"party": row.get("party") or f"_Test {party}",
-				"item_name": row.get("item_name") or "Opening Item",
-				"due_date": row.get("due_date") or add_days(today(), -10),
-				"posting_date": row.get("posting_date") or add_days(today(), -15),
-				"temporary_opening_account": row.get("temporary_opening_account")
-				or get_temporary_opening_account(company),
-				"invoice_number": row.get("invoice_number"),
-				"project": row.get("project"),
-				"cost_center": row.get("cost_center"),
-			}
-		)
 
 	invoice_dict = frappe._dict(
 		{
 			"company": company,
 			"invoice_type": args.get("invoice_type", "Sales"),
-			"project": args.get("project"),
-			"cost_center": args.get("cost_center"),
-			"invoices": default_invoices,
+			"invoices": [
+				{
+					"qty": 1.0,
+					"outstanding_amount": 300,
+					"party": args.get("party_1") or f"_Test {party}",
+					"item_name": "Opening Item",
+					"due_date": "2016-09-10",
+					"posting_date": "2016-09-05",
+					"temporary_opening_account": get_temporary_opening_account(company),
+					"invoice_number": args.get("invoice_number"),
+				},
+				{
+					"qty": 2.0,
+					"outstanding_amount": 250,
+					"party": args.get("party_2") or f"_Test {party} 1",
+					"item_name": "Opening Item",
+					"due_date": "2016-09-10",
+					"posting_date": "2016-09-05",
+					"temporary_opening_account": get_temporary_opening_account(company),
+					"invoice_number": None,
+				},
+			],
 		}
 	)
 
 	invoice_dict.update(args)
-	invoice_dict.invoices = default_invoices
 	return invoice_dict
 
 

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.json

@@ -21,8 +21,7 @@
   "qty",
   "accounting_dimensions_section",
   "cost_center",
-  "dimension_col_break",
-  "project"
+  "dimension_col_break"
  ],
  "fields": [
   {
@@ -82,7 +81,6 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Outstanding Amount",
-   "options": "Company:company:default_currency",
    "reqd": 1
   },
   {
@@ -127,17 +125,11 @@
    "fieldtype": "Data",
    "in_list_view": 1,
    "label": "Party Name"
-  },
-  {
-   "fieldname": "project",
-   "fieldtype": "Link",
-   "label": "Project",
-   "options": "Project"
   }
  ],
  "istable": 1,
  "links": [],
- "modified": "2026-07-02 15:17:11.938499",
+ "modified": "2026-03-20 02:11:42.023575",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Opening Invoice Creation Tool Item",

erpnext/accounts/doctype/opening_invoice_creation_tool_item/opening_invoice_creation_tool_item.py

@@ -26,7 +26,6 @@ class OpeningInvoiceCreationToolItem(Document):
 		party_name: DF.Data | None
 		party_type: DF.Link | None
 		posting_date: DF.Date | None
-		project: DF.Link | None
 		qty: DF.Data | None
 		supplier_invoice_date: DF.Date | None
 		temporary_opening_account: DF.Link | None

erpnext/accounts/doctype/party_account/party_account.json

@@ -29,7 +29,6 @@
   {
    "fieldname": "advance_account",
    "fieldtype": "Link",
-   "in_list_view": 1,
    "label": "Advance Account",
    "options": "Account"
   }
@@ -37,15 +36,14 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2026-05-27 14:19:00.888437",
+ "modified": "2024-03-27 13:10:08.489183",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Party Account",
  "owner": "Administrator",
  "permissions": [],
  "quick_entry": 1,
- "row_format": "Dynamic",
  "sort_field": "creation",
  "sort_order": "DESC",
  "states": []
-}
+}

erpnext/accounts/doctype/payment_entry/payment_entry.js

@@ -754,21 +754,17 @@ frappe.ui.form.on("Payment Entry", {
 		frm.set_paid_amount_based_on_received_amount = true;
 		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 
-		if (frm.doc.paid_amount && frm.doc.source_exchange_rate) {
-			frm.set_value("base_paid_amount", flt(frm.doc.paid_amount) * flt(frm.doc.source_exchange_rate));
-			frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+		if (frm.doc.base_received_amount && frm.doc.source_exchange_rate) {
+			frm.set_value("base_paid_amount", frm.doc.base_received_amount);
 
 			// target exchange rate should always be same as source if both account currencies is same
 			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
 				frm.set_value("target_exchange_rate", frm.doc.source_exchange_rate);
-				frm.set_value("received_amount", frm.doc.paid_amount);
 			} else {
-				const target_rate =
-					flt(frm.doc.target_exchange_rate) ||
-					(company_currency == frm.doc.paid_to_account_currency ? 1 : 0);
-				if (target_rate) {
-					frm.set_value("received_amount", flt(frm.doc.base_received_amount) / target_rate);
-				}
+				frm.set_value(
+					"paid_amount",
+					flt(frm.doc.base_paid_amount) / flt(frm.doc.source_exchange_rate)
+				);
 			}
 
 			// set_unallocated_amount is called by below method,
@@ -784,23 +780,18 @@ frappe.ui.form.on("Payment Entry", {
 	target_exchange_rate: function (frm) {
 		let company_currency = frappe.get_doc(":Company", frm.doc.company).default_currency;
 
-		if (frm.doc.received_amount && frm.doc.target_exchange_rate) {
-			frm.set_value(
-				"base_received_amount",
-				flt(frm.doc.received_amount) * flt(frm.doc.target_exchange_rate)
-			);
-			frm.set_value("base_paid_amount", frm.doc.base_received_amount);
-
-			if (frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency) {
+		if (frm.doc.base_paid_amount && frm.doc.target_exchange_rate) {
+			frm.set_value("base_received_amount", frm.doc.base_paid_amount);
+			if (
+				!frm.doc.source_exchange_rate &&
+				frm.doc.paid_from_account_currency == frm.doc.paid_to_account_currency
+			) {
 				frm.set_value("source_exchange_rate", frm.doc.target_exchange_rate);
-				frm.set_value("paid_amount", frm.doc.received_amount);
 			} else {
-				const source_rate =
-					flt(frm.doc.source_exchange_rate) ||
-					(company_currency == frm.doc.paid_from_account_currency ? 1 : 0);
-				if (source_rate) {
-					frm.set_value("paid_amount", flt(frm.doc.base_paid_amount) / source_rate);
-				}
+				frm.set_value(
+					"received_amount",
+					flt(frm.doc.base_received_amount) / flt(frm.doc.target_exchange_rate)
+				);
 			}
 
 			// set_unallocated_amount is called by below method,

erpnext/accounts/doctype/payment_entry/payment_entry.py

@@ -1206,9 +1206,9 @@ class PaymentEntry(AccountsController):
 				continue
 
 			if tax.add_deduct_tax == "Add":
-				included_taxes += flt(tax.base_tax_amount)
+				included_taxes += tax.base_tax_amount
 			else:
-				included_taxes -= flt(tax.base_tax_amount)
+				included_taxes -= tax.base_tax_amount
 
 		return included_taxes
 
@@ -1312,14 +1312,8 @@ class PaymentEntry(AccountsController):
 		self.add_deductions_gl_entries(gl_entries)
 		self.add_tax_gl_entries(gl_entries)
 		add_regional_gl_entries(gl_entries, self)
-		self.set_transaction_currency_and_rate_in_gl_map(gl_entries)
 		return gl_entries
 
-	def set_transaction_currency_and_rate_in_gl_map(self, gl_entries):
-		for gle in gl_entries:
-			gle.setdefault("transaction_currency", self.transaction_currency)
-			gle.setdefault("transaction_exchange_rate", self.transaction_exchange_rate)
-
 	def make_gl_entries(self, cancel=0, adv_adj=0):
 		gl_entries = self.build_gl_map()
 
@@ -2712,9 +2706,6 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 	if not frappe.db.exists(party_type, party):
 		frappe.throw(_("{0} {1} does not exist").format(_(party_type), party))
 
-	ptype = "select" if frappe.only_has_select_perm(party_type) else "read"
-	frappe.has_permission(party_type, ptype, party, throw=True)
-
 	party_account = get_party_account(party_type, party, company)
 	account_currency = get_account_currency(party_account)
 	_party_name = "title" if party_type == "Shareholder" else party_type.lower() + "_name"
@@ -2722,7 +2713,7 @@ def get_party_details(company, party_type, party, date, cost_center=None):
 
 	if party_type in ["Customer", "Supplier"]:
 		party_bank_account = get_party_bank_account(party_type, party)
-		bank_account = get_default_company_bank_account(company, party_type, party, ignore_permissions=False)
+		bank_account = get_default_company_bank_account(company, party_type, party)
 
 	return {
 		"party_account": party_account,
@@ -2814,7 +2805,9 @@ def get_reference_details(
 			exchange_rate = get_exchange_rate(party_account_currency, company_currency, ref_doc.posting_date)
 		else:
 			exchange_rate = 1
-		outstanding_amount, total_amount = get_outstanding_on_journal_entry(reference_name, party_type, party)
+			outstanding_amount, total_amount = get_outstanding_on_journal_entry(
+				reference_name, party_type, party
+			)
 
 	elif reference_doctype == "Payment Entry":
 		if reverse_payment_details := frappe.db.get_all(
@@ -3326,11 +3319,13 @@ def set_paid_amount_and_received_amount(
 			company_currency = frappe.get_cached_value("Company", doc.get("company"), "default_currency")
 			if bank and company_currency != bank.account_currency:
 				# doc currency can be different from bank currency
-				conversion_rate = get_exchange_rate(bank.account_currency, party_account_currency)
+				posting_date = doc.get("posting_date") or doc.get("transaction_date")
+				conversion_rate = get_exchange_rate(
+					bank.account_currency, party_account_currency, posting_date
+				)
 				received_amount = paid_amount / conversion_rate
 			else:
-				conversion_rate = get_exchange_rate(doc.get("currency", company_currency), company_currency)
-				received_amount = paid_amount * conversion_rate
+				received_amount = paid_amount * doc.get("conversion_rate", 1)
 
 		# if payment type is pay, then paid amount and received amount are swapped
 		if payment_type == "Pay":

erpnext/accounts/doctype/payment_entry/test_payment_entry.py

@@ -1037,17 +1037,14 @@ class TestPaymentEntry(ERPNextTestSuite):
 				gle.credit_in_account_currency,
 				gle.debit_in_transaction_currency,
 				gle.credit_in_transaction_currency,
-				gle.transaction_currency,
-				gle.transaction_exchange_rate,
 			)
 			.orderby(gle.account)
 			.where(gle.voucher_no == payment_entry.name)
 			.run()
 		)
-		# transaction currency/rate come from the paid-from USD account (company currency is INR)
 		expected_gl_entries = (
-			(paid_from, 0.0, 8440.0, 0.0, 100.0, 0.0, 100.0, "USD", 84.4),
-			("_Test Payable USD - _TC", 8440.0, 0.0, 100.0, 0.0, 100.0, 0.0, "USD", 84.4),
+			(paid_from, 0.0, 8440.0, 0.0, 100.0, 0.0, 100.0),
+			("_Test Payable USD - _TC", 8440.0, 0.0, 100.0, 0.0, 100.0, 0.0),
 		)
 		self.assertEqual(gl_entries, expected_gl_entries)
 
@@ -1113,27 +1110,6 @@ class TestPaymentEntry(ERPNextTestSuite):
 
 		self.assertEqual(gl_entries, expected_gl_entries)
 
-	def test_payment_entry_with_inclusive_tax(self):
-		# inclusive tax built server-side: base_tax_amount is None until apply_taxes()
-		payment_entry = create_payment_entry(paid_amount=1180)
-		payment_entry.append(
-			"taxes",
-			{
-				"account_head": "_Test Account Service Tax - _TC",
-				"charge_type": "On Paid Amount",
-				"rate": 18,
-				"included_in_paid_amount": 1,
-				"add_deduct_tax": "Add",
-				"description": "Service Tax",
-			},
-		)
-		payment_entry.save()
-		payment_entry.submit()
-
-		# 1180 incl 18% => 1000 base + 180 tax
-		self.assertEqual(flt(payment_entry.total_taxes_and_charges, 2), 180.0)
-		self.assertEqual(flt(payment_entry.unallocated_amount, 2), 1000.0)
-
 	def test_payment_entry_against_onhold_purchase_invoice(self):
 		pi = make_purchase_invoice()
 

erpnext/accounts/doctype/payment_ledger_entry/test_payment_ledger_entry.py

@@ -10,22 +10,76 @@ from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_ent
 from erpnext.accounts.doctype.payment_entry.test_payment_entry import create_payment_entry
 from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
 from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
+from erpnext.stock.doctype.item.test_item import create_item
 from erpnext.tests.utils import ERPNextTestSuite
 
 
 class TestPaymentLedgerEntry(ERPNextTestSuite):
 	def setUp(self):
 		self.ple = qb.DocType("Payment Ledger Entry")
-		self.company = "_Test Company"
-		self.cost_center = "Main - _TC"
-		self.warehouse = "Stores - _TC"
-		self.income_account = "Sales - _TC"
-		self.expense_account = "Cost of Goods Sold - _TC"
-		self.debit_to = "Debtors - _TC"
-		self.creditors = "Creditors - _TC"
-		self.bank = "Cash - _TC"
-		self.item = "_Test Item"
-		self.customer = "_Test Customer"
+		self.create_company()
+		self.create_item()
+		self.create_customer()
+		self.clear_old_entries()
+
+	def create_company(self):
+		company_name = "_Test Payment Ledger"
+		company = None
+		if frappe.db.exists("Company", company_name):
+			company = frappe.get_doc("Company", company_name)
+		else:
+			company = frappe.get_doc(
+				{
+					"doctype": "Company",
+					"company_name": company_name,
+					"country": "India",
+					"default_currency": "INR",
+					"create_chart_of_accounts_based_on": "Standard Template",
+					"chart_of_accounts": "Standard",
+				}
+			)
+			company = company.save()
+
+		self.company = company.name
+		self.cost_center = company.cost_center
+		self.warehouse = "All Warehouses - _PL"
+		self.income_account = "Sales - _PL"
+		self.expense_account = "Cost of Goods Sold - _PL"
+		self.debit_to = "Debtors - _PL"
+		self.creditors = "Creditors - _PL"
+
+		# create bank account
+		if frappe.db.exists("Account", "HDFC - _PL"):
+			self.bank = "HDFC - _PL"
+		else:
+			bank_acc = frappe.get_doc(
+				{
+					"doctype": "Account",
+					"account_name": "HDFC",
+					"parent_account": "Bank Accounts - _PL",
+					"company": self.company,
+				}
+			)
+			bank_acc.save()
+			self.bank = bank_acc.name
+
+	def create_item(self):
+		item_name = "_Test PL Item"
+		item = create_item(
+			item_code=item_name, is_stock_item=0, company=self.company, warehouse=self.warehouse
+		)
+		self.item = item if isinstance(item, str) else item.item_code
+
+	def create_customer(self):
+		name = "_Test PL Customer"
+		if frappe.db.exists("Customer", name):
+			self.customer = name
+		else:
+			customer = frappe.new_doc("Customer")
+			customer.customer_name = name
+			customer.type = "Individual"
+			customer.save()
+			self.customer = customer.name
 
 	def create_sales_invoice(
 		self, qty=1, rate=100, posting_date=None, do_not_save=False, do_not_submit=False
@@ -98,6 +152,18 @@ class TestPaymentLedgerEntry(ERPNextTestSuite):
 		)
 		return so
 
+	def clear_old_entries(self):
+		doctype_list = [
+			"GL Entry",
+			"Payment Ledger Entry",
+			"Sales Invoice",
+			"Purchase Invoice",
+			"Payment Entry",
+			"Journal Entry",
+		]
+		for doctype in doctype_list:
+			qb.from_(qb.DocType(doctype)).delete().where(qb.DocType(doctype).company == self.company).run()
+
 	def create_journal_entry(self, acc1=None, acc2=None, amount=0, posting_date=None, cost_center=None):
 		je = frappe.new_doc("Journal Entry")
 		je.posting_date = posting_date or nowdate()

erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py

@@ -6,10 +6,8 @@ import frappe
 from frappe import _, msgprint, qb
 from frappe.model.document import Document
 from frappe.model.meta import get_field_precision
-from frappe.permissions import get_allowed_docs_for_doctype, get_user_permissions
 from frappe.query_builder import Case, Criterion
 from frappe.query_builder.custom import ConstantColumn
-from frappe.query_builder.functions import IfNull
 from frappe.utils import flt, fmt_money, get_link_to_form, getdate, nowdate, today
 
 import erpnext
@@ -76,10 +74,6 @@ class PaymentReconciliation(Document):
 		self.ple_posting_date_filter = []
 		self.dimensions = get_dimensions(with_cost_center_and_project=True)[0]
 
-	@property
-	def user_permissions(self):
-		return get_user_permissions(frappe.session.user)
-
 	def load_from_db(self):
 		# 'modified' attribute is required for `run_doc_method` to work properly.
 		doc_dict = frappe._dict(
@@ -159,22 +153,6 @@ class PaymentReconciliation(Document):
 
 		self.add_payment_entries(non_reconciled_payments)
 
-	def get_permitted_dimension_values(self, document_type, reference_doctype):
-		return get_allowed_docs_for_doctype(self.user_permissions.get(document_type, []), reference_doctype)
-
-	def validate_permitted_dimension_value(self, document_type, value, allowed):
-		if value and allowed and value not in allowed:
-			frappe.throw(
-				_("You do not have enough permission to access {0}: {1}").format(_(document_type), value),
-				frappe.PermissionError,
-			)
-
-	def get_user_permission_dimension_condition(self, field, allowed):
-		value_condition = field.isin(allowed)
-		if frappe.get_system_settings("apply_strict_user_permissions"):
-			return value_condition
-		return (IfNull(field, "") == "") | value_condition
-
 	def get_payment_entries(self):
 		party_account = [self.receivable_payable_account]
 
@@ -198,13 +176,8 @@ class PaymentReconciliation(Document):
 		dimensions = {}
 		for x in self.dimensions:
 			dimension = x.fieldname
-			allowed = self.get_permitted_dimension_values(x.document_type, "Payment Entry")
-			if value := self.get(dimension):
-				self.validate_permitted_dimension_value(x.document_type, value, allowed)
-				dimensions[dimension] = value
-			elif allowed:
-				dimensions[dimension] = allowed
-
+			if self.get(dimension):
+				dimensions.update({dimension: self.get(dimension)})
 		condition.update({"accounting_dimensions": dimensions})
 
 		payment_entries = get_advance_payment_entries_for_regional(
@@ -228,12 +201,8 @@ class PaymentReconciliation(Document):
 		# Dimension filters
 		for x in self.dimensions:
 			dimension = x.fieldname
-			allowed = self.get_permitted_dimension_values(x.document_type, "Journal Entry Account")
-			if value := self.get(dimension):
-				self.validate_permitted_dimension_value(x.document_type, value, allowed)
-				conditions.append(jea[dimension] == value)
-			elif allowed:
-				conditions.append(self.get_user_permission_dimension_condition(jea[dimension], allowed))
+			if self.get(dimension):
+				conditions.append(jea[dimension] == self.get(dimension))
 
 		if self.payment_name:
 			conditions.append(je.name.like(f"%%{self.payment_name}%%"))
@@ -777,15 +746,8 @@ class PaymentReconciliation(Document):
 		ple = qb.DocType("Payment Ledger Entry")
 		for x in self.dimensions:
 			dimension = x.fieldname
-			if frappe.db.has_column("Payment Ledger Entry", dimension):
-				allowed = self.get_permitted_dimension_values(x.document_type, "Payment Ledger Entry")
-				if value := self.get(dimension):
-					self.validate_permitted_dimension_value(x.document_type, value, allowed)
-					self.accounting_dimension_filter_conditions.append(ple[dimension] == value)
-				elif allowed:
-					self.accounting_dimension_filter_conditions.append(
-						self.get_user_permission_dimension_condition(ple[dimension], allowed)
-					)
+			if self.get(dimension) and frappe.db.has_column("Payment Ledger Entry", dimension):
+				self.accounting_dimension_filter_conditions.append(ple[dimension] == self.get(dimension))
 
 	def build_qb_filter_conditions(self, get_invoices=False, get_return_invoices=False):
 		self.common_filter_conditions.clear()
@@ -834,17 +796,10 @@ class PaymentReconciliation(Document):
 
 
 def reconcile_dr_cr_note(dr_cr_notes, company, active_dimensions=None):
-	allocated_amount_precision = get_field_precision(
-		frappe.get_meta("Payment Reconciliation Allocation").get_field("allocated_amount")
-	)
 	for inv in dr_cr_notes:
 		if (
-			flt(
-				abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
-				- inv.allocated_amount,
-				allocated_amount_precision,
-			)
-			< 0
+			abs(frappe.db.get_value(inv.voucher_type, inv.voucher_no, "outstanding_amount"))
+			< inv.allocated_amount
 		):
 			frappe.throw(
 				_("{0} has been modified after you pulled it. Please pull it again.").format(inv.voucher_type)

erpnext/accounts/doctype/payment_reconciliation/test_payment_reconciliation.py

@@ -4,7 +4,7 @@
 
 import frappe
 from frappe import qb
-from frappe.utils import add_days, add_years, cint, flt, getdate, nowdate, today
+from frappe.utils import add_days, add_years, flt, getdate, nowdate, today
 from frappe.utils.data import getdate as convert_to_date
 
 from erpnext import get_default_cost_center
@@ -51,7 +51,6 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		sinv = create_sales_invoice(
 			qty=qty,
 			rate=rate,
-			posting_date=posting_date,
 			company=self.company,
 			customer=self.customer,
 			item_code=self.item,
@@ -1106,101 +1105,6 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
 		self.assertCountEqual(payment_vouchers, [je2.name, pe2.name])
 
-	def test_user_permission_on_accounting_dimension_filters_vouchers(self):
-		test_user = "test@example.com"
-		permitted_ccs = ["_Test Cost Center - _TC", "_Test Cost Center 2 - _TC"]
-		restricted_cc = "_Test Write Off Cost Center - _TC"
-		existing_apply_strict_user_permissions = cint(
-			frappe.db.get_single_value("System Settings", "apply_strict_user_permissions")
-		)
-		self.addCleanup(
-			frappe.db.set_single_value,
-			"System Settings",
-			"apply_strict_user_permissions",
-			existing_apply_strict_user_permissions,
-		)
-		transaction_date = nowdate()
-		rate = 100
-
-		def make_invoice(cost_center):
-			si = self.create_sales_invoice(
-				qty=1, rate=rate, posting_date=transaction_date, do_not_submit=True
-			)
-			si.cost_center = cost_center
-			for row in si.items:
-				row.cost_center = cost_center
-			return si.submit()
-
-		def make_payment(cost_center):
-			pe = self.create_payment_entry(posting_date=transaction_date, amount=rate)
-			pe.cost_center = cost_center
-			return pe.save().submit()
-
-		def make_journal(cost_center):
-			je = self.create_journal_entry(
-				self.bank, self.debit_to, 100, transaction_date, cost_center=cost_center
-			)
-			je.accounts[1].party_type = "Customer"
-			je.accounts[1].party = self.customer
-			return je.save().submit()
-
-		# Vouchers tagged with the two permitted cost centers
-		si_allowed = make_invoice(permitted_ccs[0])
-		pe_allowed = make_payment(permitted_ccs[1])
-		je_allowed = make_journal(permitted_ccs[0])
-
-		# Vouchers tagged with the restricted cost center
-		si_restricted = make_invoice(restricted_cc)
-		pe_restricted = make_payment(restricted_cc)
-		je_restricted = make_journal(restricted_cc)
-
-		# Payment entry with a BLANK cost center
-		pe_blank = make_payment(None)
-
-		for cc in permitted_ccs:
-			frappe.permissions.add_user_permission("Cost Center", cc, test_user)
-
-		# Without strict user permissions
-		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 0)
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.get_unreconciled_entries()
-
-		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertIn(si_allowed.name, invoice_numbers)
-		self.assertIn(pe_allowed.name, payment_vouchers)
-		self.assertIn(je_allowed.name, payment_vouchers)
-		self.assertIn(pe_blank.name, payment_vouchers)
-		self.assertNotIn(si_restricted.name, invoice_numbers)
-		self.assertNotIn(pe_restricted.name, payment_vouchers)
-		self.assertNotIn(je_restricted.name, payment_vouchers)
-
-		# With strict user permissions
-		frappe.db.set_single_value("System Settings", "apply_strict_user_permissions", 1)
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.get_unreconciled_entries()
-
-		invoice_numbers = [x.get("invoice_number") for x in pr.get("invoices")]
-		payment_vouchers = [x.get("reference_name") for x in pr.get("payments")]
-		self.assertIn(si_allowed.name, invoice_numbers)
-		self.assertIn(pe_allowed.name, payment_vouchers)
-		self.assertIn(je_allowed.name, payment_vouchers)
-		self.assertNotIn(pe_blank.name, payment_vouchers)
-		self.assertNotIn(si_restricted.name, invoice_numbers)
-		self.assertNotIn(pe_restricted.name, payment_vouchers)
-		self.assertNotIn(je_restricted.name, payment_vouchers)
-
-		# with restricted dimension as a filter
-		with self.set_user(test_user):
-			pr = self.create_payment_reconciliation()
-			pr.cost_center = restricted_cc
-			self.assertRaises(frappe.PermissionError, pr.get_unreconciled_entries)
-
-		for cc in permitted_ccs:
-			frappe.permissions.remove_user_permission("Cost Center", cc, test_user)
-
 	@ERPNextTestSuite.change_settings(
 		"Accounts Settings",
 		{
@@ -2114,7 +2018,7 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		pr.reconcile()
 
 		si.reload()
-		self.assertEqual(si.status, "Overdue")
+		self.assertEqual(si.status, "Partly Paid")
 		# check PR tool output post reconciliation
 		self.assertEqual(len(pr.get("invoices")), 1)
 		self.assertEqual(pr.get("invoices")[0].get("outstanding_amount"), 120)
@@ -2405,86 +2309,6 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		self.assertEqual(flt(pr.allocation[0].get("difference_amount")), -5000.0)
 		pr.reconcile()
 
-	def test_foreign_currency_reverse_payment_entry_gain_for_supplier(self):
-		transaction_date = nowdate()
-		self.supplier = "_Test Supplier USD"
-		amount = 100
-		department = frappe.db.get_value("Department", {"company": self.company, "is_group": 0}, "name")
-
-		# Pay USD 100 at an exchange rate of 90.
-		pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
-		pe.payment_type = "Pay"
-		pe.party_type = "Supplier"
-		pe.party = self.supplier
-		pe.paid_from = self.cash
-		pe.paid_from_account_currency = "INR"
-		pe.target_exchange_rate = 90
-		pe.paid_amount = 90 * amount
-		pe.received_amount = amount
-		pe.paid_to = self.creditors_usd
-		pe.paid_to_account_currency = "USD"
-		pe.department = department
-		pe = pe.save().submit()
-
-		# Receive USD 100 from the supplier at an exchange rate of 100.
-		reverse_pe = self.create_payment_entry(amount=amount, posting_date=transaction_date)
-		reverse_pe.payment_type = "Receive"
-		reverse_pe.party_type = "Supplier"
-		reverse_pe.party = self.supplier
-		reverse_pe.paid_from = self.creditors_usd
-		reverse_pe.paid_from_account_currency = "USD"
-		reverse_pe.source_exchange_rate = 100
-		reverse_pe.paid_amount = amount
-		reverse_pe.received_amount = 100 * amount
-		reverse_pe.paid_to = self.cash
-		reverse_pe.paid_to_account_currency = "INR"
-		reverse_pe.department = department
-		reverse_pe = reverse_pe.save().submit()
-
-		pr = self.create_payment_reconciliation(party_is_customer=False)
-		pr.party = self.supplier
-		pr.receivable_payable_account = self.creditors_usd
-		pr.get_unreconciled_entries()
-		invoices = [invoice.as_dict() for invoice in pr.invoices]
-		payments = [payment.as_dict() for payment in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-		for row in pr.allocation:
-			row.department = department
-
-		self.assertEqual(flt(pr.allocation[0].difference_amount), 1000)
-		pr.reconcile()
-
-		gain_loss_journal = frappe.db.get_value(
-			"Journal Entry Account",
-			{
-				"reference_type": reverse_pe.doctype,
-				"reference_name": reverse_pe.name,
-				"party": self.supplier,
-				"docstatus": 1,
-			},
-			"parent",
-		)
-		party_row = frappe.db.get_value(
-			"Journal Entry Account",
-			{"parent": gain_loss_journal, "party": self.supplier},
-			["debit", "credit"],
-			as_dict=True,
-		)
-		self.assertEqual(flt(party_row.debit), 1000)
-		self.assertEqual(flt(party_row.credit), 0)
-
-		party_gl_entries = frappe.get_all(
-			"GL Entry",
-			filters={
-				"voucher_no": ["in", [pe.name, reverse_pe.name, gain_loss_journal]],
-				"account": self.creditors_usd,
-				"party": self.supplier,
-				"is_cancelled": 0,
-			},
-			fields=["debit", "credit"],
-		)
-		self.assertEqual(flt(sum(row.debit - row.credit for row in party_gl_entries)), 0)
-
 	def test_foreign_currency_reverse_journal_entry_against_journal_entry_for_customer(self):
 		transaction_date = nowdate()
 		customer = self.customer_usd
@@ -2590,76 +2414,6 @@ class TestPaymentReconciliation(ERPNextTestSuite):
 		self.assertEqual(flt(pr.allocation[0].difference_amount), 5000.0)
 		pr.reconcile()
 
-	def test_cr_note_split_across_invoices_floating_point_precision(self):
-		"""Regression: when a credit note is split across multiple invoices, floating-point
-		arithmetic (150 - 8.45 - 90.72 = 50.83000000000001) must not cause reconcile() to fail.
-
-		The test environment rounds INR totals to whole rupees (smallest_currency_fraction_value=0),
-		so the invoices are created with round-number totals (100, 200, 100) and then partially paid
-		down to the decimal outstanding amounts (8.45, 90.72, 72.57) via payment entries.
-		"""
-		from erpnext.accounts.doctype.payment_entry.payment_entry import get_payment_entry
-
-		# Create invoices on different posting dates to control sort-order in Payment Reconciliation
-		# (invoices are sorted by posting_date ascending, so si_a is processed first).
-		# Processing order 8.45 → 90.72 → 72.57 produces the float chain:
-		#   150 - 8.45 = 141.55  →  141.55 - 90.72 = 50.83000000000001
-		# The last allocation row will therefore carry allocated_amount = 50.83000000000001.
-		si_a = self.create_sales_invoice(qty=1, rate=100, posting_date=add_days(nowdate(), -2))
-		si_b = self.create_sales_invoice(qty=1, rate=200, posting_date=add_days(nowdate(), -1))
-		si_c = self.create_sales_invoice(qty=1, rate=100, posting_date=nowdate())
-
-		# Partially pay each invoice so the remaining outstanding is a clean decimal value.
-		# INR rounds the invoice total to a whole rupee, so we achieve decimal outstandings
-		# by subtracting a decimal-valued payment from the integer total:
-		#   100 - 91.55 = 8.45
-		#   200 - 109.28 = 90.72
-		#   100 - 27.43 = 72.57
-		for si, partial_paid in ((si_a, 91.55), (si_b, 109.28), (si_c, 27.43)):
-			pe = get_payment_entry(si.doctype, si.name)
-			pe.paid_amount = partial_paid
-			pe.received_amount = partial_paid
-			pe.references[0].allocated_amount = partial_paid
-			pe.save().submit()
-
-		cr_note = self.create_sales_invoice(
-			qty=-1, rate=150, posting_date=nowdate(), do_not_save=True, do_not_submit=True
-		)
-		cr_note.is_return = 1
-		cr_note = cr_note.save().submit()
-
-		pr = self.create_payment_reconciliation()
-		# Widen date range so all three invoices (oldest is -2 days) are fetched
-		pr.from_invoice_date = add_days(nowdate(), -2)
-		pr.to_invoice_date = nowdate()
-		pr.from_payment_date = nowdate()
-		pr.to_payment_date = nowdate()
-
-		pr.get_unreconciled_entries()
-		self.assertEqual(len(pr.invoices), 3)
-		self.assertEqual(len(pr.payments), 1)
-
-		invoices = [x.as_dict() for x in pr.invoices]
-		payments = [x.as_dict() for x in pr.payments]
-		pr.allocate_entries(frappe._dict({"invoices": invoices, "payments": payments}))
-
-		# Credit note (150) covers all of si_a (8.45) and si_b (90.72), then partially si_c
-		self.assertEqual(len(pr.allocation), 3)
-		last_row = pr.allocation[-1]
-		# Last allocated amount should be ~50.83 (possibly 50.83000000000001 due to float arithmetic)
-		self.assertAlmostEqual(flt(last_row.allocated_amount), 50.83, places=2)
-
-		# reconcile() must not raise "has been modified after you pulled it" due to float imprecision
-		pr.reconcile()
-
-		si_a.reload()
-		si_b.reload()
-		si_c.reload()
-		self.assertEqual(si_a.outstanding_amount, 0)
-		self.assertEqual(si_b.outstanding_amount, 0)
-		# si_c is only partially settled: 72.57 - 50.83 = 21.74
-		self.assertAlmostEqual(si_c.outstanding_amount, 21.74, places=2)
-
 
 def create_fiscal_year(company, year_start_date, year_end_date):
 	fy_docname = frappe.db.exists(

erpnext/accounts/doctype/payment_reference/payment_reference.json

@@ -14,8 +14,7 @@
   "section_break_mjlv",
   "due_date",
   "column_break_qghl",
-  "amount",
-  "currency"
+  "amount"
  ],
  "fields": [
   {
@@ -56,18 +55,8 @@
    "fieldtype": "Currency",
    "in_list_view": 1,
    "label": "Amount",
-   "options": "currency",
    "precision": "2"
   },
-  {
-   "fieldname": "currency",
-   "fieldtype": "Link",
-   "hidden": 1,
-   "label": "Currency",
-   "options": "Currency",
-   "print_hide": 1,
-   "read_only": 1
-  },
   {
    "fieldname": "column_break_lnjp",
    "fieldtype": "Column Break"
@@ -85,7 +74,7 @@
  "index_web_pages_for_search": 1,
  "istable": 1,
  "links": [],
- "modified": "2026-07-11 00:00:00.000000",
+ "modified": "2026-01-19 02:21:36.455830",
  "modified_by": "Administrator",
  "module": "Accounts",
  "name": "Payment Reference",

erpnext/accounts/doctype/payment_request/payment_request.js

@@ -37,8 +37,6 @@ frappe.ui.form.on("Payment Request", "refresh", function (frm) {
 		frm.set_intro(__("Failure: {0}", [frm.doc.failed_reason]), "red");
 	}
 
-	let sending_email = false;
-
 	if (
 		frm.doc.payment_request_type == "Inward" &&
 		frm.doc.payment_channel !== "Phone" &&
@@ -47,16 +45,16 @@ frappe.ui.form.on("Payment Request", "refresh", function (frm) {
 		frm.doc.docstatus == 1
 	) {
 		frm.add_custom_button(__("Resend Payment Email"), function () {
-			if (sending_email) {
-				frappe.show_alert({ message: __("Sending Email"), indicator: "blue" });
-				return;
-			}
-			sending_email = true;
-			frappe.show_alert({ message: __("Sending Email"), indicator: "blue" });
-			frm.call("resend_payment_email").then((r) => {
-				const msg = !r.exc ? __("Email Sent") : __("Email couldn't be sent.");
-				frappe.show_alert({ message: msg, indicator: !r.exc ? "green" : "red" });
-				sending_email = false;
+			frappe.call({
+				method: "erpnext.accounts.doctype.payment_request.payment_request.resend_payment_email",
+				args: { docname: frm.doc.name },
+				freeze: true,
+				freeze_message: __("Sending"),
+				callback: function (r) {
+					if (!r.exc) {
+						frappe.msgprint(__("Message Sent"));
+					}
+				},
 			});
 		});
 	}

erpnext/accounts/doctype/payment_request/payment_request.py

@@ -379,7 +379,6 @@ class PaymentRequest(Document):
 			bank_amount=bank_amount,
 			created_from_payment_request=True,
 		)
-		payment_entry.set_missing_ref_details(force=True)
 
 		payment_entry.update(
 			{
@@ -423,18 +422,6 @@ class PaymentRequest(Document):
 
 		return payment_entry
 
-	@frappe.whitelist(methods=["POST"])
-	def resend_payment_email(self):
-		if not (
-			self.docstatus == 1
-			and self.payment_request_type == "Inward"
-			and self.payment_channel != "Phone"
-			and self.status not in ["Initiated", "Paid"]
-		):
-			frappe.throw(_("Payment Link couldn't be sent."))
-
-		self.send_email()
-
 	def send_email(self):
 		"""send email with payment link"""
 		email_args = {
@@ -452,14 +439,11 @@ class PaymentRequest(Document):
 				)
 			],
 		}
-		job_id = f"send_payment_email::{self.name}"
 		enqueue(
 			method=frappe.sendmail,
 			queue="short",
 			timeout=300,
 			is_async=True,
-			job_id=job_id,
-			deduplicate=True,
 			enqueue_after_commit=True,
 			**email_args,
 		)
@@ -799,7 +783,6 @@ def set_payment_references(payment_schedules):
 				"description": row.get("description"),
 				"due_date": row.get("due_date"),
 				"amount": row.get("payment_amount"),
-				"currency": row.get("currency"),
 			}
 		)
 
@@ -966,10 +949,14 @@ def get_print_format_list(ref_doctype):
 	return {"print_format": print_format_list}
 
 
+@frappe.whitelist()
+def resend_payment_email(docname):
+	return frappe.get_doc("Payment Request", docname).send_email()
+
+
 @frappe.whitelist()
 def make_payment_entry(docname):
 	doc = frappe.get_doc("Payment Request", docname)
-	doc.check_permission("read")
 	return doc.create_payment_entry(submit=False).as_dict()
 
 

erpnext/accounts/doctype/payment_request/test_payment_request.py

@@ -775,22 +775,6 @@ class TestPaymentRequest(ERPNextTestSuite):
 		pi.load_from_db()
 		self.assertEqual(pr_2.grand_total, pi.outstanding_amount)
 
-	def test_payment_entry_reference_details_fetched_from_invoice(self):
-		pi = make_purchase_invoice(currency="INR", qty=1, rate=94500)
-		pi.submit()
-
-		pr = make_payment_request(dt="Purchase Invoice", dn=pi.name, mute_email=1, submit_doc=0, return_doc=1)
-		pr.grand_total = 94000
-		pr.submit()
-
-		pe = pr.create_payment_entry(submit=False)
-
-		self.assertEqual(pe.references[0].reference_name, pi.name)
-		self.assertEqual(pe.references[0].total_amount, pi.grand_total)
-		self.assertEqual(pe.references[0].outstanding_amount, pi.outstanding_amount)
-		self.assertEqual(pe.references[0].allocated_amount, 94000)
-		self.assertEqual(pe.paid_amount, 94000)
-
 	def test_consider_journal_entry_and_return_invoice(self):
 		from erpnext.accounts.doctype.journal_entry.test_journal_entry import make_journal_entry
 

erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py

@@ -15,7 +15,6 @@ from erpnext.accounts.doctype.account_closing_balance.account_closing_balance im
 from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
 	get_accounting_dimensions,
 )
-from erpnext.accounts.general_ledger import check_freezing_date, is_immutable_ledger_enabled
 from erpnext.accounts.utils import get_account_currency, get_fiscal_year
 from erpnext.controllers.accounts_controller import AccountsController
 
@@ -47,14 +46,6 @@ class PeriodClosingVoucher(AccountsController):
 		self.block_if_future_closing_voucher_exists()
 		self.check_closing_account_type()
 		self.check_closing_account_currency()
-		self.validate_accounts_not_frozen()
-
-	def validate_accounts_not_frozen(self, for_cancellation=False):
-		posting_date = self.period_end_date
-		if for_cancellation and is_immutable_ledger_enabled():
-			posting_date = getdate()
-
-		check_freezing_date(posting_date, self.company)
 
 	def validate_start_and_end_date(self):
 		self.fy_start_date, self.fy_end_date = frappe.db.get_value(
@@ -156,7 +147,6 @@ class PeriodClosingVoucher(AccountsController):
 			"Process Period Closing Voucher",
 		)
 		self.block_if_future_closing_voucher_exists()
-		self.validate_accounts_not_frozen(for_cancellation=True)
 
 		if not frappe.get_single_value("Accounts Settings", "use_legacy_controller_for_pcv"):
 			self.cancel_process_pcv_docs()

erpnext/accounts/doctype/period_closing_voucher/test_period_closing_voucher.py

@@ -19,6 +19,7 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		frappe.db.set_single_value("Accounts Settings", "use_legacy_controller_for_pcv", 1)
 
 	def test_closing_entry(self):
+		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		jv1 = make_journal_entry(
@@ -27,10 +28,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv1.company = "Test PCV Company"
+		jv1.company = company
 		jv1.save()
 		jv1.submit()
 
@@ -40,10 +41,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cost of Goods Sold - TPC",
 			account2="Cash - TPC",
 			cost_center=cost_center,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv2.company = "Test PCV Company"
+		jv2.company = company
 		jv2.save()
 		jv2.submit()
 
@@ -67,13 +68,14 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(pcv_gle, expected_gle)
 
 	def test_cost_center_wise_posting(self):
+		company = create_company()
 		surplus_account = create_account()
 
 		cost_center1 = create_cost_center("Main")
 		cost_center2 = create_cost_center("Western Branch")
 
 		create_sales_invoice(
-			company="Test PCV Company",
+			company=company,
 			cost_center=cost_center1,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
@@ -84,7 +86,7 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			posting_date="2021-03-15",
 		)
 		create_sales_invoice(
-			company="Test PCV Company",
+			company=company,
 			cost_center=cost_center2,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
@@ -129,11 +131,12 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		)
 
 	def test_period_closing_with_finance_book_entries(self):
+		company = create_company()
 		surplus_account = create_account()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		create_sales_invoice(
-			company="Test PCV Company",
+			company=company,
 			income_account="Sales - TPC",
 			expense_account="Cost of Goods Sold - TPC",
 			cost_center=cost_center,
@@ -150,9 +153,9 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			amount=400,
 			cost_center=cost_center,
 			posting_date="2021-03-15",
-			company="Test PCV Company",
+			company=company,
 		)
-		jv.company = "Test PCV Company"
+		jv.company = company
 		jv.finance_book = create_finance_book().name
 		jv.save()
 		jv.submit()
@@ -179,6 +182,7 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertSequenceEqual(pcv_gle, expected_gle)
 
 	def test_gl_entries_restrictions(self):
+		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
@@ -189,15 +193,16 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv1.company = "Test PCV Company"
+		jv1.company = company
 		jv1.save()
 
 		self.assertRaises(frappe.ValidationError, jv1.submit)
 
 	def test_closing_balance_with_dimensions_and_test_reposting_entry(self):
+		company = create_company()
 		cost_center1 = create_cost_center("Test Cost Center 1")
 		cost_center2 = create_cost_center("Test Cost Center 2")
 
@@ -207,10 +212,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center1,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv1.company = "Test PCV Company"
+		jv1.company = company
 		jv1.save()
 		jv1.submit()
 
@@ -220,10 +225,10 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv2.company = "Test PCV Company"
+		jv2.company = company
 		jv2.save()
 		jv2.submit()
 
@@ -250,11 +255,11 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center2,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
 
-		jv3.company = "Test PCV Company"
+		jv3.company = company
 		jv3.save()
 		jv3.submit()
 
@@ -289,12 +294,12 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(cc2_closing_balance.credit, 500)
 		self.assertEqual(cc2_closing_balance.credit_in_account_currency, 500)
 
-		warehouse = frappe.db.get_value("Warehouse", {"company": "Test PCV Company"}, "name")
+		warehouse = frappe.db.get_value("Warehouse", {"company": company}, "name")
 
 		repost_doc = frappe.get_doc(
 			{
 				"doctype": "Repost Item Valuation",
-				"company": "Test PCV Company",
+				"company": company,
 				"posting_date": "2020-03-15",
 				"based_on": "Item and Warehouse",
 				"item_code": "Test Item 1",
@@ -335,6 +340,7 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		{"enable_immutable_ledger": 1},
 	)
 	def test_immutable_ledger_reverse_entry_uses_passed_posting_date_after_pcv(self):
+		company = create_company()
 		cost_center = create_cost_center("Test Cost Center 1")
 
 		jv = make_journal_entry(
@@ -343,24 +349,21 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 			account1="Cash - TPC",
 			account2="Sales - TPC",
 			cost_center=cost_center,
-			company="Test PCV Company",
+			company=company,
 			save=False,
 		)
-		jv.company = "Test PCV Company"
+		jv.company = company
 		jv.save()
 		jv.submit()
 
 		self.make_period_closing_voucher(posting_date="2021-03-31")
 
-		frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", "2021-12-31")
-
-		try:
-			make_reverse_gl_entries(
-				voucher_type="Journal Entry",
-				voucher_no=jv.name,
-			)
-		finally:
-			frappe.db.set_value("Company", "Test PCV Company", "accounts_frozen_till_date", None)
+		# Passed posting_date is after PCV end date, so cancellation should not fail.
+		make_reverse_gl_entries(
+			voucher_type="Journal Entry",
+			voucher_no=jv.name,
+			posting_date="2022-01-01",
+		)
 
 		totals_after_cancel = frappe.db.sql(
 			"""
@@ -375,6 +378,19 @@ class TestPeriodClosingVoucher(ERPNextTestSuite):
 		self.assertEqual(totals_after_cancel.total_debit, totals_after_cancel.total_credit)
 
 
+def create_company():
+	company = frappe.get_doc(
+		{
+			"doctype": "Company",
+			"company_name": "Test PCV Company",
+			"country": "United States",
+			"default_currency": "USD",
+		}
+	)
+	company.insert(ignore_if_duplicate=True)
+	return company.name
+
+
 def create_account():
 	account = frappe.get_doc(
 		{

erpnext/accounts/doctype/pos_closing_entry/pos_closing_entry.py

@@ -217,8 +217,7 @@ class POSClosingEntry(StatusUpdater):
 		self.update_sales_invoices_closing_entry()
 
 	def before_cancel(self):
-		if self.status != "Failed":
-			self.check_pce_is_cancellable()
+		self.check_pce_is_cancellable()
 
 	def on_cancel(self):
 		unconsolidate_pos_invoices(closing_entry=self)

erpnext/accounts/doctype/pos_profile/pos_profile.py

@@ -234,18 +234,15 @@ def get_item_groups(pos_profile):
 		for data in pos_profile.get("item_groups"):
 			item_groups.extend(
 				[
-					d.name
+					"%s" % frappe.db.escape(d.name)
 					for d in get_child_nodes("Item Group", data.item_group)
 					if not permitted_item_groups or d.name in permitted_item_groups
 				]
 			)
 
 	if not item_groups and permitted_item_groups:
-		item_groups = list(permitted_item_groups)
+		item_groups = ["%s" % frappe.db.escape(d) for d in permitted_item_groups]
 
-	# Return raw Item Group names; the callers parameterize them via the query builder
-	# (item_group.isin(...)) / frappe.get_all, which escapes them once. Pre-escaping here would
-	# double-escape (item_group IN ('''X''')) and match nothing.
 	return list(set(item_groups))