From e8ce0ee79db4115ded0550a35a0f423808241dc2 Mon Sep 17 00:00:00 2001 From: Mohammed Irfan Date: Sat, 12 Sep 2026 03:32:47 +0530 Subject: [PATCH 1/2] Custom stock balance report with multiselect Item group filter --- .../report/stock_balance_custom/__init__.py | 1 + .../stock_balance_custom.js | 173 ++++ .../stock_balance_custom.json | 35 + .../stock_balance_custom.py | 769 ++++++++++++++++++ 4 files changed, 978 insertions(+) create mode 100644 spollex/spollex/report/stock_balance_custom/__init__.py create mode 100644 spollex/spollex/report/stock_balance_custom/stock_balance_custom.js create mode 100644 spollex/spollex/report/stock_balance_custom/stock_balance_custom.json create mode 100644 spollex/spollex/report/stock_balance_custom/stock_balance_custom.py diff --git a/spollex/spollex/report/stock_balance_custom/__init__.py b/spollex/spollex/report/stock_balance_custom/__init__.py new file mode 100644 index 0000000..40a96af --- /dev/null +++ b/spollex/spollex/report/stock_balance_custom/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js new file mode 100644 index 0000000..e6248d6 --- /dev/null +++ b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js @@ -0,0 +1,173 @@ +// Copyright (c) 2026, 4C Solutions and contributors +// For license information, please see license.txt + +frappe.query_reports["Stock Balance Custom"] = { + filters: [ + { + fieldname: "company", + label: __("Company"), + fieldtype: "Link", + width: "80", + options: "Company", + default: frappe.defaults.get_default("company"), + }, + { + fieldname: "from_date", + label: __("From Date"), + fieldtype: "Date", + width: "80", + reqd: 1, + default: frappe.datetime.add_months(frappe.datetime.get_today(), -1), + }, + { + fieldname: "to_date", + label: __("To Date"), + fieldtype: "Date", + width: "80", + reqd: 1, + default: frappe.datetime.get_today(), + }, + { + fieldname: "item_group", + label: __("Item Group"), + fieldtype: "MultiSelectList", + width: "80", + options: "Item Group", + get_data: function (txt) { + return frappe.db.get_link_options("Item Group", txt); + }, + }, + { + fieldname: "item_code", + label: __("Items"), + fieldtype: "MultiSelectList", + width: "80", + options: "Item", + get_data: async function (txt) { + let item_group = frappe.query_report.get_filter_value("item_group"); + + let filters = { + is_stock_item: 1, + }; + + if (item_group) { + if (Array.isArray(item_group) && item_group.length) { + filters.item_group = ["in", item_group]; + } else if (typeof item_group === "string" && item_group.trim()) { + filters.item_group = item_group; + } + } + + let { message: data } = await frappe.call({ + method: "erpnext.controllers.queries.item_query", + args: { + doctype: "Item", + txt: txt, + searchfield: "name", + start: 0, + page_len: 10, + filters: filters, + as_dict: 1, + }, + }); + + data = data.map(({ name, ...rest }) => { + return { + value: name, + description: Object.values(rest), + }; + }); + + return data || []; + }, + }, + { + fieldname: "warehouse", + label: __("Warehouses"), + fieldtype: "MultiSelectList", + width: "80", + options: "Warehouse", + get_data: (txt) => { + let warehouse_type = frappe.query_report.get_filter_value("warehouse_type"); + let company = frappe.query_report.get_filter_value("company"); + + let filters = { + ...(warehouse_type && { warehouse_type }), + ...(company && { company }), + }; + + return frappe.db.get_link_options("Warehouse", txt, filters); + }, + }, + { + fieldname: "warehouse_type", + label: __("Warehouse Type"), + fieldtype: "Link", + width: "80", + options: "Warehouse Type", + }, + { + fieldname: "valuation_field_type", + label: __("Valuation Field Type"), + fieldtype: "Select", + width: "80", + options: "Currency\nFloat", + default: "Currency", + }, + { + fieldname: "include_uom", + label: __("Include UOM"), + fieldtype: "Link", + options: "UOM", + }, + { + fieldname: "show_variant_attributes", + label: __("Show Variant Attributes"), + fieldtype: "Check", + }, + { + fieldname: "show_stock_ageing_data", + label: __("Show Stock Ageing Data"), + fieldtype: "Check", + }, + { + fieldname: "ignore_closing_balance", + label: __("Ignore Closing Balance"), + fieldtype: "Check", + default: 0, + }, + { + fieldname: "include_zero_stock_items", + label: __("Include Zero Stock Items"), + fieldtype: "Check", + default: 1, + }, + { + fieldname: "show_dimension_wise_stock", + label: __("Show Dimension Wise Stock"), + fieldtype: "Check", + default: 0, + }, + ], + + formatter: function (value, row, column, data, default_formatter) { + value = default_formatter(value, row, column, data); + + if (column.fieldname == "out_qty" && data && data.out_qty > 0) { + value = "" + value + ""; + } else if (column.fieldname == "in_qty" && data && data.in_qty > 0) { + value = "" + value + ""; + } + + return value; + }, + + onload: function (report) { + report.page.add_inner_button(__("View Stock Ledger"), function () { + var filters = report.get_values(); + frappe.set_route("query-report", "Stock Ledger", filters); + }); + }, +}; + +erpnext.utils.add_inventory_dimensions("Stock Balance Custom", 8); diff --git a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.json b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.json new file mode 100644 index 0000000..01c1f29 --- /dev/null +++ b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.json @@ -0,0 +1,35 @@ +{ + "add_total_row": 1, + "add_translate_data": 0, + "columns": [], + "creation": "2026-09-12 01:54:21.375969", + "disable_prepared_report_automation": 0, + "disabled": 0, + "docstatus": 0, + "doctype": "Report", + "doctype_to_sync": [], + "filters": [], + "idx": 0, + "is_standard": "Yes", + "letter_head": null, + "modified": "2026-09-12 01:59:39.253934", + "modified_by": "Administrator", + "module": "spollex", + "name": "Stock Balance Custom", + "owner": "Administrator", + "prepared_report": 0, + "ref_doctype": "Stock Ledger Entry", + "reference_report": "Stock Balance", + "report_name": "Stock Balance Custom", + "report_type": "Script Report", + "roles": [ + { + "role": "Stock User" + }, + { + "role": "Accounts Manager" + } + ], + "snapshot_report": 0, + "timeout": 0 +} \ No newline at end of file diff --git a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py new file mode 100644 index 0000000..19ad48d --- /dev/null +++ b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py @@ -0,0 +1,769 @@ +# Copyright (c) 2026, 4C Solutions and Contributors +# License: GNU General Public License v3. See license.txt + +import json +from operator import itemgetter +from typing import Any, TypedDict + +import frappe +from frappe import _ +from frappe.query_builder import Order +from frappe.query_builder.functions import Coalesce, Count +from frappe.utils import add_days, cint, date_diff, flt, getdate +from frappe.utils.nestedset import get_descendants_of + +import erpnext +from erpnext.stock.doctype.inventory_dimension.inventory_dimension import get_inventory_dimensions +from erpnext.stock.doctype.warehouse.warehouse import apply_warehouse_filter +from erpnext.stock.report.stock_ageing.stock_ageing import ( + FIFOSlots, + get_average_age, + normalize_fifo_queue, +) +from erpnext.stock.utils import add_additional_uom_columns + + +class StockBalanceFilter(TypedDict): + company: str | None + from_date: str + to_date: str + item_group: str | list[str] | None + item_code: list[str] | None + warehouse: list[str] | None + warehouse_type: str | None + include_uom: str | None # include extra info in converted UOM + show_stock_ageing_data: bool + show_variant_attributes: bool + + +SLEntry = dict[str, Any] + + +def execute(filters: StockBalanceFilter | None = None): + return StockBalanceReport(filters).run() + + +def parse_filter_list(val): + if not val: + return [] + if isinstance(val, str): + try: + parsed = json.loads(val) + if isinstance(parsed, list): + return [x for x in parsed if x] + except Exception: + pass + return [val] + if isinstance(val, (list, tuple, set)): + return [x for x in val if x] + return [val] + + +def get_item_groups_with_descendants(item_groups): + groups = parse_filter_list(item_groups) + if not groups: + return [] + all_groups = set() + for ig in groups: + if not ig: + continue + all_groups.add(ig) + if descendants := get_descendants_of("Item Group", ig, ignore_permissions=True): + all_groups.update(descendants) + return list(all_groups) + + +class StockBalanceReport: + def __init__(self, filters: StockBalanceFilter | None) -> None: + self.filters = filters or {} + self.from_date = getdate(self.filters.get("from_date")) + self.to_date = getdate(self.filters.get("to_date")) + + self.start_from = None + self.data = [] + self.columns = [] + self.sle_entries: list[SLEntry] = [] + self.set_company_currency() + + def set_company_currency(self) -> None: + if self.filters.get("company"): + self.company_currency = erpnext.get_company_currency(self.filters.get("company")) + else: + self.company_currency = frappe.db.get_single_value("Global Defaults", "default_currency") + + def run(self): + self.float_precision = cint(frappe.db.get_default("float_precision")) or 3 + + self.inventory_dimensions = self.get_inventory_dimension_fields() + self.prepare_opening_data_from_closing_balance() + self.prepare_stock_ledger_entries() + self.prepare_new_data() + + if not self.columns: + self.columns = self.get_columns() + + self.add_additional_uom_columns() + + return self.columns, self.data + + def prepare_opening_data_from_closing_balance(self) -> None: + self.opening_data = frappe._dict({}) + + closing_balance = self.get_closing_balance() + if not closing_balance: + return + + self.start_from = add_days(closing_balance[0].to_date, 1) + res = frappe.get_doc("Closing Stock Balance", closing_balance[0].name).get_prepared_data() + + for entry in res.data: + entry = frappe._dict(entry) + + group_by_key = self.get_group_by_key(entry) + if group_by_key not in self.opening_data: + self.opening_data.setdefault(group_by_key, entry) + + def prepare_new_data(self): + self.item_warehouse_map = self.get_item_warehouse_map() + + if self.filters.get("show_stock_ageing_data"): + self.filters["show_warehouse_wise_stock"] = True + item_wise_fifo_queue = FIFOSlots(self.filters, self.sle_entries).generate() + + del self.sle_entries + + sre_details = self.get_sre_reserved_qty_details() + + variant_values = {} + if self.filters.get("show_variant_attributes"): + variant_values = self.get_variant_values_for() + + for _key, report_data in self.item_warehouse_map.items(): + if variant_data := variant_values.get(report_data.item_code): + report_data.update(variant_data) + + if self.filters.get("show_stock_ageing_data"): + opening_fifo_queue = self.get_opening_fifo_queue(report_data) or [] + + fifo_queue = [] + if fifo_queue := item_wise_fifo_queue.get((report_data.item_code, report_data.warehouse)): + fifo_queue = fifo_queue.get("fifo_queue") + + if fifo_queue: + opening_fifo_queue.extend(fifo_queue) + + stock_ageing_data = {"average_age": 0, "earliest_age": 0, "latest_age": 0} + if opening_fifo_queue: + stock_ageing_data.update(get_stock_ageing_data(opening_fifo_queue, self.to_date)) + + report_data.update(stock_ageing_data) + + report_data.update( + {"reserved_stock": sre_details.get((report_data.item_code, report_data.warehouse), 0.0)} + ) + + if ( + not self.filters.get("include_zero_stock_items") + and report_data + and report_data.bal_qty == 0 + and report_data.bal_val == 0 + ): + continue + + self.data.append(report_data) + + def get_item_warehouse_map(self): + item_warehouse_map = {} + self.opening_vouchers = self.get_opening_vouchers() + + if self.filters.get("show_stock_ageing_data"): + self.sle_entries = self.sle_query.run(as_dict=True) + + self.prepare_stock_reco_voucher_wise_count() + + # HACK: This is required to avoid causing db query in flt + _system_settings = frappe.get_cached_doc("System Settings") + with frappe.db.unbuffered_cursor(): + if not self.filters.get("show_stock_ageing_data"): + self.sle_entries = self.sle_query.run(as_dict=True, as_iterator=True) + + for entry in self.sle_entries: + group_by_key = self.get_group_by_key(entry) + if group_by_key not in item_warehouse_map: + self.initialize_data(item_warehouse_map, group_by_key, entry) + + self.prepare_item_warehouse_map(item_warehouse_map, entry, group_by_key) + + if self.opening_data.get(group_by_key): + del self.opening_data[group_by_key] + + for group_by_key, entry in self.opening_data.items(): + if group_by_key not in item_warehouse_map: + self.initialize_data(item_warehouse_map, group_by_key, entry) + + item_warehouse_map = filter_items_with_no_transactions( + item_warehouse_map, self.float_precision, self.inventory_dimensions + ) + + return item_warehouse_map + + def prepare_stock_reco_voucher_wise_count(self): + self.stock_reco_voucher_wise_count = frappe._dict() + + doctype = frappe.qb.DocType("Stock Ledger Entry") + item = frappe.qb.DocType("Item") + + query = ( + frappe.qb.from_(doctype) + .inner_join(item) + .on(doctype.item_code == item.name) + .select(doctype.voucher_detail_no, Count(doctype.name).as_("count")) + .where( + (doctype.voucher_type == "Stock Reconciliation") + & (doctype.docstatus < 2) + & (doctype.is_cancelled == 0) + & (item.has_serial_no == 1) + ) + .groupby(doctype.voucher_detail_no) + ) + + if items := self.filters.get("item_code"): + items = parse_filter_list(items) + if items: + query = query.where(item.name.isin(items)) + + if self.filters.get("item_group"): + childrens = get_item_groups_with_descendants(self.filters.get("item_group")) + if childrens: + query = query.where(item.item_group.isin(childrens)) + + if warehouses := self.filters.get("warehouse"): + warehouses = parse_filter_list(warehouses) + childrens = [] + for warehouse in warehouses: + childrens.append(warehouse) + if warehouse_childrens := get_descendants_of("Warehouse", warehouse, ignore_permissions=True): + childrens.extend(warehouse_childrens) + + if childrens: + query = query.where(doctype.warehouse.isin(childrens)) + + data = query.run(as_dict=True) + if not data: + return + + for row in data: + if row.count != 1: + continue + + sr_item = frappe.db.get_value( + "Stock Reconciliation Item", row.voucher_detail_no, ["current_qty", "qty"], as_dict=True + ) + + if sr_item.qty and sr_item.current_qty: + self.stock_reco_voucher_wise_count[row.voucher_detail_no] = sr_item.current_qty + + def get_sre_reserved_qty_details(self) -> dict: + from erpnext.stock.doctype.stock_reservation_entry.stock_reservation_entry import ( + get_sre_reserved_qty_for_items_and_warehouses as get_reserved_qty_details, + ) + + item_code_list, warehouse_list = [], [] + for d in self.item_warehouse_map: + item_code_list.append(d[1]) + warehouse_list.append(d[2]) + + return get_reserved_qty_details(item_code_list, warehouse_list) + + def prepare_item_warehouse_map(self, item_warehouse_map, entry, group_by_key): + qty_dict = item_warehouse_map[group_by_key] + for field in self.inventory_dimensions: + qty_dict[field] = entry.get(field) + + if entry.voucher_type == "Stock Reconciliation" and ( + not entry.batch_no or entry.serial_no or entry.serial_and_batch_bundle + ): + if entry.serial_no and entry.voucher_detail_no in self.stock_reco_voucher_wise_count: + qty_dict.opening_qty -= self.stock_reco_voucher_wise_count.get(entry.voucher_detail_no, 0) + qty_dict.bal_qty = 0.0 + qty_diff = flt(entry.actual_qty) + value_diff = flt(entry.stock_value_difference) + else: + qty_diff = flt(entry.qty_after_transaction) - flt(qty_dict.bal_qty) + value_diff = flt(entry.stock_value) - flt(qty_dict.bal_val) + else: + qty_diff = flt(entry.actual_qty) + value_diff = flt(entry.stock_value_difference) + + if entry.posting_date < self.from_date or entry.voucher_no in self.opening_vouchers.get( + entry.voucher_type, [] + ): + qty_dict.opening_qty += qty_diff + qty_dict.opening_val += value_diff + + elif entry.posting_date >= self.from_date and entry.posting_date <= self.to_date: + if flt(qty_diff, self.float_precision) >= 0: + qty_dict.in_qty += qty_diff + else: + qty_dict.out_qty += abs(qty_diff) + + if flt(value_diff, self.float_precision) >= 0: + qty_dict.in_val += value_diff + else: + qty_dict.out_val += abs(value_diff) + + qty_dict.val_rate = entry.valuation_rate + qty_dict.bal_qty += qty_diff + qty_dict.bal_val += value_diff + + def initialize_data(self, item_warehouse_map, group_by_key, entry): + opening_data = self.opening_data.get(group_by_key, {}) + + item_warehouse_map[group_by_key] = frappe._dict( + { + "item_code": entry.item_code, + "warehouse": entry.warehouse, + "item_group": entry.item_group, + "company": entry.company, + "currency": self.company_currency, + "stock_uom": entry.stock_uom, + "item_name": entry.item_name, + "opening_qty": opening_data.get("bal_qty") or 0.0, + "opening_val": opening_data.get("bal_val") or 0.0, + "opening_fifo_queue": opening_data.get("fifo_queue") or [], + "in_qty": 0.0, + "in_val": 0.0, + "out_qty": 0.0, + "out_val": 0.0, + "bal_qty": opening_data.get("bal_qty") or 0.0, + "bal_val": opening_data.get("bal_val") or 0.0, + "val_rate": 0.0, + } + ) + + def get_group_by_key(self, row) -> tuple: + group_by_key = [row.company, row.item_code, row.warehouse] + + for fieldname in self.inventory_dimensions: + if not row.get(fieldname): + continue + + if self.filters.get(fieldname) or self.filters.get("show_dimension_wise_stock"): + group_by_key.append(row.get(fieldname)) + + return tuple(group_by_key) + + def get_closing_balance(self) -> list[dict[str, Any]]: + if self.filters.get("ignore_closing_balance"): + return [] + + table = frappe.qb.DocType("Closing Stock Balance") + + query = ( + frappe.qb.from_(table) + .select(table.name, table.to_date) + .where( + (table.docstatus == 1) + & (table.company == self.filters.get("company")) + & (table.to_date <= self.from_date) + & (table.status == "Completed") + ) + .orderby(table.to_date, order=Order.desc) + .limit(1) + ) + + for fieldname in ["warehouse", "item_code", "item_group", "warehouse_type"]: + if value := self.filters.get(fieldname): + if fieldname == "item_group": + groups = parse_filter_list(value) + if groups: + query = query.where(table[fieldname].isin(groups)) + elif isinstance(value, list | tuple): + query = query.where(table[fieldname].isin(value)) + else: + query = query.where(table[fieldname] == value) + + return query.run(as_dict=True) + + def prepare_stock_ledger_entries(self): + sle = frappe.qb.DocType("Stock Ledger Entry") + item_table = frappe.qb.DocType("Item") + + query = ( + frappe.qb.from_(sle) + .inner_join(item_table) + .on(sle.item_code == item_table.name) + .select( + sle.item_code, + sle.warehouse, + sle.posting_date, + sle.actual_qty, + sle.valuation_rate, + sle.company, + sle.voucher_type, + sle.qty_after_transaction, + sle.stock_value_difference, + sle.item_code.as_("name"), + sle.voucher_no, + sle.stock_value, + sle.batch_no, + sle.serial_no, + sle.serial_and_batch_bundle, + sle.voucher_detail_no, + item_table.has_serial_no, + item_table.has_batch_no, + item_table.item_group, + item_table.stock_uom, + item_table.item_name, + ) + .where((sle.docstatus < 2) & (sle.is_cancelled == 0)) + .orderby(sle.posting_datetime) + .orderby(sle.creation) + ) + + query = self.apply_inventory_dimensions_filters(query, sle) + query = self.apply_warehouse_filters(query, sle) + query = self.apply_items_filters(query, item_table) + query = self.apply_date_filters(query, sle) + + if self.filters.get("company"): + query = query.where(sle.company == self.filters.get("company")) + + self.sle_query = query + + def apply_inventory_dimensions_filters(self, query, sle) -> str: + inventory_dimension_fields = self.get_inventory_dimension_fields() + if inventory_dimension_fields: + for fieldname in inventory_dimension_fields: + query = query.select(fieldname) + if self.filters.get(fieldname): + query = query.where(sle[fieldname].isin(self.filters.get(fieldname))) + + return query + + def apply_warehouse_filters(self, query, sle) -> str: + warehouse_table = frappe.qb.DocType("Warehouse") + + if self.filters.get("warehouse"): + query = apply_warehouse_filter(query, sle, self.filters) + + elif warehouse_type := self.filters.get("warehouse_type"): + query = ( + query.join(warehouse_table) + .on(warehouse_table.name == sle.warehouse) + .where(warehouse_table.warehouse_type == warehouse_type) + ) + + return query + + def apply_items_filters(self, query, item_table) -> str: + if item_group := self.filters.get("item_group"): + children = get_item_groups_with_descendants(item_group) + if children: + query = query.where(item_table.item_group.isin(children)) + + if item_codes := self.filters.get("item_code"): + item_codes = parse_filter_list(item_codes) + if item_codes: + query = query.where(item_table.name.isin(item_codes)) + + if brand := self.filters.get("brand"): + query = query.where(item_table.brand == brand) + + return query + + def apply_date_filters(self, query, sle) -> str: + if not self.filters.get("ignore_closing_balance") and self.start_from: + query = query.where(sle.posting_date >= self.start_from) + + if self.to_date: + query = query.where(sle.posting_date <= self.to_date) + + return query + + def get_columns(self): + columns = [ + { + "label": _("Item"), + "fieldname": "item_code", + "fieldtype": "Link", + "options": "Item", + "width": 100, + }, + {"label": _("Item Name"), "fieldname": "item_name", "width": 150}, + { + "label": _("Item Group"), + "fieldname": "item_group", + "fieldtype": "Link", + "options": "Item Group", + "width": 100, + }, + { + "label": _("Warehouse"), + "fieldname": "warehouse", + "fieldtype": "Link", + "options": "Warehouse", + "width": 100, + }, + ] + + if self.filters.get("show_dimension_wise_stock"): + for dimension in get_inventory_dimensions(): + columns.append( + { + "label": _(dimension.doctype), + "fieldname": dimension.fieldname, + "fieldtype": "Link", + "options": dimension.doctype, + "width": 110, + } + ) + + columns.extend( + [ + { + "label": _("Stock UOM"), + "fieldname": "stock_uom", + "fieldtype": "Link", + "options": "UOM", + "width": 90, + }, + { + "label": _("Balance Qty"), + "fieldname": "bal_qty", + "fieldtype": "Float", + "width": 100, + "convertible": "qty", + }, + { + "label": _("Balance Value"), + "fieldname": "bal_val", + "fieldtype": "Currency", + "width": 100, + "options": "Company:company:default_currency", + }, + { + "label": _("Opening Qty"), + "fieldname": "opening_qty", + "fieldtype": "Float", + "width": 100, + "convertible": "qty", + }, + { + "label": _("Opening Value"), + "fieldname": "opening_val", + "fieldtype": "Currency", + "width": 110, + "options": "Company:company:default_currency", + }, + { + "label": _("In Qty"), + "fieldname": "in_qty", + "fieldtype": "Float", + "width": 80, + "convertible": "qty", + }, + {"label": _("In Value"), "fieldname": "in_val", "fieldtype": "Float", "width": 80}, + { + "label": _("Out Qty"), + "fieldname": "out_qty", + "fieldtype": "Float", + "width": 80, + "convertible": "qty", + }, + {"label": _("Out Value"), "fieldname": "out_val", "fieldtype": "Float", "width": 80}, + { + "label": _("Valuation Rate"), + "fieldname": "val_rate", + "fieldtype": self.filters.get("valuation_field_type") or "Currency", + "width": 90, + "convertible": "rate", + "options": "Company:company:default_currency" + if self.filters.get("valuation_field_type") == "Currency" + else None, + }, + { + "label": _("Reserved Stock"), + "fieldname": "reserved_stock", + "fieldtype": "Float", + "width": 80, + "convertible": "qty", + }, + { + "label": _("Company"), + "fieldname": "company", + "fieldtype": "Link", + "options": "Company", + "width": 100, + }, + ] + ) + + if self.filters.get("show_stock_ageing_data"): + columns += [ + {"label": _("Average Age"), "fieldname": "average_age", "width": 100}, + {"label": _("Earliest Age"), "fieldname": "earliest_age", "width": 100}, + {"label": _("Latest Age"), "fieldname": "latest_age", "width": 100}, + ] + + if self.filters.get("show_variant_attributes"): + columns += [ + {"label": att_name, "fieldname": att_name, "width": 100} + for att_name in get_variants_attributes() + ] + + return columns + + def add_additional_uom_columns(self): + if not self.filters.get("include_uom"): + return + + conversion_factors = self.get_itemwise_conversion_factor() + add_additional_uom_columns(self.columns, self.data, self.filters.include_uom, conversion_factors) + + def get_itemwise_conversion_factor(self): + items = [] + if self.filters.get("item_code") or self.filters.get("item_group"): + items = [d.item_code for d in self.data] + + table = frappe.qb.DocType("UOM Conversion Detail") + query = ( + frappe.qb.from_(table) + .select( + table.conversion_factor, + table.parent, + ) + .where((table.parenttype == "Item") & (table.uom == self.filters.include_uom)) + ) + + if items: + query = query.where(table.parent.isin(items)) + + result = query.run(as_dict=1) + if not result: + return {} + + return {d.parent: d.conversion_factor for d in result} + + def get_variant_values_for(self): + '''Returns variant values for items.''' + attribute_map = {} + items = [] + if self.filters.get("item_code") or self.filters.get("item_group"): + items = [d.item_code for d in self.data] + + filters = {} + if items: + filters = {"parent": ("in", items)} + + attribute_info = frappe.get_all( + "Item Variant Attribute", + fields=["parent", "attribute", "attribute_value"], + filters=filters, + ) + + for attr in attribute_info: + attribute_map.setdefault(attr["parent"], {}) + attribute_map[attr["parent"]].update({attr["attribute"]: attr["attribute_value"]}) + + return attribute_map + + def get_opening_vouchers(self): + opening_vouchers = {"Stock Entry": [], "Stock Reconciliation": []} + + se = frappe.qb.DocType("Stock Entry") + sr = frappe.qb.DocType("Stock Reconciliation") + + vouchers_data = ( + frappe.qb.from_( + ( + frappe.qb.from_(se) + .select(se.name, Coalesce("Stock Entry").as_("voucher_type")) + .where((se.docstatus == 1) & (se.posting_date <= self.to_date) & (se.is_opening == "Yes")) + ) + + ( + frappe.qb.from_(sr) + .select(sr.name, Coalesce("Stock Reconciliation").as_("voucher_type")) + .where( + (sr.docstatus == 1) + & (sr.posting_date <= self.to_date) + & (sr.purpose == "Opening Stock") + ) + ) + ).select("voucher_type", "name") + ).run(as_dict=True) + + if vouchers_data: + for d in vouchers_data: + opening_vouchers[d.voucher_type].append(d.name) + + return opening_vouchers + + @staticmethod + def get_inventory_dimension_fields(): + return [dimension.fieldname for dimension in get_inventory_dimensions()] + + @staticmethod + def get_opening_fifo_queue(report_data): + opening_fifo_queue = report_data.get("opening_fifo_queue") or [] + for row in opening_fifo_queue: + row[1] = getdate(row[1]) + + return opening_fifo_queue + + +def get_stock_ageing_data(fifo_queue: list, to_date: str) -> dict: + stock_ageing_data = {"average_age": 0, "earliest_age": 0, "latest_age": 0} + fifo_queue = sorted(filter(itemgetter(1), normalize_fifo_queue(fifo_queue)), key=itemgetter(1)) + + if not fifo_queue: + return stock_ageing_data + + stock_ageing_data["average_age"] = get_average_age(fifo_queue, to_date) + stock_ageing_data["earliest_age"] = date_diff(to_date, fifo_queue[0][1]) + stock_ageing_data["latest_age"] = date_diff(to_date, fifo_queue[-1][1]) + stock_ageing_data["fifo_queue"] = fifo_queue + + return stock_ageing_data + + +def filter_items_with_no_transactions( + iwb_map, float_precision: float, inventory_dimensions: list | None = None +): + pop_keys = [] + for group_by_key in iwb_map: + qty_dict = iwb_map[group_by_key] + + no_transactions = True + for key, val in qty_dict.items(): + if inventory_dimensions and key in inventory_dimensions: + continue + + if key in [ + "item_code", + "warehouse", + "item_name", + "item_group", + "project", + "stock_uom", + "company", + "opening_fifo_queue", + ]: + continue + + val = flt(val, float_precision) + qty_dict[key] = val + if key != "val_rate" and val: + no_transactions = False + + if no_transactions: + pop_keys.append(group_by_key) + + for key in pop_keys: + iwb_map.pop(key) + + return iwb_map + + +def get_variants_attributes() -> list[str]: + return frappe.get_all("Item Attribute", pluck="name") From 39b427647ee4c628ac678d2ed0cea2a979ccc610 Mon Sep 17 00:00:00 2001 From: Syed Mujeer Hashmi Date: Sat, 12 Sep 2026 12:19:16 +0530 Subject: [PATCH 2/2] refactor: subclass StockBalanceReport for custom stock balance report --- .../stock_balance_custom.js | 9 + .../stock_balance_custom.py | 674 +----------------- 2 files changed, 46 insertions(+), 637 deletions(-) diff --git a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js index e6248d6..3790425 100644 --- a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js +++ b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.js @@ -165,6 +165,15 @@ frappe.query_reports["Stock Balance Custom"] = { onload: function (report) { report.page.add_inner_button(__("View Stock Ledger"), function () { var filters = report.get_values(); + if (filters.item_group) { + if (Array.isArray(filters.item_group)) { + if (filters.item_group.length === 1) { + filters.item_group = filters.item_group[0]; + } else { + delete filters.item_group; + } + } + } frappe.set_route("query-report", "Stock Ledger", filters); }); }, diff --git a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py index 19ad48d..9a68178 100644 --- a/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py +++ b/spollex/spollex/report/stock_balance_custom/stock_balance_custom.py @@ -2,64 +2,45 @@ # License: GNU General Public License v3. See license.txt import json -from operator import itemgetter -from typing import Any, TypedDict +from typing import Any import frappe -from frappe import _ from frappe.query_builder import Order -from frappe.query_builder.functions import Coalesce, Count -from frappe.utils import add_days, cint, date_diff, flt, getdate +from frappe.query_builder.functions import Count from frappe.utils.nestedset import get_descendants_of -import erpnext -from erpnext.stock.doctype.inventory_dimension.inventory_dimension import get_inventory_dimensions -from erpnext.stock.doctype.warehouse.warehouse import apply_warehouse_filter -from erpnext.stock.report.stock_ageing.stock_ageing import ( - FIFOSlots, - get_average_age, - normalize_fifo_queue, +from erpnext.stock.report.stock_balance.stock_balance import ( + StockBalanceFilter, + StockBalanceReport, ) -from erpnext.stock.utils import add_additional_uom_columns -class StockBalanceFilter(TypedDict): - company: str | None - from_date: str - to_date: str - item_group: str | list[str] | None - item_code: list[str] | None - warehouse: list[str] | None - warehouse_type: str | None - include_uom: str | None # include extra info in converted UOM - show_stock_ageing_data: bool - show_variant_attributes: bool +def execute(filters: StockBalanceFilter | dict[str, Any] | None = None): + return StockBalanceCustomReport(filters).run() -SLEntry = dict[str, Any] +def parse_filter_list(val: Any) -> list[str]: + """Parse a filter value into a list of non-empty strings. - -def execute(filters: StockBalanceFilter | None = None): - return StockBalanceReport(filters).run() - - -def parse_filter_list(val): + Handles JSON lists (from frontend MultiSelectList), lists/tuples/sets, and single strings. + """ if not val: return [] if isinstance(val, str): try: parsed = json.loads(val) if isinstance(parsed, list): - return [x for x in parsed if x] + return [str(x) for x in parsed if x] except Exception: pass return [val] if isinstance(val, (list, tuple, set)): - return [x for x in val if x] - return [val] + return [str(x) for x in val if x] + return [str(val)] -def get_item_groups_with_descendants(item_groups): +def get_item_groups_with_descendants(item_groups: Any) -> list[str]: + """Return the given item groups and all their descendants in the tree hierarchy.""" groups = parse_filter_list(item_groups) if not groups: return [] @@ -73,141 +54,17 @@ def get_item_groups_with_descendants(item_groups): return list(all_groups) -class StockBalanceReport: - def __init__(self, filters: StockBalanceFilter | None) -> None: - self.filters = filters or {} - self.from_date = getdate(self.filters.get("from_date")) - self.to_date = getdate(self.filters.get("to_date")) - - self.start_from = None - self.data = [] - self.columns = [] - self.sle_entries: list[SLEntry] = [] - self.set_company_currency() - - def set_company_currency(self) -> None: - if self.filters.get("company"): - self.company_currency = erpnext.get_company_currency(self.filters.get("company")) - else: - self.company_currency = frappe.db.get_single_value("Global Defaults", "default_currency") - - def run(self): - self.float_precision = cint(frappe.db.get_default("float_precision")) or 3 - - self.inventory_dimensions = self.get_inventory_dimension_fields() - self.prepare_opening_data_from_closing_balance() - self.prepare_stock_ledger_entries() - self.prepare_new_data() - - if not self.columns: - self.columns = self.get_columns() - - self.add_additional_uom_columns() - - return self.columns, self.data - - def prepare_opening_data_from_closing_balance(self) -> None: - self.opening_data = frappe._dict({}) - - closing_balance = self.get_closing_balance() - if not closing_balance: - return - - self.start_from = add_days(closing_balance[0].to_date, 1) - res = frappe.get_doc("Closing Stock Balance", closing_balance[0].name).get_prepared_data() - - for entry in res.data: - entry = frappe._dict(entry) - - group_by_key = self.get_group_by_key(entry) - if group_by_key not in self.opening_data: - self.opening_data.setdefault(group_by_key, entry) - - def prepare_new_data(self): - self.item_warehouse_map = self.get_item_warehouse_map() - - if self.filters.get("show_stock_ageing_data"): - self.filters["show_warehouse_wise_stock"] = True - item_wise_fifo_queue = FIFOSlots(self.filters, self.sle_entries).generate() - - del self.sle_entries - - sre_details = self.get_sre_reserved_qty_details() - - variant_values = {} - if self.filters.get("show_variant_attributes"): - variant_values = self.get_variant_values_for() - - for _key, report_data in self.item_warehouse_map.items(): - if variant_data := variant_values.get(report_data.item_code): - report_data.update(variant_data) - - if self.filters.get("show_stock_ageing_data"): - opening_fifo_queue = self.get_opening_fifo_queue(report_data) or [] - - fifo_queue = [] - if fifo_queue := item_wise_fifo_queue.get((report_data.item_code, report_data.warehouse)): - fifo_queue = fifo_queue.get("fifo_queue") - - if fifo_queue: - opening_fifo_queue.extend(fifo_queue) - - stock_ageing_data = {"average_age": 0, "earliest_age": 0, "latest_age": 0} - if opening_fifo_queue: - stock_ageing_data.update(get_stock_ageing_data(opening_fifo_queue, self.to_date)) +class StockBalanceCustomReport(StockBalanceReport): + """Custom Stock Balance Report subclassing ERPNext's standard StockBalanceReport - report_data.update(stock_ageing_data) + Enhances standard functionality by supporting multiselect Item Group filters with descendant traversal. + """ - report_data.update( - {"reserved_stock": sre_details.get((report_data.item_code, report_data.warehouse), 0.0)} - ) - - if ( - not self.filters.get("include_zero_stock_items") - and report_data - and report_data.bal_qty == 0 - and report_data.bal_val == 0 - ): - continue - - self.data.append(report_data) - - def get_item_warehouse_map(self): - item_warehouse_map = {} - self.opening_vouchers = self.get_opening_vouchers() - - if self.filters.get("show_stock_ageing_data"): - self.sle_entries = self.sle_query.run(as_dict=True) - - self.prepare_stock_reco_voucher_wise_count() - - # HACK: This is required to avoid causing db query in flt - _system_settings = frappe.get_cached_doc("System Settings") - with frappe.db.unbuffered_cursor(): - if not self.filters.get("show_stock_ageing_data"): - self.sle_entries = self.sle_query.run(as_dict=True, as_iterator=True) - - for entry in self.sle_entries: - group_by_key = self.get_group_by_key(entry) - if group_by_key not in item_warehouse_map: - self.initialize_data(item_warehouse_map, group_by_key, entry) - - self.prepare_item_warehouse_map(item_warehouse_map, entry, group_by_key) - - if self.opening_data.get(group_by_key): - del self.opening_data[group_by_key] - - for group_by_key, entry in self.opening_data.items(): - if group_by_key not in item_warehouse_map: - self.initialize_data(item_warehouse_map, group_by_key, entry) - - item_warehouse_map = filter_items_with_no_transactions( - item_warehouse_map, self.float_precision, self.inventory_dimensions - ) - - return item_warehouse_map + def __init__(self, filters: StockBalanceFilter | dict[str, Any] | None = None) -> None: + # Ensure self.filters is a frappe._dict for consistent attribute & dict-style access + super().__init__(frappe._dict(filters or {})) - def prepare_stock_reco_voucher_wise_count(self): + def prepare_stock_reco_voucher_wise_count(self) -> None: self.stock_reco_voucher_wise_count = frappe._dict() doctype = frappe.qb.DocType("Stock Ledger Entry") @@ -233,20 +90,20 @@ def prepare_stock_reco_voucher_wise_count(self): query = query.where(item.name.isin(items)) if self.filters.get("item_group"): - childrens = get_item_groups_with_descendants(self.filters.get("item_group")) - if childrens: - query = query.where(item.item_group.isin(childrens)) + children = get_item_groups_with_descendants(self.filters.get("item_group")) + if children: + query = query.where(item.item_group.isin(children)) if warehouses := self.filters.get("warehouse"): warehouses = parse_filter_list(warehouses) - childrens = [] + children = [] for warehouse in warehouses: - childrens.append(warehouse) - if warehouse_childrens := get_descendants_of("Warehouse", warehouse, ignore_permissions=True): - childrens.extend(warehouse_childrens) + children.append(warehouse) + if warehouse_children := get_descendants_of("Warehouse", warehouse, ignore_permissions=True): + children.extend(warehouse_children) - if childrens: - query = query.where(doctype.warehouse.isin(childrens)) + if children: + query = query.where(doctype.warehouse.isin(children)) data = query.run(as_dict=True) if not data: @@ -260,99 +117,9 @@ def prepare_stock_reco_voucher_wise_count(self): "Stock Reconciliation Item", row.voucher_detail_no, ["current_qty", "qty"], as_dict=True ) - if sr_item.qty and sr_item.current_qty: + if sr_item and sr_item.qty and sr_item.current_qty: self.stock_reco_voucher_wise_count[row.voucher_detail_no] = sr_item.current_qty - def get_sre_reserved_qty_details(self) -> dict: - from erpnext.stock.doctype.stock_reservation_entry.stock_reservation_entry import ( - get_sre_reserved_qty_for_items_and_warehouses as get_reserved_qty_details, - ) - - item_code_list, warehouse_list = [], [] - for d in self.item_warehouse_map: - item_code_list.append(d[1]) - warehouse_list.append(d[2]) - - return get_reserved_qty_details(item_code_list, warehouse_list) - - def prepare_item_warehouse_map(self, item_warehouse_map, entry, group_by_key): - qty_dict = item_warehouse_map[group_by_key] - for field in self.inventory_dimensions: - qty_dict[field] = entry.get(field) - - if entry.voucher_type == "Stock Reconciliation" and ( - not entry.batch_no or entry.serial_no or entry.serial_and_batch_bundle - ): - if entry.serial_no and entry.voucher_detail_no in self.stock_reco_voucher_wise_count: - qty_dict.opening_qty -= self.stock_reco_voucher_wise_count.get(entry.voucher_detail_no, 0) - qty_dict.bal_qty = 0.0 - qty_diff = flt(entry.actual_qty) - value_diff = flt(entry.stock_value_difference) - else: - qty_diff = flt(entry.qty_after_transaction) - flt(qty_dict.bal_qty) - value_diff = flt(entry.stock_value) - flt(qty_dict.bal_val) - else: - qty_diff = flt(entry.actual_qty) - value_diff = flt(entry.stock_value_difference) - - if entry.posting_date < self.from_date or entry.voucher_no in self.opening_vouchers.get( - entry.voucher_type, [] - ): - qty_dict.opening_qty += qty_diff - qty_dict.opening_val += value_diff - - elif entry.posting_date >= self.from_date and entry.posting_date <= self.to_date: - if flt(qty_diff, self.float_precision) >= 0: - qty_dict.in_qty += qty_diff - else: - qty_dict.out_qty += abs(qty_diff) - - if flt(value_diff, self.float_precision) >= 0: - qty_dict.in_val += value_diff - else: - qty_dict.out_val += abs(value_diff) - - qty_dict.val_rate = entry.valuation_rate - qty_dict.bal_qty += qty_diff - qty_dict.bal_val += value_diff - - def initialize_data(self, item_warehouse_map, group_by_key, entry): - opening_data = self.opening_data.get(group_by_key, {}) - - item_warehouse_map[group_by_key] = frappe._dict( - { - "item_code": entry.item_code, - "warehouse": entry.warehouse, - "item_group": entry.item_group, - "company": entry.company, - "currency": self.company_currency, - "stock_uom": entry.stock_uom, - "item_name": entry.item_name, - "opening_qty": opening_data.get("bal_qty") or 0.0, - "opening_val": opening_data.get("bal_val") or 0.0, - "opening_fifo_queue": opening_data.get("fifo_queue") or [], - "in_qty": 0.0, - "in_val": 0.0, - "out_qty": 0.0, - "out_val": 0.0, - "bal_qty": opening_data.get("bal_qty") or 0.0, - "bal_val": opening_data.get("bal_val") or 0.0, - "val_rate": 0.0, - } - ) - - def get_group_by_key(self, row) -> tuple: - group_by_key = [row.company, row.item_code, row.warehouse] - - for fieldname in self.inventory_dimensions: - if not row.get(fieldname): - continue - - if self.filters.get(fieldname) or self.filters.get("show_dimension_wise_stock"): - group_by_key.append(row.get(fieldname)) - - return tuple(group_by_key) - def get_closing_balance(self) -> list[dict[str, Any]]: if self.filters.get("ignore_closing_balance"): return [] @@ -378,85 +145,14 @@ def get_closing_balance(self) -> list[dict[str, Any]]: groups = parse_filter_list(value) if groups: query = query.where(table[fieldname].isin(groups)) - elif isinstance(value, list | tuple): - query = query.where(table[fieldname].isin(value)) + elif isinstance(value, (list, tuple, set)): + query = query.where(table[fieldname].isin(list(value))) else: query = query.where(table[fieldname] == value) return query.run(as_dict=True) - def prepare_stock_ledger_entries(self): - sle = frappe.qb.DocType("Stock Ledger Entry") - item_table = frappe.qb.DocType("Item") - - query = ( - frappe.qb.from_(sle) - .inner_join(item_table) - .on(sle.item_code == item_table.name) - .select( - sle.item_code, - sle.warehouse, - sle.posting_date, - sle.actual_qty, - sle.valuation_rate, - sle.company, - sle.voucher_type, - sle.qty_after_transaction, - sle.stock_value_difference, - sle.item_code.as_("name"), - sle.voucher_no, - sle.stock_value, - sle.batch_no, - sle.serial_no, - sle.serial_and_batch_bundle, - sle.voucher_detail_no, - item_table.has_serial_no, - item_table.has_batch_no, - item_table.item_group, - item_table.stock_uom, - item_table.item_name, - ) - .where((sle.docstatus < 2) & (sle.is_cancelled == 0)) - .orderby(sle.posting_datetime) - .orderby(sle.creation) - ) - - query = self.apply_inventory_dimensions_filters(query, sle) - query = self.apply_warehouse_filters(query, sle) - query = self.apply_items_filters(query, item_table) - query = self.apply_date_filters(query, sle) - - if self.filters.get("company"): - query = query.where(sle.company == self.filters.get("company")) - - self.sle_query = query - - def apply_inventory_dimensions_filters(self, query, sle) -> str: - inventory_dimension_fields = self.get_inventory_dimension_fields() - if inventory_dimension_fields: - for fieldname in inventory_dimension_fields: - query = query.select(fieldname) - if self.filters.get(fieldname): - query = query.where(sle[fieldname].isin(self.filters.get(fieldname))) - - return query - - def apply_warehouse_filters(self, query, sle) -> str: - warehouse_table = frappe.qb.DocType("Warehouse") - - if self.filters.get("warehouse"): - query = apply_warehouse_filter(query, sle, self.filters) - - elif warehouse_type := self.filters.get("warehouse_type"): - query = ( - query.join(warehouse_table) - .on(warehouse_table.name == sle.warehouse) - .where(warehouse_table.warehouse_type == warehouse_type) - ) - - return query - - def apply_items_filters(self, query, item_table) -> str: + def apply_items_filters(self, query, item_table): if item_group := self.filters.get("item_group"): children = get_item_groups_with_descendants(item_group) if children: @@ -471,299 +167,3 @@ def apply_items_filters(self, query, item_table) -> str: query = query.where(item_table.brand == brand) return query - - def apply_date_filters(self, query, sle) -> str: - if not self.filters.get("ignore_closing_balance") and self.start_from: - query = query.where(sle.posting_date >= self.start_from) - - if self.to_date: - query = query.where(sle.posting_date <= self.to_date) - - return query - - def get_columns(self): - columns = [ - { - "label": _("Item"), - "fieldname": "item_code", - "fieldtype": "Link", - "options": "Item", - "width": 100, - }, - {"label": _("Item Name"), "fieldname": "item_name", "width": 150}, - { - "label": _("Item Group"), - "fieldname": "item_group", - "fieldtype": "Link", - "options": "Item Group", - "width": 100, - }, - { - "label": _("Warehouse"), - "fieldname": "warehouse", - "fieldtype": "Link", - "options": "Warehouse", - "width": 100, - }, - ] - - if self.filters.get("show_dimension_wise_stock"): - for dimension in get_inventory_dimensions(): - columns.append( - { - "label": _(dimension.doctype), - "fieldname": dimension.fieldname, - "fieldtype": "Link", - "options": dimension.doctype, - "width": 110, - } - ) - - columns.extend( - [ - { - "label": _("Stock UOM"), - "fieldname": "stock_uom", - "fieldtype": "Link", - "options": "UOM", - "width": 90, - }, - { - "label": _("Balance Qty"), - "fieldname": "bal_qty", - "fieldtype": "Float", - "width": 100, - "convertible": "qty", - }, - { - "label": _("Balance Value"), - "fieldname": "bal_val", - "fieldtype": "Currency", - "width": 100, - "options": "Company:company:default_currency", - }, - { - "label": _("Opening Qty"), - "fieldname": "opening_qty", - "fieldtype": "Float", - "width": 100, - "convertible": "qty", - }, - { - "label": _("Opening Value"), - "fieldname": "opening_val", - "fieldtype": "Currency", - "width": 110, - "options": "Company:company:default_currency", - }, - { - "label": _("In Qty"), - "fieldname": "in_qty", - "fieldtype": "Float", - "width": 80, - "convertible": "qty", - }, - {"label": _("In Value"), "fieldname": "in_val", "fieldtype": "Float", "width": 80}, - { - "label": _("Out Qty"), - "fieldname": "out_qty", - "fieldtype": "Float", - "width": 80, - "convertible": "qty", - }, - {"label": _("Out Value"), "fieldname": "out_val", "fieldtype": "Float", "width": 80}, - { - "label": _("Valuation Rate"), - "fieldname": "val_rate", - "fieldtype": self.filters.get("valuation_field_type") or "Currency", - "width": 90, - "convertible": "rate", - "options": "Company:company:default_currency" - if self.filters.get("valuation_field_type") == "Currency" - else None, - }, - { - "label": _("Reserved Stock"), - "fieldname": "reserved_stock", - "fieldtype": "Float", - "width": 80, - "convertible": "qty", - }, - { - "label": _("Company"), - "fieldname": "company", - "fieldtype": "Link", - "options": "Company", - "width": 100, - }, - ] - ) - - if self.filters.get("show_stock_ageing_data"): - columns += [ - {"label": _("Average Age"), "fieldname": "average_age", "width": 100}, - {"label": _("Earliest Age"), "fieldname": "earliest_age", "width": 100}, - {"label": _("Latest Age"), "fieldname": "latest_age", "width": 100}, - ] - - if self.filters.get("show_variant_attributes"): - columns += [ - {"label": att_name, "fieldname": att_name, "width": 100} - for att_name in get_variants_attributes() - ] - - return columns - - def add_additional_uom_columns(self): - if not self.filters.get("include_uom"): - return - - conversion_factors = self.get_itemwise_conversion_factor() - add_additional_uom_columns(self.columns, self.data, self.filters.include_uom, conversion_factors) - - def get_itemwise_conversion_factor(self): - items = [] - if self.filters.get("item_code") or self.filters.get("item_group"): - items = [d.item_code for d in self.data] - - table = frappe.qb.DocType("UOM Conversion Detail") - query = ( - frappe.qb.from_(table) - .select( - table.conversion_factor, - table.parent, - ) - .where((table.parenttype == "Item") & (table.uom == self.filters.include_uom)) - ) - - if items: - query = query.where(table.parent.isin(items)) - - result = query.run(as_dict=1) - if not result: - return {} - - return {d.parent: d.conversion_factor for d in result} - - def get_variant_values_for(self): - '''Returns variant values for items.''' - attribute_map = {} - items = [] - if self.filters.get("item_code") or self.filters.get("item_group"): - items = [d.item_code for d in self.data] - - filters = {} - if items: - filters = {"parent": ("in", items)} - - attribute_info = frappe.get_all( - "Item Variant Attribute", - fields=["parent", "attribute", "attribute_value"], - filters=filters, - ) - - for attr in attribute_info: - attribute_map.setdefault(attr["parent"], {}) - attribute_map[attr["parent"]].update({attr["attribute"]: attr["attribute_value"]}) - - return attribute_map - - def get_opening_vouchers(self): - opening_vouchers = {"Stock Entry": [], "Stock Reconciliation": []} - - se = frappe.qb.DocType("Stock Entry") - sr = frappe.qb.DocType("Stock Reconciliation") - - vouchers_data = ( - frappe.qb.from_( - ( - frappe.qb.from_(se) - .select(se.name, Coalesce("Stock Entry").as_("voucher_type")) - .where((se.docstatus == 1) & (se.posting_date <= self.to_date) & (se.is_opening == "Yes")) - ) - + ( - frappe.qb.from_(sr) - .select(sr.name, Coalesce("Stock Reconciliation").as_("voucher_type")) - .where( - (sr.docstatus == 1) - & (sr.posting_date <= self.to_date) - & (sr.purpose == "Opening Stock") - ) - ) - ).select("voucher_type", "name") - ).run(as_dict=True) - - if vouchers_data: - for d in vouchers_data: - opening_vouchers[d.voucher_type].append(d.name) - - return opening_vouchers - - @staticmethod - def get_inventory_dimension_fields(): - return [dimension.fieldname for dimension in get_inventory_dimensions()] - - @staticmethod - def get_opening_fifo_queue(report_data): - opening_fifo_queue = report_data.get("opening_fifo_queue") or [] - for row in opening_fifo_queue: - row[1] = getdate(row[1]) - - return opening_fifo_queue - - -def get_stock_ageing_data(fifo_queue: list, to_date: str) -> dict: - stock_ageing_data = {"average_age": 0, "earliest_age": 0, "latest_age": 0} - fifo_queue = sorted(filter(itemgetter(1), normalize_fifo_queue(fifo_queue)), key=itemgetter(1)) - - if not fifo_queue: - return stock_ageing_data - - stock_ageing_data["average_age"] = get_average_age(fifo_queue, to_date) - stock_ageing_data["earliest_age"] = date_diff(to_date, fifo_queue[0][1]) - stock_ageing_data["latest_age"] = date_diff(to_date, fifo_queue[-1][1]) - stock_ageing_data["fifo_queue"] = fifo_queue - - return stock_ageing_data - - -def filter_items_with_no_transactions( - iwb_map, float_precision: float, inventory_dimensions: list | None = None -): - pop_keys = [] - for group_by_key in iwb_map: - qty_dict = iwb_map[group_by_key] - - no_transactions = True - for key, val in qty_dict.items(): - if inventory_dimensions and key in inventory_dimensions: - continue - - if key in [ - "item_code", - "warehouse", - "item_name", - "item_group", - "project", - "stock_uom", - "company", - "opening_fifo_queue", - ]: - continue - - val = flt(val, float_precision) - qty_dict[key] = val - if key != "val_rate" and val: - no_transactions = False - - if no_transactions: - pop_keys.append(group_by_key) - - for key in pop_keys: - iwb_map.pop(key) - - return iwb_map - - -def get_variants_attributes() -> list[str]: - return frappe.get_all("Item Attribute", pluck="name")