diff --git a/spollex/spollex/report/accounts_payable_with_rebate_received/accounts_payable_with_rebate_received.py b/spollex/spollex/report/accounts_payable_with_rebate_received/accounts_payable_with_rebate_received.py
index 0376cd8..fdb7b07 100644
--- a/spollex/spollex/report/accounts_payable_with_rebate_received/accounts_payable_with_rebate_received.py
+++ b/spollex/spollex/report/accounts_payable_with_rebate_received/accounts_payable_with_rebate_received.py
@@ -1,11 +1,17 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
-from spollex.spollex.report.accounts_receivable_with_rebate_given.accounts_receivable_with_rebate_given import ReceivablePayableReport
+from spollex.spollex.report.accounts_receivable_with_rebate_given.accounts_receivable_with_rebate_given import (
+ SpollexReceivablePayableReport,
+)
+
def execute(filters=None):
args = {
"account_type": "Payable",
"naming_by": ["Buying Settings", "supp_master_name"],
}
- return ReceivablePayableReport(filters).run(args)
+ return SpollexReceivablePayableReport(filters).run(args)
+
+
+ReceivablePayableReport = SpollexReceivablePayableReport
diff --git a/spollex/spollex/report/accounts_receivable_for_sales_user/accounts_receivable_for_sales_user.py b/spollex/spollex/report/accounts_receivable_for_sales_user/accounts_receivable_for_sales_user.py
index 3b62b5a..23be0f6 100644
--- a/spollex/spollex/report/accounts_receivable_for_sales_user/accounts_receivable_for_sales_user.py
+++ b/spollex/spollex/report/accounts_receivable_for_sales_user/accounts_receivable_for_sales_user.py
@@ -1,34 +1,11 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
-from collections import OrderedDict
-
import frappe
-from frappe import _, qb, query_builder, scrub
-from frappe.query_builder import Criterion
-from frappe.query_builder.functions import Date, Substring, Sum
-from frappe.utils import cint, cstr, flt, getdate, nowdate
-
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
- get_accounting_dimensions,
- get_dimension_with_children,
+from erpnext.accounts.report.accounts_receivable import accounts_receivable
+from spollex.spollex.report.accounts_receivable_with_rebate_given.accounts_receivable_with_rebate_given import (
+ SpollexReceivablePayableReport,
)
-from erpnext.accounts.utils import get_currency_precision, get_party_types_from_account_type
-
-# This report gives a summary of all Outstanding Invoices considering the following
-
-# 1. Invoice can be booked via Sales/Purchase Invoice or Journal Entry
-# 2. Report handles both receivable and payable
-# 3. Key balances for each row are "Invoiced Amount", "Paid Amount", "Credit/Debit Note Amount", "Oustanding Amount"
-# 4. For explicit payment terms in invoice (example: 30% advance, 30% on delivery, 40% post delivery),
-# the invoice will be broken up into multiple rows, one for each payment term
-# 5. If there are payments after the report date (post dated), these will be updated in additional columns
-# for future amount
-# 6. Configurable Ageing Groups (0-30, 30-60 etc) can be set via filters
-# 7. For overpayment against an invoice with payment terms, there will be an additional row
-# 8. Invoice details like Sales Persons, Delivery Notes are also fetched comma separated
-# 9. Report amounts are in party currency if in_party_currency is selected, otherwise company currency
-# 10. This report is based on Payment Ledger Entries
def execute(filters=None):
@@ -36,891 +13,65 @@ def execute(filters=None):
"account_type": "Receivable",
"naming_by": ["Selling Settings", "cust_master_name"],
}
- return ReceivablePayableReport(filters).run(args)
-
-
-class ReceivablePayableReport:
- def __init__(self, filters=None):
- self.filters = frappe._dict(filters or {})
- self.qb_selection_filter = []
- self.ple = qb.DocType("Payment Ledger Entry")
- self.filters.report_date = getdate(self.filters.report_date or nowdate())
- self.age_as_on = (
- getdate(nowdate()) if self.filters.report_date > getdate(nowdate()) else self.filters.report_date
- )
+ return AccountsReceivableForSalesUser(filters).run(args)
- if not self.filters.range:
- self.filters.range = "30, 60, 90, 120"
- self.ranges = [num.strip() for num in self.filters.range.split(",") if num.strip().isdigit()]
- self.range_numbers = [num for num in range(1, len(self.ranges) + 2)]
- def run(self, args):
- self.filters.update(args)
- self.set_defaults()
- self.party_naming_by = frappe.db.get_value(args.get("naming_by")[0], None, args.get("naming_by")[1])
- self.get_columns()
- self.get_data()
- self.get_chart_data()
- return self.columns, self.data, None, self.chart, None, self.skip_total_row
+class AccountsReceivableForSalesUser(SpollexReceivablePayableReport):
+ def prepare_ple_query(self):
+ # Temporarily ignore PermissionError when building match conditions for Payment Ledger Entry,
+ # because Sales User roles do not have direct read permission to raw Payment Ledger Entry.
+ orig_build_qb = accounts_receivable.build_qb_match_conditions
- def set_defaults(self):
- if not self.filters.get("company"):
- self.filters.company = frappe.db.get_single_value("Global Defaults", "default_company")
- self.company_currency = frappe.get_cached_value(
- "Company", self.filters.get("company"), "default_currency"
- )
- self.currency_precision = get_currency_precision() or 2
- self.dr_or_cr = "debit" if self.filters.account_type == "Receivable" else "credit"
- self.account_type = self.filters.account_type
- self.party_type = get_party_types_from_account_type(self.account_type)
- self.party_details = {}
- self.invoices = set()
- self.skip_total_row = 0
-
- if self.filters.get("group_by_party"):
- self.previous_party = ""
- self.total_row_map = {}
- self.skip_total_row = 1
+ def safe_build_qb(doctype):
+ try:
+ return orig_build_qb(doctype)
+ except frappe.PermissionError:
+ return []
- if self.filters.get("in_party_currency"):
- if self.filters.get("party") and len(self.filters.get("party")) == 1:
- self.skip_total_row = 0
- else:
- self.skip_total_row = 1
+ accounts_receivable.build_qb_match_conditions = safe_build_qb
+ try:
+ super().prepare_ple_query()
+ finally:
+ accounts_receivable.build_qb_match_conditions = orig_build_qb
- def get_data(self):
- self.get_ple_entries()
+ def fetch_ple_in_buffered_cursor(self):
+ self.ple_entries = self.ple_query.run(as_dict=True)
self.filter_ple_entries_by_user_sales_person()
- self.get_sales_invoices_or_customers_based_on_sales_person()
- self.voucher_balance = OrderedDict()
- self.init_voucher_balance() # invoiced, paid, credit_note, outstanding
-
- # Build delivery note map against all sales invoices
- self.build_delivery_note_map()
-
- # Get invoice details like bill_no, due_date etc for all invoices
- self.get_invoice_details()
-
- # fetch future payments against invoices
- self.get_future_payments()
-
- # Get return entries
- self.get_return_entries()
-
- # Get Exchange Rate Revaluations
- self.get_exchange_rate_revaluations()
-
- self.data = []
for ple in self.ple_entries:
- self.update_voucher_balance(ple)
+ self.init_voucher_balance(ple)
- self.build_data()
-
- def build_voucher_dict(self, ple):
- return frappe._dict(
- voucher_type=ple.voucher_type,
- voucher_no=ple.voucher_no,
- party=ple.party,
- party_account=ple.account,
- posting_date=ple.posting_date,
- account_currency=ple.account_currency,
- remarks=ple.remarks,
- invoiced=0.0,
- paid=0.0,
- credit_note=0.0,
- outstanding=0.0,
- invoiced_in_account_currency=0.0,
- paid_in_account_currency=0.0,
- credit_note_in_account_currency=0.0,
- outstanding_in_account_currency=0.0,
- cost_center=ple.cost_center,
- )
-
- def init_voucher_balance(self):
- # build all keys, since we want to exclude vouchers beyond the report date
for ple in self.ple_entries:
- # get the balance object for voucher_type
-
- if self.filters.get("ignore_accounts"):
- key = (ple.voucher_type, ple.voucher_no, ple.party)
- else:
- key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
-
- if key not in self.voucher_balance:
- self.voucher_balance[key] = self.build_voucher_dict(ple)
-
- self.get_invoices(ple)
-
- if self.filters.get("group_by_party"):
- self.init_subtotal_row(ple.party)
-
- if self.filters.get("group_by_party") and not self.filters.get("in_party_currency"):
- self.init_subtotal_row("Total")
-
- def get_invoices(self, ple):
- print(ple)
- if ple.voucher_type in ("Sales Invoice", "Purchase Invoice"):
- if self.filters.get("sales_person"):
- if ple.voucher_no in self.sales_person_records.get(
- "Sales Invoice", []
- ) or ple.party in self.sales_person_records.get("Customer", []):
- self.invoices.add(ple.voucher_no)
- else:
- self.invoices.add(ple.voucher_no)
-
- def init_subtotal_row(self, party):
- if not self.total_row_map.get(party):
- self.total_row_map.setdefault(party, {"party": party, "bold": 1})
-
- for field in self.get_currency_fields():
- self.total_row_map[party][field] = 0.0
-
- def get_currency_fields(self):
- return [
- "invoiced",
- "paid",
- "credit_note",
- "outstanding",
- "range1",
- "range2",
- "range3",
- "range4",
- "range5",
- "future_amount",
- "remaining_balance",
- ]
-
- def get_voucher_balance(self, ple):
- if self.filters.get("sales_person"):
- if not (
- ple.party in self.sales_person_records.get("Customer", [])
- or ple.against_voucher_no in self.sales_person_records.get("Sales Invoice", [])
- ):
- return
-
- if self.filters.get("ignore_accounts"):
- key = (ple.against_voucher_type, ple.against_voucher_no, ple.party)
- else:
- key = (ple.account, ple.against_voucher_type, ple.against_voucher_no, ple.party)
-
- # If payment is made against credit note
- # and credit note is made against a Sales Invoice
- # then consider the payment against original sales invoice.
- if ple.against_voucher_type in ("Sales Invoice", "Purchase Invoice"):
- if ple.against_voucher_no in self.return_entries:
- return_against = self.return_entries.get(ple.against_voucher_no)
- if return_against:
- if self.filters.get("ignore_accounts"):
- key = (ple.against_voucher_type, return_against, ple.party)
- else:
- key = (ple.account, ple.against_voucher_type, return_against, ple.party)
-
- row = self.voucher_balance.get(key)
-
- # Build and use a separate row for Employee Advances.
- # This allows Payments or Journals made against Emp Advance to be processed.
- if (
- not row
- and ple.against_voucher_type == "Employee Advance"
- and self.filters.handle_employee_advances
- ):
- _d = self.build_voucher_dict(ple)
- _d.voucher_type = ple.against_voucher_type
- _d.voucher_no = ple.against_voucher_no
- row = self.voucher_balance[key] = _d
-
- if not row:
- # no invoice, this is an invoice / stand-alone payment / credit note
- if self.filters.get("ignore_accounts"):
- row = self.voucher_balance.get((ple.voucher_type, ple.voucher_no, ple.party))
- else:
- row = self.voucher_balance.get((ple.account, ple.voucher_type, ple.voucher_no, ple.party))
-
- row.party_type = ple.party_type
- return row
-
- def update_voucher_balance(self, ple):
- # get the row where this balance needs to be updated
- # if its a payment, it will return the linked invoice or will be considered as advance
- row = self.get_voucher_balance(ple)
- if not row:
- return
-
- if self.filters.get("in_party_currency") or self.filters.get("party_account"):
- amount = ple.amount_in_account_currency
- else:
- amount = ple.amount
- amount_in_account_currency = ple.amount_in_account_currency
-
- # update voucher
- if ple.amount > 0:
- if (
- ple.voucher_type in ["Journal Entry", "Payment Entry"]
- and ple.voucher_no != ple.against_voucher_no
- ):
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
- else:
- row.invoiced += amount
- row.invoiced_in_account_currency += amount_in_account_currency
- else:
- if self.is_invoice(ple):
- if row.voucher_no == ple.voucher_no == ple.against_voucher_no:
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
- else:
- row.credit_note -= amount
- row.credit_note_in_account_currency -= amount_in_account_currency
- else:
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
-
- if not row.cost_center and ple.cost_center:
- row.cost_center = str(ple.cost_center)
-
- def update_sub_total_row(self, row, party):
- total_row = self.total_row_map.get(party)
-
- if total_row:
- for field in self.get_currency_fields():
- total_row[field] += row.get(field, 0.0)
- total_row["currency"] = row.get("currency", "")
-
- def append_subtotal_row(self, party):
- sub_total_row = self.total_row_map.get(party)
-
- if sub_total_row:
- self.data.append(sub_total_row)
- self.data.append({})
- self.update_sub_total_row(sub_total_row, "Total")
-
- def build_data(self):
- # set outstanding for all the accumulated balances
- # as we can use this to filter out invoices without outstanding
- for _key, row in self.voucher_balance.items():
- if row.voucher_type != "Sales Invoice": # Filter out non-"Sales Invoice"
- continue
- row.outstanding = flt(row.invoiced - row.paid - row.credit_note, self.currency_precision)
- row.outstanding_in_account_currency = flt(
- row.invoiced_in_account_currency
- - row.paid_in_account_currency
- - row.credit_note_in_account_currency,
- self.currency_precision,
- )
-
- row.invoice_grand_total = row.invoiced
-
- must_consider = False
- if self.filters.get("for_revaluation_journals"):
- if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) or (
- abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision
- ):
- must_consider = True
- else:
- if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) and (
- (abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision)
- or (row.voucher_no in self.err_journals)
- ):
- must_consider = True
-
- if must_consider:
- # non-zero oustanding, we must consider this row
-
- if self.is_invoice(row) and self.filters.based_on_payment_terms:
- # is an invoice, allocate based on fifo
- # adds a list `payment_terms` which contains new rows for each term
- self.allocate_outstanding_based_on_payment_terms(row)
-
- if row.payment_terms:
- # make separate rows for each payment term
- for d in row.payment_terms:
- if d.outstanding > 0:
- self.append_row(d)
-
- # if there is overpayment, add another row
- self.allocate_extra_payments_or_credits(row)
- else:
- self.append_row(row)
- else:
- self.append_row(row)
-
- if self.filters.get("group_by_party"):
- self.append_subtotal_row(self.previous_party)
- if self.data:
- self.data.append(self.total_row_map.get("Total", {}))
-
- def append_row(self, row):
- self.allocate_future_payments(row)
- self.set_invoice_details(row)
- self.set_party_details(row)
- self.set_ageing(row)
-
- if self.filters.get("group_by_party"):
- self.update_sub_total_row(row, row.party)
- if self.previous_party and (self.previous_party != row.party):
- self.append_subtotal_row(self.previous_party)
- self.previous_party = row.party
-
- if row.due_date < getdate(nowdate()):
- row["overdue"] = 1
- self.data.append(row)
-
- def set_invoice_details(self, row):
- invoice_details = self.invoice_details.get(row.voucher_no, {})
-
- if row.due_date:
-
- invoice_details.pop("due_date", None)
-
- row.update(invoice_details)
-
- if "rebate_received" in invoice_details:
- row["rebate_received"] = invoice_details["rebate_received"]
- row["paid"] = row["paid"] - row["rebate_received"]
- elif "rebate_given" in invoice_details:
- row["rebate_given"] = invoice_details["rebate_given"]
- row["paid"] = row["paid"] - row["rebate_given"]
-
- if row.voucher_type == "Sales Invoice":
- if self.filters.show_delivery_notes:
- self.set_delivery_notes(row)
-
- if self.filters.show_sales_person and row.sales_team:
- row.sales_person = ", ".join(row.sales_team)
- del row["sales_team"]
-
- def set_delivery_notes(self, row):
- delivery_notes = self.delivery_notes.get(row.voucher_no, [])
- if delivery_notes:
- row.delivery_notes = ", ".join(delivery_notes)
-
- def build_delivery_note_map(self):
- if self.invoices and self.filters.show_delivery_notes:
- self.delivery_notes = frappe._dict()
-
- # delivery note link inside sales invoice
- # nosemgrep
- si_against_dn = frappe.db.sql(
- """
- select parent, delivery_note
- from `tabSales Invoice Item`
- where docstatus=1 and parent in (%s)
- """
- % (",".join(["%s"] * len(self.invoices))),
- tuple(self.invoices),
- as_dict=1,
- )
-
- for d in si_against_dn:
- if d.delivery_note:
- self.delivery_notes.setdefault(d.parent, set()).add(d.delivery_note)
-
- # nosemgrep
- dn_against_si = frappe.db.sql(
- """
- select distinct parent, against_sales_invoice
- from `tabDelivery Note Item`
- where against_sales_invoice in (%s)
- """
- % (",".join(["%s"] * len(self.invoices))),
- tuple(self.invoices),
- as_dict=1,
- )
-
- for d in dn_against_si:
- self.delivery_notes.setdefault(d.against_sales_invoice, set()).add(d.parent)
-
- def get_invoice_details(self):
- self.invoice_details = frappe._dict()
- if self.account_type == "Receivable":
- # nosemgrep
- si_list = frappe.db.sql(
- """
- select name, due_date, po_no
- from `tabSales Invoice`
- where posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
- )
-
- for d in si_list:
- default_receivable_account = frappe.db.get_value('Company', self.filters.company, 'default_receivable_account')
-
- credit_note_total = frappe.db.sql(
- """
- select
- sum(`tabJournal Entry Account`.credit_in_account_currency)
- from
- `tabJournal Entry Account`
- join `tabJournal Entry` on `tabJournal Entry`.name = `tabJournal Entry Account`.parent
- where
- `tabJournal Entry Account`.parent in (
- select
- `tabJournal Entry Account`.parent
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.reference_name = %s
- and `tabJournal Entry Account`.docstatus = 1
- )
- and `tabJournal Entry Account`.account = %s
- and `tabJournal Entry Account`.docstatus = 1
- and `tabJournal Entry`.voucher_type = 'Credit Note';
- """, (d.name, default_receivable_account)
- )
-
- credit_note_total = credit_note_total[0][0] or 0 if credit_note_total else 0
- d["rebate_given"] = credit_note_total
- self.invoice_details.setdefault(d.name, d)
-
- # Get Sales Team
- if self.filters.show_sales_person:
- # nosemgrep
- sales_team = frappe.db.sql(
- """
- select parent, sales_person
- from `tabSales Team`
- where parenttype = 'Sales Invoice'
- """,
- as_dict=1,
- )
- for d in sales_team:
- self.invoice_details.setdefault(d.parent, {}).setdefault("sales_team", []).append(
- d.sales_person
- )
-
-
- if self.account_type == "Payable":
- # nosemgrep
- for pi in frappe.db.sql(
- """
- select name, due_date, bill_no, bill_date
- from `tabPurchase Invoice`
- where
- posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
- ):
- po = frappe.db.get_all('Purchase Invoice Item',filters={'parent': pi.name},fields=['distinct purchase_order'])
- po_list = [
- f'{po.purchase_order}'
- for po in po if po.purchase_order
- ]
-
- default_payable_account = frappe.db.get_value('Company', self.filters.company, 'default_payable_account')
-
- debit_note_total = frappe.db.sql(
- """
- select
- sum(`tabJournal Entry Account`.debit_in_account_currency)
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.parent in (
- select
- `tabJournal Entry Account`.parent
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.reference_name = %s
- and `tabJournal Entry Account`.docstatus = 1
- )
- and `tabJournal Entry Account`.account = %s
- and `tabJournal Entry Account`.docstatus = 1
- """, (pi.name, default_payable_account)
- )
-
- debit_note_total = debit_note_total[0][0] or 0 if debit_note_total else 0
- pi["rebate_received"] = debit_note_total
- pi["purchase_order"] = ", ".join(po_list)
-
- self.invoice_details.setdefault(pi.name, pi)
-
- # Invoices booked via Journal Entries
- # nosemgrep
- journal_entries = frappe.db.sql(
- """
- select name, due_date, bill_no, bill_date
- from `tabJournal Entry`
- where
- posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
- )
-
- for je in journal_entries:
- if je.bill_no:
- self.invoice_details.setdefault(je.name, je)
-
-
- def set_party_details(self, row):
- if not row.party:
- return
- # customer / supplier name
- party_details = self.get_party_details(row.party) or {}
- row.update(party_details)
-
- if self.filters.get("in_party_currency") or self.filters.get("party_account"):
- row.currency = row.account_currency
- else:
- row.currency = self.company_currency
-
- def allocate_outstanding_based_on_payment_terms(self, row):
- self.get_payment_terms(row)
- for term in row.payment_terms:
- # update "paid" and "outstanding" for this term
- if not term.paid:
- self.allocate_closing_to_term(row, term, "paid")
-
- # update "credit_note" and "outstanding" for this term
- if term.outstanding:
- self.allocate_closing_to_term(row, term, "credit_note")
-
- row.payment_terms = sorted(row.payment_terms, key=lambda x: x["due_date"])
-
- def get_payment_terms(self, row):
- # build payment_terms for row
- # nosemgrep
- payment_terms_details = frappe.db.sql(
- f"""
- select
- si.name, si.party_account_currency, si.currency, si.conversion_rate,
- si.total_advance, ps.due_date, ps.payment_term, ps.payment_amount, ps.base_payment_amount,
- ps.description, ps.paid_amount, ps.discounted_amount
- from `tab{row.voucher_type}` si, `tabPayment Schedule` ps
- where
- si.name = ps.parent and
- si.name = %s and
- si.is_return = 0
- order by ps.paid_amount desc, due_date
- """,
- row.voucher_no,
- as_dict=1,
- )
-
- original_row = frappe._dict(row)
- row.payment_terms = []
-
- # Cr Note's don't have Payment Terms
- if not payment_terms_details:
- return
-
- # Advance allocated during invoicing is not considered in payment terms
- # Deduct that from paid amount pre allocation
- row.paid -= flt(payment_terms_details[0].total_advance)
-
- # If single payment terms, no need to split the row
- if len(payment_terms_details) == 1 and payment_terms_details[0].payment_term:
- self.append_payment_term(row, payment_terms_details[0], original_row)
- return
-
- for d in payment_terms_details:
- term = frappe._dict(original_row)
- self.append_payment_term(row, d, term)
-
- def append_payment_term(self, row, d, term):
- if (
- self.filters.get("customer") or self.filters.get("supplier")
- ) and d.currency == d.party_account_currency:
- invoiced = d.payment_amount
- else:
- invoiced = d.base_payment_amount
-
- row.payment_terms.append(
- term.update(
- {
- "due_date": d.due_date,
- "invoiced": invoiced,
- "invoice_grand_total": row.invoiced,
- "payment_term": d.description or d.payment_term,
- "paid": d.paid_amount + d.discounted_amount,
- "credit_note": 0.0,
- "outstanding": invoiced - d.paid_amount - d.discounted_amount,
- }
- )
- )
-
- if d.paid_amount:
- row["paid"] -= d.paid_amount + d.discounted_amount
-
- def allocate_closing_to_term(self, row, term, key):
- if row[key]:
- if row[key] > term.outstanding:
- term[key] = term.outstanding
- row[key] -= term.outstanding
- else:
- term[key] = row[key]
- row[key] = 0
- term.outstanding -= term[key]
-
- def allocate_extra_payments_or_credits(self, row):
- # allocate extra payments / credits
- additional_row = None
- for key in ("paid", "credit_note"):
- if row[key] > 0:
- if not additional_row:
- additional_row = frappe._dict(row)
- additional_row.invoiced = 0.0
- additional_row[key] = row[key]
-
- if additional_row:
- additional_row.outstanding = (
- additional_row.invoiced - additional_row.paid - additional_row.credit_note
- )
- self.append_row(additional_row)
-
- def get_future_payments(self):
- if self.filters.show_future_payments:
- self.future_payments = frappe._dict()
- future_payments = list(self.get_future_payments_from_payment_entry())
- future_payments += list(self.get_future_payments_from_journal_entry())
- if future_payments:
- for d in future_payments:
- if d.future_amount and d.invoice_no:
- self.future_payments.setdefault((d.invoice_no, d.party), []).append(d)
-
- def get_future_payments_from_payment_entry(self):
- pe = frappe.qb.DocType("Payment Entry")
- pe_ref = frappe.qb.DocType("Payment Entry Reference")
- ifelse = query_builder.CustomFunction("IF", ["condition", "then", "else"])
-
- return (
- frappe.qb.from_(pe)
- .inner_join(pe_ref)
- .on(pe_ref.parent == pe.name)
- .select(
- (pe_ref.reference_name).as_("invoice_no"),
- pe.party,
- pe.party_type,
- (pe.posting_date).as_("future_date"),
- (pe_ref.allocated_amount).as_("future_amount"),
- (pe.reference_no).as_("future_ref"),
- ifelse(
- pe.payment_type == "Receive",
- pe.source_exchange_rate * pe_ref.allocated_amount,
- pe.target_exchange_rate * pe_ref.allocated_amount,
- ).as_("future_amount_in_base_currency"),
- )
- .where(
- (pe.docstatus < 2)
- & (pe.posting_date > self.filters.report_date)
- & (pe.party_type.isin(self.party_type))
- )
- ).run(as_dict=True)
-
- def get_future_payments_from_journal_entry(self):
- je = frappe.qb.DocType("Journal Entry")
- jea = frappe.qb.DocType("Journal Entry Account")
- query = (
- frappe.qb.from_(je)
- .inner_join(jea)
- .on(jea.parent == je.name)
- .select(
- jea.reference_name.as_("invoice_no"),
- jea.party,
- jea.party_type,
- je.posting_date.as_("future_date"),
- je.cheque_no.as_("future_ref"),
- )
- .where(
- (je.docstatus < 2)
- & (je.posting_date > self.filters.report_date)
- & (jea.party_type.isin(self.party_type))
- & (jea.reference_name.isnotnull())
- & (jea.reference_name != "")
- )
- )
-
- if self.filters.get("party"):
- if self.account_type == "Payable":
- query = query.select(
- Sum(jea.debit_in_account_currency - jea.credit_in_account_currency).as_("future_amount")
- )
- query = query.select(Sum(jea.debit - jea.credit).as_("future_amount_in_base_currency"))
- else:
- query = query.select(
- Sum(jea.credit_in_account_currency - jea.debit_in_account_currency).as_("future_amount")
- )
- query = query.select(Sum(jea.credit - jea.debit).as_("future_amount_in_base_currency"))
- else:
- query = query.select(
- Sum(jea.debit if self.account_type == "Payable" else jea.credit).as_(
- "future_amount_in_base_currency"
- )
- )
- query = query.select(
- Sum(
- jea.debit_in_account_currency
- if self.account_type == "Payable"
- else jea.credit_in_account_currency
- ).as_("future_amount")
- )
-
- query = query.having(qb.Field("future_amount") > 0)
- return query.run(as_dict=True)
-
- def allocate_future_payments(self, row):
- # future payments are captured in additional columns
- # this method allocates pending future payments against a voucher to
- # the current row (which could be generated from payment terms)
- if not self.filters.show_future_payments:
- return
-
- row.remaining_balance = row.outstanding
- row.future_amount = 0.0
- row.days_until_pdc = 0
- for future in self.future_payments.get((row.voucher_no, row.party), []):
- if self.filters.in_party_currency:
- future_amount_field = "future_amount"
- else:
- future_amount_field = "future_amount_in_base_currency"
-
- if row.remaining_balance != 0 and future.get(future_amount_field):
- if future.get(future_amount_field) > row.outstanding:
- row.future_amount = row.outstanding
- future[future_amount_field] = future.get(future_amount_field) - row.outstanding
- row.remaining_balance = 0
- else:
- row.future_amount += future.get(future_amount_field)
- future[future_amount_field] = 0
- row.remaining_balance = row.outstanding - row.future_amount
-
- row.setdefault("future_ref", []).append(
- cstr(future.future_ref) + "/" + cstr(future.future_date)
- )
-
- if future.future_date:
- row.days_until_pdc = max((getdate(future.future_date) - getdate(nowdate())).days, 0)
- else:
- row.days_until_pdc = 0
- if row.future_ref:
- row.future_ref = ", ".join(row.future_ref)
-
- def get_return_entries(self):
- doctype = "Sales Invoice" if self.account_type == "Receivable" else "Purchase Invoice"
- filters = {
- "posting_date": ("<=", self.filters.report_date),
- "is_return": 1,
- "docstatus": 1,
- "company": self.filters.company,
- "update_outstanding_for_self": 0,
- }
- or_filters = {}
- for party_type in self.party_type:
- party_field = scrub(party_type)
- if self.filters.get(party_field):
- or_filters.update({party_field: self.filters.get(party_field)})
- self.return_entries = frappe._dict(
- frappe.get_all(
- doctype, filters=filters, or_filters=or_filters, fields=["name", "return_against"], as_list=1
- )
- )
-
- def set_ageing(self, row):
- if self.filters.ageing_based_on == "Due Date":
- # use posting date as a fallback for advances posted via journal and payment entry
- # when ageing viewed by due date
- entry_date = row.due_date or row.posting_date
- elif self.filters.ageing_based_on == "Supplier Invoice Date":
- entry_date = row.bill_date
- else:
- entry_date = row.posting_date
-
- self.get_ageing_data(entry_date, row)
-
- # ageing buckets should not have amounts if due date is not reached
- if getdate(entry_date) > getdate(self.filters.report_date):
- [setattr(row, f"range{i}", 0.0) for i in self.range_numbers]
-
- row.total_due = sum(row[f"range{i}"] for i in self.range_numbers)
-
- def get_ageing_data(self, entry_date, row):
- # [0-30, 30-60, 60-90, 90-120, 120-above]
- [setattr(row, f"range{i}", 0.0) for i in self.range_numbers]
-
- if not (self.age_as_on and entry_date):
- return
-
- row.age = (getdate(self.age_as_on) - getdate(entry_date)).days or 0
-
- index = next(
- (i for i, days in enumerate(self.ranges) if cint(row.age) <= cint(days)), len(self.ranges)
- )
- row["range" + str(index + 1)] = row.outstanding
-
- def get_ple_entries(self):
- # get all the GL entries filtered by the given filters
+ self.update_voucher_balance(ple)
- self.prepare_conditions()
+ delattr(self, "ple_entries")
- if self.filters.show_future_payments:
- self.qb_selection_filter.append(
- self.ple.posting_date.lte(self.filters.report_date)
- | (
- (self.ple.voucher_no == self.ple.against_voucher_no)
- & (Date(self.ple.creation).lte(self.filters.report_date))
- )
- )
- else:
- self.qb_selection_filter.append(self.ple.posting_date.lte(self.filters.report_date))
+ def fetch_ple_in_unbuffered_cursor(self):
+ self.ple_entries = []
+ with frappe.db.unbuffered_cursor():
+ for ple in self.ple_query.run(as_dict=True, as_iterator=True):
+ self.ple_entries.append(ple)
- ple = qb.DocType("Payment Ledger Entry")
- query = (
- qb.from_(ple)
- .select(
- ple.name,
- ple.account,
- ple.voucher_type,
- ple.voucher_no,
- ple.against_voucher_type,
- ple.against_voucher_no,
- ple.party_type,
- ple.cost_center,
- ple.party,
- ple.posting_date,
- ple.due_date,
- ple.account_currency,
- ple.amount,
- ple.amount_in_account_currency,
- )
- .where(ple.delinked == 0)
- .where(Criterion.all(self.qb_selection_filter))
- .where(Criterion.any(self.or_filters))
- )
+ self.filter_ple_entries_by_user_sales_person()
- if self.filters.get("show_remarks"):
- if remarks_length := frappe.db.get_single_value(
- "Accounts Settings", "receivable_payable_remarks_length"
- ):
- query = query.select(Substring(ple.remarks, 1, remarks_length).as_("remarks"))
- else:
- query = query.select(ple.remarks)
+ for ple in self.ple_entries:
+ self.init_voucher_balance(ple)
- if self.filters.get("group_by_party"):
- query = query.orderby(self.ple.party, self.ple.posting_date)
- else:
- query = query.orderby(self.ple.posting_date, self.ple.party)
+ for ple in self.ple_entries:
+ self.update_voucher_balance(ple)
- self.ple_entries = query.run(as_dict=True)
+ delattr(self, "ple_entries")
def filter_ple_entries_by_user_sales_person(self):
current_user = frappe.session.user
- # Get sales person(s) mapped to this user (via 'user' field in Sales Person)
- sales_persons = frappe.get_all("Sales Person", filters={"custom_user_id": current_user}, pluck="name")
+ # Get sales person(s) mapped to this user (via 'custom_user_id' field in Sales Person)
+ sales_persons = frappe.get_all(
+ "Sales Person", filters={"custom_user_id": current_user}, pluck="name"
+ )
if not sales_persons:
- # No sales person found for the current user → exclude all Sales Invoices
+ # No sales person found for the current user -> exclude all Sales Invoices
self.ple_entries = [
ple for ple in self.ple_entries if ple.voucher_type != "Sales Invoice"
]
@@ -941,385 +92,7 @@ def filter_ple_entries_by_user_sales_person(self):
# Filter ple_entries
self.ple_entries = [
- ple for ple in self.ple_entries
+ ple
+ for ple in self.ple_entries
if ple.voucher_type != "Sales Invoice" or ple.voucher_no in allowed_si
]
-
-
- def get_sales_invoices_or_customers_based_on_sales_person(self):
- if self.filters.get("sales_person"):
- lft, rgt = frappe.db.get_value("Sales Person", self.filters.get("sales_person"), ["lft", "rgt"])
-
- # nosemgrep
- records = frappe.db.sql(
- """
- select distinct parent, parenttype
- from `tabSales Team` steam
- where parenttype in ('Customer', 'Sales Invoice')
- and exists(select name from `tabSales Person` where lft >= %s and rgt <= %s and name = steam.sales_person)
- """,
- (lft, rgt),
- as_dict=1,
- )
-
- self.sales_person_records = frappe._dict()
- for d in records:
- self.sales_person_records.setdefault(d.parenttype, set()).add(d.parent)
-
- def prepare_conditions(self):
- self.qb_selection_filter = []
- self.or_filters = []
-
- for _party_type in self.party_type:
- self.add_common_filters()
-
- if self.account_type == "Receivable":
- self.add_customer_filters()
-
- elif self.account_type == "Payable":
- self.add_supplier_filters()
-
- if self.filters.cost_center:
- self.get_cost_center_conditions()
-
- self.add_accounting_dimensions_filters()
-
- def get_cost_center_conditions(self):
- lft, rgt = frappe.db.get_value("Cost Center", self.filters.cost_center, ["lft", "rgt"])
- cost_center_list = [
- center.name
- for center in frappe.get_list("Cost Center", filters={"lft": (">=", lft), "rgt": ("<=", rgt)})
- ]
- self.qb_selection_filter.append(self.ple.cost_center.isin(cost_center_list))
-
- def add_common_filters(self):
- if self.filters.company:
- self.qb_selection_filter.append(self.ple.company == self.filters.company)
-
- if self.filters.finance_book:
- self.qb_selection_filter.append(self.ple.finance_book == self.filters.finance_book)
-
- if self.filters.get("party_type"):
- self.qb_selection_filter.append(self.filters.party_type == self.ple.party_type)
-
- if self.filters.get("party"):
- self.qb_selection_filter.append(self.ple.party.isin(self.filters.party))
-
- if self.filters.party_account:
- self.qb_selection_filter.append(self.ple.account == self.filters.party_account)
- else:
- # get GL with "receivable" or "payable" account_type
- accounts = [
- d.name
- for d in frappe.get_all(
- "Account", filters={"account_type": self.account_type, "company": self.filters.company}
- )
- ]
-
- if accounts:
- self.qb_selection_filter.append(self.ple.account.isin(accounts))
-
- def add_customer_filters(
- self,
- ):
- self.customer = qb.DocType("Customer")
-
- if self.filters.get("customer_group"):
- groups = get_customer_group_with_children(self.filters.customer_group)
- customers = (
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer["customer_group"].isin(groups))
- )
- self.qb_selection_filter.append(self.ple.party.isin(customers))
-
- if self.filters.get("territory"):
- self.get_hierarchical_filters("Territory", "territory")
-
- if self.filters.get("payment_terms_template"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer.payment_terms == self.filters.get("payment_terms_template"))
- )
- )
-
- if self.filters.get("sales_partner"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer.default_sales_partner == self.filters.get("sales_partner"))
- )
- )
-
- def add_supplier_filters(self):
- supplier = qb.DocType("Supplier")
- if self.filters.get("supplier_group"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(supplier)
- .select(supplier.name)
- .where(supplier.supplier_group == self.filters.get("supplier_group"))
- )
- )
-
- if self.filters.get("payment_terms_template"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(supplier)
- .select(supplier.name)
- .where(supplier.payment_terms == self.filters.get("supplier_group"))
- )
- )
-
- def get_hierarchical_filters(self, doctype, key):
- lft, rgt = frappe.db.get_value(doctype, self.filters.get(key), ["lft", "rgt"])
-
- doc = qb.DocType(doctype)
- ple = self.ple
- customer = self.customer
- groups = qb.from_(doc).select(doc.name).where((doc.lft >= lft) & (doc.rgt <= rgt))
- customers = qb.from_(customer).select(customer.name).where(customer[key].isin(groups))
- self.qb_selection_filter.append(ple.party.isin(customers))
-
- def add_accounting_dimensions_filters(self):
- accounting_dimensions = get_accounting_dimensions(as_list=False)
-
- if accounting_dimensions:
- for dimension in accounting_dimensions:
- if self.filters.get(dimension.fieldname):
- if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
- self.filters[dimension.fieldname] = get_dimension_with_children(
- dimension.document_type, self.filters.get(dimension.fieldname)
- )
- self.qb_selection_filter.append(
- self.ple[dimension.fieldname].isin(self.filters[dimension.fieldname])
- )
- else:
- self.qb_selection_filter.append(
- self.ple[dimension.fieldname].isin(self.filters[dimension.fieldname])
- )
-
- def is_invoice(self, ple):
- if ple.voucher_type in ("Sales Invoice", "Purchase Invoice"):
- return True
-
- def get_party_details(self, party):
- if party not in self.party_details:
- if self.account_type == "Receivable":
- fields = ["customer_name", "territory", "customer_group", "customer_primary_contact"]
-
- if self.filters.get("sales_partner"):
- fields.append("default_sales_partner")
-
- self.party_details[party] = frappe.db.get_value(
- "Customer",
- party,
- fields,
- as_dict=True,
- )
- else:
- self.party_details[party] = frappe.db.get_value(
- "Supplier", party, ["supplier_name", "supplier_group"], as_dict=True
- )
-
- return self.party_details[party]
-
- def get_columns(self):
- self.columns = []
- self.add_column("Posting Date", fieldtype="Date")
- self.add_column(
- label="Party Type",
- fieldname="party_type",
- fieldtype="Data",
- width=100,
- )
- self.add_column(
- label="Party",
- fieldname="party",
- fieldtype="Dynamic Link",
- options="party_type",
- width=180,
- )
- self.add_column(
- label=self.account_type + " Account",
- fieldname="party_account",
- fieldtype="Link",
- options="Account",
- width=180,
- )
-
- if self.party_naming_by == "Naming Series":
- if self.account_type == "Payable":
- label = "Supplier Name"
- fieldname = "supplier_name"
- else:
- label = "Customer Name"
- fieldname = "customer_name"
- self.add_column(
- label=label,
- fieldname=fieldname,
- fieldtype="Data",
- )
-
- if self.account_type == "Receivable":
- self.add_column(
- _("Customer Contact"),
- fieldname="customer_primary_contact",
- fieldtype="Link",
- options="Contact",
- )
-
- self.add_column(label=_("Cost Center"), fieldname="cost_center", fieldtype="Data")
- self.add_column(label=_("Voucher Type"), fieldname="voucher_type", fieldtype="Data")
- self.add_column(
- label=_("Voucher No"),
- fieldname="voucher_no",
- fieldtype="Data",
-# options="voucher_type",
- width=180,
- )
-
- self.add_column(label="Due Date", fieldtype="Date")
-
- if self.account_type == "Payable":
- self.add_column(label=_("Purchase Order"), fieldname="purchase_order", fieldtype="Data", width="180")
- self.add_column(label=_("Bill No"), fieldname="bill_no", fieldtype="Data")
- self.add_column(label=_("Bill Date"), fieldname="bill_date", fieldtype="Date")
-
- if self.filters.based_on_payment_terms:
- self.add_column(label=_("Payment Term"), fieldname="payment_term", fieldtype="Data")
- self.add_column(label=_("Invoice Grand Total"), fieldname="invoice_grand_total")
-
- self.add_column(_("Invoiced Amount"), fieldname="invoiced")
- self.add_column(_("Paid Amount"), fieldname="paid")
- if self.account_type == "Receivable":
- self.add_column(_("Credit Note"), fieldname="credit_note")
- self.add_column(_("Rebate Given"), fieldname="rebate_given")
- else:
- # note: fieldname is still `credit_note`
- self.add_column(_("Debit Note"), fieldname="credit_note")
- self.add_column(_("Rebate Received"), fieldname="rebate_received")
- self.add_column(_("Outstanding Amount"), fieldname="outstanding")
-
- self.add_column(label=_("Age (Days)"), fieldname="age", fieldtype="Int", width=80)
- self.setup_ageing_columns()
-
- self.add_column(
- label=_("Currency"), fieldname="currency", fieldtype="Link", options="Currency", width=80
- )
-
- if self.filters.show_future_payments:
- self.add_column(label=_("PDC Payment Ref"), fieldname="future_ref", fieldtype="Data")
- self.add_column(label=_("PDC Payment Amount"), fieldname="future_amount")
- self.add_column(label=_("Remaining Balance"), fieldname="remaining_balance")
- self.add_column(label=_("Days Until PDC"), fieldname="days_until_pdc", fieldtype="Int")
-
- if self.filters.account_type == "Receivable":
- self.add_column(label=_("Customer LPO"), fieldname="po_no", fieldtype="Data")
-
- # comma separated list of linked delivery notes
- if self.filters.show_delivery_notes:
- self.add_column(label=_("Delivery Notes"), fieldname="delivery_notes", fieldtype="Data")
- self.add_column(
- label=_("Territory"), fieldname="territory", fieldtype="Link", options="Territory"
- )
- self.add_column(
- label=_("Customer Group"),
- fieldname="customer_group",
- fieldtype="Link",
- options="Customer Group",
- )
- if self.filters.show_sales_person:
- self.add_column(label=_("Sales Person"), fieldname="sales_person", fieldtype="Data")
-
- if self.filters.sales_partner:
- self.add_column(label=_("Sales Partner"), fieldname="default_sales_partner", fieldtype="Data")
-
- if self.filters.account_type == "Payable":
- self.add_column(
- label=_("Supplier Group"),
- fieldname="supplier_group",
- fieldtype="Link",
- options="Supplier Group",
- )
-
- if self.filters.show_remarks:
- self.add_column(label=_("Remarks"), fieldname="remarks", fieldtype="Text", width=200)
-
- def add_column(self, label, fieldname=None, fieldtype="Currency", options=None, width=120):
- if not fieldname:
- fieldname = scrub(label)
- if fieldtype == "Currency":
- options = "currency"
- if fieldtype == "Date":
- width = 110
-
- self.columns.append(
- dict(label=label, fieldname=fieldname, fieldtype=fieldtype, options=options, width=width)
- )
-
- def setup_ageing_columns(self):
- # for charts
- self.ageing_column_labels = []
- ranges = [*self.ranges, "Above"]
-
- prev_range_value = 0
- for idx, curr_range_value in enumerate(ranges):
- label = f"{prev_range_value}-{curr_range_value}"
- self.add_column(label=label, fieldname="range" + str(idx + 1))
-
- self.ageing_column_labels.append(label)
-
- if curr_range_value.isdigit():
- prev_range_value = cint(curr_range_value) + 1
-
- def get_chart_data(self):
- precision = cint(frappe.db.get_default("float_precision")) or 2
- rows = []
- for row in self.data:
- row = frappe._dict(row)
- if not cint(row.bold):
- values = [flt(row.get(f"range{i}", None), precision) for i in self.range_numbers]
- rows.append({"values": values})
-
- self.chart = {
- "data": {"labels": self.ageing_column_labels, "datasets": rows},
- "type": "percentage",
- }
-
- def get_exchange_rate_revaluations(self):
- je = qb.DocType("Journal Entry")
- results = (
- qb.from_(je)
- .select(je.name)
- .where(
- (je.company == self.filters.company)
- & (je.posting_date.lte(self.filters.report_date))
- & (
- (je.voucher_type == "Exchange Rate Revaluation")
- | (je.voucher_type == "Exchange Gain Or Loss")
- )
- )
- .run()
- )
- self.err_journals = [x[0] for x in results] if results else []
-
-
-def get_customer_group_with_children(customer_groups):
- if not isinstance(customer_groups, list):
- customer_groups = [d.strip() for d in customer_groups.strip().split(",") if d]
-
- all_customer_groups = []
- for d in customer_groups:
- if frappe.db.exists("Customer Group", d):
- lft, rgt = frappe.db.get_value("Customer Group", d, ["lft", "rgt"])
- children = frappe.get_all("Customer Group", filters={"lft": [">=", lft], "rgt": ["<=", rgt]})
- all_customer_groups += [c.name for c in children]
- else:
- frappe.throw(_("Customer Group: {0} does not exist").format(d))
-
- return list(set(all_customer_groups))
-
diff --git a/spollex/spollex/report/accounts_receivable_with_rebate_given/accounts_receivable_with_rebate_given.py b/spollex/spollex/report/accounts_receivable_with_rebate_given/accounts_receivable_with_rebate_given.py
index 745ba4c..d9e5f8b 100644
--- a/spollex/spollex/report/accounts_receivable_with_rebate_given/accounts_receivable_with_rebate_given.py
+++ b/spollex/spollex/report/accounts_receivable_with_rebate_given/accounts_receivable_with_rebate_given.py
@@ -1,34 +1,12 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
-from collections import OrderedDict
-
import frappe
-from frappe import _, qb, query_builder, scrub
-from frappe.query_builder import Criterion
-from frappe.query_builder.functions import Date, Substring, Sum
-from frappe.utils import cint, cstr, flt, getdate, nowdate
-
-from erpnext.accounts.doctype.accounting_dimension.accounting_dimension import (
- get_accounting_dimensions,
- get_dimension_with_children,
+from frappe import _, qb, scrub
+from frappe.utils import cstr, getdate, nowdate
+from erpnext.accounts.report.accounts_receivable.accounts_receivable import (
+ ReceivablePayableReport as ERPNextReceivablePayableReport,
)
-from erpnext.accounts.utils import get_currency_precision, get_party_types_from_account_type
-
-# This report gives a summary of all Outstanding Invoices considering the following
-
-# 1. Invoice can be booked via Sales/Purchase Invoice or Journal Entry
-# 2. Report handles both receivable and payable
-# 3. Key balances for each row are "Invoiced Amount", "Paid Amount", "Credit/Debit Note Amount", "Oustanding Amount"
-# 4. For explicit payment terms in invoice (example: 30% advance, 30% on delivery, 40% post delivery),
-# the invoice will be broken up into multiple rows, one for each payment term
-# 5. If there are payments after the report date (post dated), these will be updated in additional columns
-# for future amount
-# 6. Configurable Ageing Groups (0-30, 30-60 etc) can be set via filters
-# 7. For overpayment against an invoice with payment terms, there will be an additional row
-# 8. Invoice details like Sales Persons, Delivery Notes are also fetched comma separated
-# 9. Report amounts are in party currency if in_party_currency is selected, otherwise company currency
-# 10. This report is based on Payment Ledger Entries
def execute(filters=None):
@@ -36,1254 +14,174 @@ def execute(filters=None):
"account_type": "Receivable",
"naming_by": ["Selling Settings", "cust_master_name"],
}
- return ReceivablePayableReport(filters).run(args)
-
-
-class ReceivablePayableReport:
- def __init__(self, filters=None):
- self.filters = frappe._dict(filters or {})
- self.qb_selection_filter = []
- self.ple = qb.DocType("Payment Ledger Entry")
- self.filters.report_date = getdate(self.filters.report_date or nowdate())
- self.age_as_on = (
- getdate(nowdate()) if self.filters.report_date > getdate(nowdate()) else self.filters.report_date
- )
-
- if not self.filters.range:
- self.filters.range = "30, 60, 90, 120"
- self.ranges = [num.strip() for num in self.filters.range.split(",") if num.strip().isdigit()]
- self.range_numbers = [num for num in range(1, len(self.ranges) + 2)]
-
- def run(self, args):
- self.filters.update(args)
- self.set_defaults()
- self.party_naming_by = frappe.db.get_value(args.get("naming_by")[0], None, args.get("naming_by")[1])
- self.get_columns()
- self.get_data()
- self.get_chart_data()
- return self.columns, self.data, None, self.chart, None, self.skip_total_row
-
- def set_defaults(self):
- if not self.filters.get("company"):
- self.filters.company = frappe.db.get_single_value("Global Defaults", "default_company")
- self.company_currency = frappe.get_cached_value(
- "Company", self.filters.get("company"), "default_currency"
- )
- self.currency_precision = get_currency_precision() or 2
- self.dr_or_cr = "debit" if self.filters.account_type == "Receivable" else "credit"
- self.account_type = self.filters.account_type
- self.party_type = get_party_types_from_account_type(self.account_type)
- self.party_details = {}
- self.invoices = set()
- self.skip_total_row = 0
-
- if self.filters.get("group_by_party"):
- self.previous_party = ""
- self.total_row_map = {}
- self.skip_total_row = 1
-
- if self.filters.get("in_party_currency"):
- if self.filters.get("party") and len(self.filters.get("party")) == 1:
- self.skip_total_row = 0
- else:
- self.skip_total_row = 1
-
- def get_data(self):
- self.get_ple_entries()
- self.get_sales_invoices_or_customers_based_on_sales_person()
- self.voucher_balance = OrderedDict()
- self.init_voucher_balance() # invoiced, paid, credit_note, outstanding
-
- # Build delivery note map against all sales invoices
- self.build_delivery_note_map()
-
- # Get invoice details like bill_no, due_date etc for all invoices
- self.get_invoice_details()
-
- # fetch future payments against invoices
- self.get_future_payments()
-
- # Get return entries
- self.get_return_entries()
-
- # Get Exchange Rate Revaluations
- self.get_exchange_rate_revaluations()
-
- self.data = []
-
- for ple in self.ple_entries:
- self.update_voucher_balance(ple)
-
- self.build_data()
-
- def build_voucher_dict(self, ple):
- return frappe._dict(
- voucher_type=ple.voucher_type,
- voucher_no=ple.voucher_no,
- party=ple.party,
- party_account=ple.account,
- posting_date=ple.posting_date,
- account_currency=ple.account_currency,
- remarks=ple.remarks,
- invoiced=0.0,
- paid=0.0,
- credit_note=0.0,
- outstanding=0.0,
- invoiced_in_account_currency=0.0,
- paid_in_account_currency=0.0,
- credit_note_in_account_currency=0.0,
- outstanding_in_account_currency=0.0,
- cost_center=ple.cost_center,
- )
-
- def init_voucher_balance(self):
- # build all keys, since we want to exclude vouchers beyond the report date
- for ple in self.ple_entries:
- # get the balance object for voucher_type
-
- if self.filters.get("ignore_accounts"):
- key = (ple.voucher_type, ple.voucher_no, ple.party)
- else:
- key = (ple.account, ple.voucher_type, ple.voucher_no, ple.party)
-
- if key not in self.voucher_balance:
- self.voucher_balance[key] = self.build_voucher_dict(ple)
-
- self.get_invoices(ple)
-
- if self.filters.get("group_by_party"):
- self.init_subtotal_row(ple.party)
-
- if self.filters.get("group_by_party") and not self.filters.get("in_party_currency"):
- self.init_subtotal_row("Total")
-
- def get_invoices(self, ple):
- if ple.voucher_type in ("Sales Invoice", "Purchase Invoice"):
- if self.filters.get("sales_person"):
- if ple.voucher_no in self.sales_person_records.get(
- "Sales Invoice", []
- ) or ple.party in self.sales_person_records.get("Customer", []):
- self.invoices.add(ple.voucher_no)
- else:
- self.invoices.add(ple.voucher_no)
-
- def init_subtotal_row(self, party):
- if not self.total_row_map.get(party):
- self.total_row_map.setdefault(party, {"party": party, "bold": 1})
-
- for field in self.get_currency_fields():
- self.total_row_map[party][field] = 0.0
+ return SpollexReceivablePayableReport(filters).run(args)
- def get_currency_fields(self):
- return [
- "invoiced",
- "paid",
- "credit_note",
- "outstanding",
- "range1",
- "range2",
- "range3",
- "range4",
- "range5",
- "future_amount",
- "remaining_balance",
- ]
- def get_voucher_balance(self, ple):
- if self.filters.get("sales_person"):
- if not (
- ple.party in self.sales_person_records.get("Customer", [])
- or ple.against_voucher_no in self.sales_person_records.get("Sales Invoice", [])
- ):
- return
-
- if self.filters.get("ignore_accounts"):
- key = (ple.against_voucher_type, ple.against_voucher_no, ple.party)
- else:
- key = (ple.account, ple.against_voucher_type, ple.against_voucher_no, ple.party)
-
- # If payment is made against credit note
- # and credit note is made against a Sales Invoice
- # then consider the payment against original sales invoice.
- if ple.against_voucher_type in ("Sales Invoice", "Purchase Invoice"):
- if ple.against_voucher_no in self.return_entries:
- return_against = self.return_entries.get(ple.against_voucher_no)
- if return_against:
- if self.filters.get("ignore_accounts"):
- key = (ple.against_voucher_type, return_against, ple.party)
- else:
- key = (ple.account, ple.against_voucher_type, return_against, ple.party)
-
- row = self.voucher_balance.get(key)
-
- # Build and use a separate row for Employee Advances.
- # This allows Payments or Journals made against Emp Advance to be processed.
- if (
- not row
- and ple.against_voucher_type == "Employee Advance"
- and self.filters.handle_employee_advances
- ):
- _d = self.build_voucher_dict(ple)
- _d.voucher_type = ple.against_voucher_type
- _d.voucher_no = ple.against_voucher_no
- row = self.voucher_balance[key] = _d
-
- if not row:
- # no invoice, this is an invoice / stand-alone payment / credit note
- if self.filters.get("ignore_accounts"):
- row = self.voucher_balance.get((ple.voucher_type, ple.voucher_no, ple.party))
- else:
- row = self.voucher_balance.get((ple.account, ple.voucher_type, ple.voucher_no, ple.party))
-
- row.party_type = ple.party_type
- return row
-
- def update_voucher_balance(self, ple):
- # get the row where this balance needs to be updated
- # if its a payment, it will return the linked invoice or will be considered as advance
- row = self.get_voucher_balance(ple)
- if not row:
- return
-
- if self.filters.get("in_party_currency") or self.filters.get("party_account"):
- amount = ple.amount_in_account_currency
- else:
- amount = ple.amount
- amount_in_account_currency = ple.amount_in_account_currency
-
- # update voucher
- if ple.amount > 0:
- if (
- ple.voucher_type in ["Journal Entry", "Payment Entry"]
- and ple.voucher_no != ple.against_voucher_no
- ):
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
- else:
- row.invoiced += amount
- row.invoiced_in_account_currency += amount_in_account_currency
- else:
- if self.is_invoice(ple):
- if row.voucher_no == ple.voucher_no == ple.against_voucher_no:
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
- else:
- row.credit_note -= amount
- row.credit_note_in_account_currency -= amount_in_account_currency
- else:
- row.paid -= amount
- row.paid_in_account_currency -= amount_in_account_currency
-
- if not row.cost_center and ple.cost_center:
- row.cost_center = str(ple.cost_center)
-
- def update_sub_total_row(self, row, party):
- total_row = self.total_row_map.get(party)
-
- if total_row:
- for field in self.get_currency_fields():
- total_row[field] += row.get(field, 0.0)
- total_row["currency"] = row.get("currency", "")
-
- def append_subtotal_row(self, party):
- sub_total_row = self.total_row_map.get(party)
-
- if sub_total_row:
- self.data.append(sub_total_row)
- self.data.append({})
- self.update_sub_total_row(sub_total_row, "Total")
-
- def build_data(self):
- # set outstanding for all the accumulated balances
- # as we can use this to filter out invoices without outstanding
- for _key, row in self.voucher_balance.items():
- if row.voucher_type not in ("Sales Invoice", "Purchase Invoice"): # Filter out non-"Sales Invoice & Purchase Invoice"
- continue
- row.outstanding = flt(row.invoiced - row.paid - row.credit_note, self.currency_precision)
- row.outstanding_in_account_currency = flt(
- row.invoiced_in_account_currency
- - row.paid_in_account_currency
- - row.credit_note_in_account_currency,
- self.currency_precision,
+class SpollexReceivablePayableReport(ERPNextReceivablePayableReport):
+ def get_columns(self):
+ super().get_columns()
+ col_fieldnames = [c.get("fieldname") for c in self.columns]
+
+ # Insert purchase_order before bill_no if Payable
+ if self.account_type == "Payable" and "purchase_order" not in col_fieldnames:
+ po_col = dict(
+ label=_("Purchase Order"),
+ fieldname="purchase_order",
+ fieldtype="Data",
+ width=180,
)
-
- row.invoice_grand_total = row.invoiced
-
- must_consider = False
- if self.filters.get("for_revaluation_journals"):
- if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) or (
- abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision
- ):
- must_consider = True
+ if "bill_no" in col_fieldnames:
+ idx = col_fieldnames.index("bill_no")
+ self.columns.insert(idx, po_col)
else:
- if (abs(row.outstanding) >= 1.0 / 10**self.currency_precision) and (
- (abs(row.outstanding_in_account_currency) >= 1.0 / 10**self.currency_precision)
- or (row.voucher_no in self.err_journals)
- ):
- must_consider = True
-
- if must_consider:
- # non-zero oustanding, we must consider this row
-
- if self.is_invoice(row) and self.filters.based_on_payment_terms:
- # is an invoice, allocate based on fifo
- # adds a list `payment_terms` which contains new rows for each term
- self.allocate_outstanding_based_on_payment_terms(row)
-
- if row.payment_terms:
- # make separate rows for each payment term
- for d in row.payment_terms:
- if d.outstanding > 0:
- self.append_row(d)
-
- # if there is overpayment, add another row
- self.allocate_extra_payments_or_credits(row)
- else:
- self.append_row(row)
- else:
- self.append_row(row)
-
- if self.filters.get("group_by_party"):
- self.append_subtotal_row(self.previous_party)
- if self.data:
- self.data.append(self.total_row_map.get("Total", {}))
-
- def append_row(self, row):
- self.allocate_future_payments(row)
- self.set_invoice_details(row)
- self.set_party_details(row)
- self.set_ageing(row)
-
- if self.filters.get("group_by_party"):
- self.update_sub_total_row(row, row.party)
- if self.previous_party and (self.previous_party != row.party):
- self.append_subtotal_row(self.previous_party)
- self.previous_party = row.party
-
- if row.due_date < getdate(nowdate()):
- row["overdue"] = 1
- self.data.append(row)
-
- def set_invoice_details(self, row):
- invoice_details = self.invoice_details.get(row.voucher_no, {})
-
- if row.due_date:
-
- invoice_details.pop("due_date", None)
-
- row.update(invoice_details)
-
- if "rebate_received" in invoice_details:
- row["rebate_received"] = invoice_details["rebate_received"]
- row["paid"] = row["paid"] - row["rebate_received"]
- elif "rebate_given" in invoice_details:
- row["rebate_given"] = invoice_details["rebate_given"]
- row["paid"] = row["paid"] - row["rebate_given"]
-
- if row.voucher_type == "Sales Invoice":
- if self.filters.show_delivery_notes:
- self.set_delivery_notes(row)
-
- if self.filters.show_sales_person and row.sales_team:
- row.sales_person = ", ".join(row.sales_team)
- del row["sales_team"]
-
- def set_delivery_notes(self, row):
- delivery_notes = self.delivery_notes.get(row.voucher_no, [])
- if delivery_notes:
- row.delivery_notes = ", ".join(delivery_notes)
-
- def build_delivery_note_map(self):
- if self.invoices and self.filters.show_delivery_notes:
- self.delivery_notes = frappe._dict()
-
- # delivery note link inside sales invoice
- # nosemgrep
- si_against_dn = frappe.db.sql(
- """
- select parent, delivery_note
- from `tabSales Invoice Item`
- where docstatus=1 and parent in (%s)
- """
- % (",".join(["%s"] * len(self.invoices))),
- tuple(self.invoices),
- as_dict=1,
- )
-
- for d in si_against_dn:
- if d.delivery_note:
- self.delivery_notes.setdefault(d.parent, set()).add(d.delivery_note)
-
- # nosemgrep
- dn_against_si = frappe.db.sql(
- """
- select distinct parent, against_sales_invoice
- from `tabDelivery Note Item`
- where against_sales_invoice in (%s)
- """
- % (",".join(["%s"] * len(self.invoices))),
- tuple(self.invoices),
- as_dict=1,
- )
-
- for d in dn_against_si:
- self.delivery_notes.setdefault(d.against_sales_invoice, set()).add(d.parent)
+ self.columns.append(po_col)
+
+ # Insert rebate columns after credit_note
+ col_fieldnames = [c.get("fieldname") for c in self.columns]
+ if "credit_note" in col_fieldnames:
+ idx = col_fieldnames.index("credit_note")
+ if self.account_type == "Receivable" and "rebate_given" not in col_fieldnames:
+ self.columns.insert(
+ idx + 1,
+ dict(
+ label=_("Rebate Given"),
+ fieldname="rebate_given",
+ fieldtype="Currency",
+ options="currency",
+ width=120,
+ ),
+ )
+ elif self.account_type == "Payable" and "rebate_received" not in col_fieldnames:
+ self.columns.insert(
+ idx + 1,
+ dict(
+ label=_("Rebate Received"),
+ fieldname="rebate_received",
+ fieldtype="Currency",
+ options="currency",
+ width=120,
+ ),
+ )
+
+ # Insert Days Until PDC and adjust labels if show_future_payments
+ if self.filters.show_future_payments:
+ for c in self.columns:
+ if c.get("fieldname") == "future_ref":
+ c["label"] = _("PDC Payment Ref")
+ elif c.get("fieldname") == "future_amount":
+ c["label"] = _("PDC Payment Amount")
+
+ col_fieldnames = [c.get("fieldname") for c in self.columns]
+ if "remaining_balance" in col_fieldnames and "days_until_pdc" not in col_fieldnames:
+ idx = col_fieldnames.index("remaining_balance")
+ self.columns.insert(
+ idx + 1,
+ dict(
+ label=_("Days Until PDC"),
+ fieldname="days_until_pdc",
+ fieldtype="Int",
+ width=120,
+ ),
+ )
+
+ # Default sales partner fieldname mapping
+ if self.filters.sales_partner and self.filters.account_type == "Receivable":
+ for c in self.columns:
+ if c.get("fieldname") == "sales_partner":
+ c["fieldname"] = "default_sales_partner"
def get_invoice_details(self):
- self.invoice_details = frappe._dict()
+ super().get_invoice_details()
+
if self.account_type == "Receivable":
- # nosemgrep
- si_list = frappe.db.sql(
- """
- select name, due_date, po_no
- from `tabSales Invoice`
- where posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
+ default_receivable_account = frappe.db.get_value(
+ "Company", self.filters.company, "default_receivable_account"
)
-
- for d in si_list:
- default_receivable_account = frappe.db.get_value('Company', self.filters.company, 'default_receivable_account')
-
+ for inv_name, d in self.invoice_details.items():
credit_note_total = frappe.db.sql(
"""
- select
- sum(`tabJournal Entry Account`.credit_in_account_currency)
- from
- `tabJournal Entry Account`
+ select sum(`tabJournal Entry Account`.credit_in_account_currency)
+ from `tabJournal Entry Account`
join `tabJournal Entry` on `tabJournal Entry`.name = `tabJournal Entry Account`.parent
- where
- `tabJournal Entry Account`.parent in (
- select
- `tabJournal Entry Account`.parent
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.reference_name = %s
- and `tabJournal Entry Account`.docstatus = 1
- )
- and `tabJournal Entry Account`.account = %s
+ where `tabJournal Entry Account`.parent in (
+ select `tabJournal Entry Account`.parent
+ from `tabJournal Entry Account`
+ where `tabJournal Entry Account`.reference_name = %s
and `tabJournal Entry Account`.docstatus = 1
- and `tabJournal Entry`.voucher_type = 'Credit Note';
- """, (d.name, default_receivable_account)
+ )
+ and `tabJournal Entry Account`.account = %s
+ and `tabJournal Entry Account`.docstatus = 1
+ and `tabJournal Entry`.voucher_type = 'Credit Note';
+ """,
+ (inv_name, default_receivable_account),
)
-
credit_note_total = credit_note_total[0][0] or 0 if credit_note_total else 0
d["rebate_given"] = credit_note_total
- self.invoice_details.setdefault(d.name, d)
- # Get Sales Team
- if self.filters.show_sales_person:
- # nosemgrep
- sales_team = frappe.db.sql(
- """
- select parent, sales_person
- from `tabSales Team`
- where parenttype = 'Sales Invoice'
- """,
- as_dict=1,
+ elif self.account_type == "Payable":
+ default_payable_account = frappe.db.get_value(
+ "Company", self.filters.company, "default_payable_account"
+ )
+ for inv_name, pi in self.invoice_details.items():
+ po = frappe.db.get_all(
+ "Purchase Invoice Item",
+ filters={"parent": inv_name},
+ fields=["distinct purchase_order"],
)
- for d in sales_team:
- self.invoice_details.setdefault(d.parent, {}).setdefault("sales_team", []).append(
- d.sales_person
- )
-
-
- if self.account_type == "Payable":
- # nosemgrep
- for pi in frappe.db.sql(
- """
- select name, due_date, bill_no, bill_date
- from `tabPurchase Invoice`
- where
- posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
- ):
- po = frappe.db.get_all('Purchase Invoice Item',filters={'parent': pi.name},fields=['distinct purchase_order'])
po_list = [
- f'{po.purchase_order}'
- for po in po if po.purchase_order
- ]
-
- default_payable_account = frappe.db.get_value('Company', self.filters.company, 'default_payable_account')
+ f'{p.purchase_order}'
+ for p in po
+ if p.purchase_order
+ ]
debit_note_total = frappe.db.sql(
"""
- select
- sum(`tabJournal Entry Account`.debit_in_account_currency)
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.parent in (
- select
- `tabJournal Entry Account`.parent
- from
- `tabJournal Entry Account`
- where
- `tabJournal Entry Account`.reference_name = %s
- and `tabJournal Entry Account`.docstatus = 1
- )
- and `tabJournal Entry Account`.account = %s
+ select sum(`tabJournal Entry Account`.debit_in_account_currency)
+ from `tabJournal Entry Account`
+ where `tabJournal Entry Account`.parent in (
+ select `tabJournal Entry Account`.parent
+ from `tabJournal Entry Account`
+ where `tabJournal Entry Account`.reference_name = %s
and `tabJournal Entry Account`.docstatus = 1
- """, (pi.name, default_payable_account)
+ )
+ and `tabJournal Entry Account`.account = %s
+ and `tabJournal Entry Account`.docstatus = 1
+ """,
+ (inv_name, default_payable_account),
)
-
debit_note_total = debit_note_total[0][0] or 0 if debit_note_total else 0
pi["rebate_received"] = debit_note_total
pi["purchase_order"] = ", ".join(po_list)
- self.invoice_details.setdefault(pi.name, pi)
-
- # Invoices booked via Journal Entries
- # nosemgrep
- journal_entries = frappe.db.sql(
- """
- select name, due_date, bill_no, bill_date
- from `tabJournal Entry`
- where
- posting_date <= %s
- and company = %s
- and docstatus = 1
- """,
- (self.filters.report_date, self.filters.company),
- as_dict=1,
- )
-
- for je in journal_entries:
- if je.bill_no:
- self.invoice_details.setdefault(je.name, je)
-
-
- def set_party_details(self, row):
- if not row.party:
- return
- # customer / supplier name
- party_details = self.get_party_details(row.party) or {}
- row.update(party_details)
-
- if self.filters.get("in_party_currency") or self.filters.get("party_account"):
- row.currency = row.account_currency
- else:
- row.currency = self.company_currency
-
- def allocate_outstanding_based_on_payment_terms(self, row):
- self.get_payment_terms(row)
- for term in row.payment_terms:
- # update "paid" and "outstanding" for this term
- if not term.paid:
- self.allocate_closing_to_term(row, term, "paid")
-
- # update "credit_note" and "outstanding" for this term
- if term.outstanding:
- self.allocate_closing_to_term(row, term, "credit_note")
-
- row.payment_terms = sorted(row.payment_terms, key=lambda x: x["due_date"])
-
- def get_payment_terms(self, row):
- # build payment_terms for row
- # nosemgrep
- payment_terms_details = frappe.db.sql(
- f"""
- select
- si.name, si.party_account_currency, si.currency, si.conversion_rate,
- si.total_advance, ps.due_date, ps.payment_term, ps.payment_amount, ps.base_payment_amount,
- ps.description, ps.paid_amount, ps.discounted_amount
- from `tab{row.voucher_type}` si, `tabPayment Schedule` ps
- where
- si.name = ps.parent and
- si.name = %s and
- si.is_return = 0
- order by ps.paid_amount desc, due_date
- """,
- row.voucher_no,
- as_dict=1,
- )
-
- original_row = frappe._dict(row)
- row.payment_terms = []
-
- # Cr Note's don't have Payment Terms
- if not payment_terms_details:
- return
-
- # Advance allocated during invoicing is not considered in payment terms
- # Deduct that from paid amount pre allocation
- row.paid -= flt(payment_terms_details[0].total_advance)
-
- # If single payment terms, no need to split the row
- if len(payment_terms_details) == 1 and payment_terms_details[0].payment_term:
- self.append_payment_term(row, payment_terms_details[0], original_row)
- return
-
- for d in payment_terms_details:
- term = frappe._dict(original_row)
- self.append_payment_term(row, d, term)
-
- def append_payment_term(self, row, d, term):
- if (
- self.filters.get("customer") or self.filters.get("supplier")
- ) and d.currency == d.party_account_currency:
- invoiced = d.payment_amount
- else:
- invoiced = d.base_payment_amount
-
- row.payment_terms.append(
- term.update(
- {
- "due_date": d.due_date,
- "invoiced": invoiced,
- "invoice_grand_total": row.invoiced,
- "payment_term": d.description or d.payment_term,
- "paid": d.paid_amount + d.discounted_amount,
- "credit_note": 0.0,
- "outstanding": invoiced - d.paid_amount - d.discounted_amount,
- }
- )
- )
-
- if d.paid_amount:
- row["paid"] -= d.paid_amount + d.discounted_amount
-
- def allocate_closing_to_term(self, row, term, key):
- if row[key]:
- if row[key] > term.outstanding:
- term[key] = term.outstanding
- row[key] -= term.outstanding
- else:
- term[key] = row[key]
- row[key] = 0
- term.outstanding -= term[key]
-
- def allocate_extra_payments_or_credits(self, row):
- # allocate extra payments / credits
- additional_row = None
- for key in ("paid", "credit_note"):
- if row[key] > 0:
- if not additional_row:
- additional_row = frappe._dict(row)
- additional_row.invoiced = 0.0
- additional_row[key] = row[key]
-
- if additional_row:
- additional_row.outstanding = (
- additional_row.invoiced - additional_row.paid - additional_row.credit_note
- )
- self.append_row(additional_row)
-
- def get_future_payments(self):
- if self.filters.show_future_payments:
- self.future_payments = frappe._dict()
- future_payments = list(self.get_future_payments_from_payment_entry())
- future_payments += list(self.get_future_payments_from_journal_entry())
- if future_payments:
- for d in future_payments:
- if d.future_amount and d.invoice_no:
- self.future_payments.setdefault((d.invoice_no, d.party), []).append(d)
-
- def get_future_payments_from_payment_entry(self):
- pe = frappe.qb.DocType("Payment Entry")
- pe_ref = frappe.qb.DocType("Payment Entry Reference")
- ifelse = query_builder.CustomFunction("IF", ["condition", "then", "else"])
-
- return (
- frappe.qb.from_(pe)
- .inner_join(pe_ref)
- .on(pe_ref.parent == pe.name)
- .select(
- (pe_ref.reference_name).as_("invoice_no"),
- pe.party,
- pe.party_type,
- (pe.posting_date).as_("future_date"),
- (pe_ref.allocated_amount).as_("future_amount"),
- (pe.reference_no).as_("future_ref"),
- ifelse(
- pe.payment_type == "Receive",
- pe.source_exchange_rate * pe_ref.allocated_amount,
- pe.target_exchange_rate * pe_ref.allocated_amount,
- ).as_("future_amount_in_base_currency"),
- )
- .where(
- (pe.docstatus < 2)
- & (pe.posting_date > self.filters.report_date)
- & (pe.party_type.isin(self.party_type))
- )
- ).run(as_dict=True)
-
- def get_future_payments_from_journal_entry(self):
- je = frappe.qb.DocType("Journal Entry")
- jea = frappe.qb.DocType("Journal Entry Account")
- query = (
- frappe.qb.from_(je)
- .inner_join(jea)
- .on(jea.parent == je.name)
- .select(
- jea.reference_name.as_("invoice_no"),
- jea.party,
- jea.party_type,
- je.posting_date.as_("future_date"),
- je.cheque_no.as_("future_ref"),
- )
- .where(
- (je.docstatus < 2)
- & (je.posting_date > self.filters.report_date)
- & (jea.party_type.isin(self.party_type))
- & (jea.reference_name.isnotnull())
- & (jea.reference_name != "")
- )
- )
-
- if self.filters.get("party"):
- if self.account_type == "Payable":
- query = query.select(
- Sum(jea.debit_in_account_currency - jea.credit_in_account_currency).as_("future_amount")
- )
- query = query.select(Sum(jea.debit - jea.credit).as_("future_amount_in_base_currency"))
- else:
- query = query.select(
- Sum(jea.credit_in_account_currency - jea.debit_in_account_currency).as_("future_amount")
- )
- query = query.select(Sum(jea.credit - jea.debit).as_("future_amount_in_base_currency"))
- else:
- query = query.select(
- Sum(jea.debit if self.account_type == "Payable" else jea.credit).as_(
- "future_amount_in_base_currency"
- )
- )
- query = query.select(
- Sum(
- jea.debit_in_account_currency
- if self.account_type == "Payable"
- else jea.credit_in_account_currency
- ).as_("future_amount")
- )
+ def set_invoice_details(self, row):
+ super().set_invoice_details(row)
- query = query.having(qb.Field("future_amount") > 0)
- return query.run(as_dict=True)
+ invoice_details = self.invoice_details.get(row.voucher_no, {})
+ if "rebate_received" in invoice_details:
+ row["rebate_received"] = invoice_details["rebate_received"]
+ row["paid"] = row["paid"] - row["rebate_received"]
+ elif "rebate_given" in invoice_details:
+ row["rebate_given"] = invoice_details["rebate_given"]
+ row["paid"] = row["paid"] - row["rebate_given"]
def allocate_future_payments(self, row):
- # future payments are captured in additional columns
- # this method allocates pending future payments against a voucher to
- # the current row (which could be generated from payment terms)
- if not self.filters.show_future_payments:
- return
-
- row.remaining_balance = row.outstanding
- row.future_amount = 0.0
- row.days_until_pdc = 0
- for future in self.future_payments.get((row.voucher_no, row.party), []):
- if self.filters.in_party_currency:
- future_amount_field = "future_amount"
- else:
- future_amount_field = "future_amount_in_base_currency"
-
- if row.remaining_balance != 0 and future.get(future_amount_field):
- if future.get(future_amount_field) > row.outstanding:
- row.future_amount = row.outstanding
- future[future_amount_field] = future.get(future_amount_field) - row.outstanding
- row.remaining_balance = 0
- else:
- row.future_amount += future.get(future_amount_field)
- future[future_amount_field] = 0
- row.remaining_balance = row.outstanding - row.future_amount
-
- row.setdefault("future_ref", []).append(
- cstr(future.future_ref) + "/" + cstr(future.future_date)
- )
+ super().allocate_future_payments(row)
+ if self.filters.show_future_payments:
+ row.days_until_pdc = 0
+ for future in self.future_payments.get((row.voucher_no, row.party), []):
if future.future_date:
row.days_until_pdc = max((getdate(future.future_date) - getdate(nowdate())).days, 0)
- else:
- row.days_until_pdc = 0
- if row.future_ref:
- row.future_ref = ", ".join(row.future_ref)
-
- def get_return_entries(self):
- doctype = "Sales Invoice" if self.account_type == "Receivable" else "Purchase Invoice"
- filters = {
- "posting_date": ("<=", self.filters.report_date),
- "is_return": 1,
- "docstatus": 1,
- "company": self.filters.company,
- "update_outstanding_for_self": 0,
- }
- or_filters = {}
- for party_type in self.party_type:
- party_field = scrub(party_type)
- if self.filters.get(party_field):
- or_filters.update({party_field: self.filters.get(party_field)})
- self.return_entries = frappe._dict(
- frappe.get_all(
- doctype, filters=filters, or_filters=or_filters, fields=["name", "return_against"], as_list=1
- )
- )
-
- def set_ageing(self, row):
- if self.filters.ageing_based_on == "Due Date":
- # use posting date as a fallback for advances posted via journal and payment entry
- # when ageing viewed by due date
- entry_date = row.due_date or row.posting_date
- elif self.filters.ageing_based_on == "Supplier Invoice Date":
- entry_date = row.bill_date
- else:
- entry_date = row.posting_date
-
- self.get_ageing_data(entry_date, row)
-
- # ageing buckets should not have amounts if due date is not reached
- if getdate(entry_date) > getdate(self.filters.report_date):
- [setattr(row, f"range{i}", 0.0) for i in self.range_numbers]
-
- row.total_due = sum(row[f"range{i}"] for i in self.range_numbers)
-
- def get_ageing_data(self, entry_date, row):
- # [0-30, 30-60, 60-90, 90-120, 120-above]
- [setattr(row, f"range{i}", 0.0) for i in self.range_numbers]
-
- if not (self.age_as_on and entry_date):
- return
-
- row.age = (getdate(self.age_as_on) - getdate(entry_date)).days or 0
-
- index = next(
- (i for i, days in enumerate(self.ranges) if cint(row.age) <= cint(days)), len(self.ranges)
- )
- row["range" + str(index + 1)] = row.outstanding
-
- def get_ple_entries(self):
- # get all the GL entries filtered by the given filters
-
- self.prepare_conditions()
-
- if self.filters.show_future_payments:
- self.qb_selection_filter.append(
- self.ple.posting_date.lte(self.filters.report_date)
- | (
- (self.ple.voucher_no == self.ple.against_voucher_no)
- & (Date(self.ple.creation).lte(self.filters.report_date))
- )
- )
- else:
- self.qb_selection_filter.append(self.ple.posting_date.lte(self.filters.report_date))
-
- ple = qb.DocType("Payment Ledger Entry")
- query = (
- qb.from_(ple)
- .select(
- ple.name,
- ple.account,
- ple.voucher_type,
- ple.voucher_no,
- ple.against_voucher_type,
- ple.against_voucher_no,
- ple.party_type,
- ple.cost_center,
- ple.party,
- ple.posting_date,
- ple.due_date,
- ple.account_currency,
- ple.amount,
- ple.amount_in_account_currency,
- )
- .where(ple.delinked == 0)
- .where(Criterion.all(self.qb_selection_filter))
- .where(Criterion.any(self.or_filters))
- )
-
- if self.filters.get("show_remarks"):
- if remarks_length := frappe.db.get_single_value(
- "Accounts Settings", "receivable_payable_remarks_length"
- ):
- query = query.select(Substring(ple.remarks, 1, remarks_length).as_("remarks"))
- else:
- query = query.select(ple.remarks)
-
- if self.filters.get("group_by_party"):
- query = query.orderby(self.ple.party, self.ple.posting_date)
- else:
- query = query.orderby(self.ple.posting_date, self.ple.party)
-
- self.ple_entries = query.run(as_dict=True)
-
- def get_sales_invoices_or_customers_based_on_sales_person(self):
- if self.filters.get("sales_person"):
- lft, rgt = frappe.db.get_value("Sales Person", self.filters.get("sales_person"), ["lft", "rgt"])
-
- # nosemgrep
- records = frappe.db.sql(
- """
- select distinct parent, parenttype
- from `tabSales Team` steam
- where parenttype in ('Customer', 'Sales Invoice')
- and exists(select name from `tabSales Person` where lft >= %s and rgt <= %s and name = steam.sales_person)
- """,
- (lft, rgt),
- as_dict=1,
- )
-
- self.sales_person_records = frappe._dict()
- for d in records:
- self.sales_person_records.setdefault(d.parenttype, set()).add(d.parent)
-
- def prepare_conditions(self):
- self.qb_selection_filter = []
- self.or_filters = []
-
- for _party_type in self.party_type:
- self.add_common_filters()
-
- if self.account_type == "Receivable":
- self.add_customer_filters()
-
- elif self.account_type == "Payable":
- self.add_supplier_filters()
-
- if self.filters.cost_center:
- self.get_cost_center_conditions()
-
- self.add_accounting_dimensions_filters()
-
- def get_cost_center_conditions(self):
- lft, rgt = frappe.db.get_value("Cost Center", self.filters.cost_center, ["lft", "rgt"])
- cost_center_list = [
- center.name
- for center in frappe.get_list("Cost Center", filters={"lft": (">=", lft), "rgt": ("<=", rgt)})
- ]
- self.qb_selection_filter.append(self.ple.cost_center.isin(cost_center_list))
-
- def add_common_filters(self):
- if self.filters.company:
- self.qb_selection_filter.append(self.ple.company == self.filters.company)
-
- if self.filters.finance_book:
- self.qb_selection_filter.append(self.ple.finance_book == self.filters.finance_book)
-
- if self.filters.get("party_type"):
- self.qb_selection_filter.append(self.filters.party_type == self.ple.party_type)
-
- if self.filters.get("party"):
- self.qb_selection_filter.append(self.ple.party.isin(self.filters.party))
-
- if self.filters.party_account:
- self.qb_selection_filter.append(self.ple.account == self.filters.party_account)
- else:
- # get GL with "receivable" or "payable" account_type
- accounts = [
- d.name
- for d in frappe.get_all(
- "Account", filters={"account_type": self.account_type, "company": self.filters.company}
- )
- ]
-
- if accounts:
- self.qb_selection_filter.append(self.ple.account.isin(accounts))
-
- def add_customer_filters(
- self,
- ):
- self.customer = qb.DocType("Customer")
-
- if self.filters.get("customer_group"):
- groups = get_customer_group_with_children(self.filters.customer_group)
- customers = (
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer["customer_group"].isin(groups))
- )
- self.qb_selection_filter.append(self.ple.party.isin(customers))
-
- if self.filters.get("territory"):
- self.get_hierarchical_filters("Territory", "territory")
-
- if self.filters.get("payment_terms_template"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer.payment_terms == self.filters.get("payment_terms_template"))
- )
- )
-
- if self.filters.get("sales_partner"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(self.customer)
- .select(self.customer.name)
- .where(self.customer.default_sales_partner == self.filters.get("sales_partner"))
- )
- )
-
- def add_supplier_filters(self):
- supplier = qb.DocType("Supplier")
- if self.filters.get("supplier_group"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(supplier)
- .select(supplier.name)
- .where(supplier.supplier_group == self.filters.get("supplier_group"))
- )
- )
-
- if self.filters.get("payment_terms_template"):
- self.qb_selection_filter.append(
- self.ple.party.isin(
- qb.from_(supplier)
- .select(supplier.name)
- .where(supplier.payment_terms == self.filters.get("supplier_group"))
- )
- )
-
- def get_hierarchical_filters(self, doctype, key):
- lft, rgt = frappe.db.get_value(doctype, self.filters.get(key), ["lft", "rgt"])
-
- doc = qb.DocType(doctype)
- ple = self.ple
- customer = self.customer
- groups = qb.from_(doc).select(doc.name).where((doc.lft >= lft) & (doc.rgt <= rgt))
- customers = qb.from_(customer).select(customer.name).where(customer[key].isin(groups))
- self.qb_selection_filter.append(ple.party.isin(customers))
-
- def add_accounting_dimensions_filters(self):
- accounting_dimensions = get_accounting_dimensions(as_list=False)
-
- if accounting_dimensions:
- for dimension in accounting_dimensions:
- if self.filters.get(dimension.fieldname):
- if frappe.get_cached_value("DocType", dimension.document_type, "is_tree"):
- self.filters[dimension.fieldname] = get_dimension_with_children(
- dimension.document_type, self.filters.get(dimension.fieldname)
- )
- self.qb_selection_filter.append(
- self.ple[dimension.fieldname].isin(self.filters[dimension.fieldname])
- )
- else:
- self.qb_selection_filter.append(
- self.ple[dimension.fieldname].isin(self.filters[dimension.fieldname])
- )
-
- def is_invoice(self, ple):
- if ple.voucher_type in ("Sales Invoice", "Purchase Invoice"):
- return True
-
- def get_party_details(self, party):
- if party not in self.party_details:
- if self.account_type == "Receivable":
- fields = ["customer_name", "territory", "customer_group", "customer_primary_contact"]
-
- if self.filters.get("sales_partner"):
- fields.append("default_sales_partner")
-
- self.party_details[party] = frappe.db.get_value(
- "Customer",
- party,
- fields,
- as_dict=True,
- )
- else:
- self.party_details[party] = frappe.db.get_value(
- "Supplier", party, ["supplier_name", "supplier_group"], as_dict=True
- )
-
- return self.party_details[party]
-
- def get_columns(self):
- self.columns = []
- self.add_column("Posting Date", fieldtype="Date")
- self.add_column(
- label="Party Type",
- fieldname="party_type",
- fieldtype="Data",
- width=100,
- )
- self.add_column(
- label="Party",
- fieldname="party",
- fieldtype="Dynamic Link",
- options="party_type",
- width=180,
- )
- self.add_column(
- label=self.account_type + " Account",
- fieldname="party_account",
- fieldtype="Link",
- options="Account",
- width=180,
- )
-
- if self.party_naming_by == "Naming Series":
- if self.account_type == "Payable":
- label = "Supplier Name"
- fieldname = "supplier_name"
- else:
- label = "Customer Name"
- fieldname = "customer_name"
- self.add_column(
- label=label,
- fieldname=fieldname,
- fieldtype="Data",
- )
-
- if self.account_type == "Receivable":
- self.add_column(
- _("Customer Contact"),
- fieldname="customer_primary_contact",
- fieldtype="Link",
- options="Contact",
- )
-
- self.add_column(label=_("Cost Center"), fieldname="cost_center", fieldtype="Data")
- self.add_column(label=_("Voucher Type"), fieldname="voucher_type", fieldtype="Data")
- self.add_column(
- label=_("Voucher No"),
- fieldname="voucher_no",
- fieldtype="Dynamic Link",
- options="voucher_type",
- width=180,
- )
-
- self.add_column(label="Due Date", fieldtype="Date")
-
- if self.account_type == "Payable":
- self.add_column(label=_("Purchase Order"), fieldname="purchase_order", fieldtype="Data", width="180")
- self.add_column(label=_("Bill No"), fieldname="bill_no", fieldtype="Data")
- self.add_column(label=_("Bill Date"), fieldname="bill_date", fieldtype="Date")
-
- if self.filters.based_on_payment_terms:
- self.add_column(label=_("Payment Term"), fieldname="payment_term", fieldtype="Data")
- self.add_column(label=_("Invoice Grand Total"), fieldname="invoice_grand_total")
-
- self.add_column(_("Invoiced Amount"), fieldname="invoiced")
- self.add_column(_("Paid Amount"), fieldname="paid")
- if self.account_type == "Receivable":
- self.add_column(_("Credit Note"), fieldname="credit_note")
- self.add_column(_("Rebate Given"), fieldname="rebate_given")
- else:
- # note: fieldname is still `credit_note`
- self.add_column(_("Debit Note"), fieldname="credit_note")
- self.add_column(_("Rebate Received"), fieldname="rebate_received")
- self.add_column(_("Outstanding Amount"), fieldname="outstanding")
-
- self.add_column(label=_("Age (Days)"), fieldname="age", fieldtype="Int", width=80)
- self.setup_ageing_columns()
-
- self.add_column(
- label=_("Currency"), fieldname="currency", fieldtype="Link", options="Currency", width=80
- )
-
- if self.filters.show_future_payments:
- self.add_column(label=_("PDC Payment Ref"), fieldname="future_ref", fieldtype="Data")
- self.add_column(label=_("PDC Payment Amount"), fieldname="future_amount")
- self.add_column(label=_("Remaining Balance"), fieldname="remaining_balance")
- self.add_column(label=_("Days Until PDC"), fieldname="days_until_pdc", fieldtype="Int")
-
- if self.filters.account_type == "Receivable":
- self.add_column(label=_("Customer LPO"), fieldname="po_no", fieldtype="Data")
-
- # comma separated list of linked delivery notes
- if self.filters.show_delivery_notes:
- self.add_column(label=_("Delivery Notes"), fieldname="delivery_notes", fieldtype="Data")
- self.add_column(
- label=_("Territory"), fieldname="territory", fieldtype="Link", options="Territory"
- )
- self.add_column(
- label=_("Customer Group"),
- fieldname="customer_group",
- fieldtype="Link",
- options="Customer Group",
- )
- if self.filters.show_sales_person:
- self.add_column(label=_("Sales Person"), fieldname="sales_person", fieldtype="Data")
-
- if self.filters.sales_partner:
- self.add_column(label=_("Sales Partner"), fieldname="default_sales_partner", fieldtype="Data")
-
- if self.filters.account_type == "Payable":
- self.add_column(
- label=_("Supplier Group"),
- fieldname="supplier_group",
- fieldtype="Link",
- options="Supplier Group",
- )
-
- if self.filters.show_remarks:
- self.add_column(label=_("Remarks"), fieldname="remarks", fieldtype="Text", width=200)
-
- def add_column(self, label, fieldname=None, fieldtype="Currency", options=None, width=120):
- if not fieldname:
- fieldname = scrub(label)
- if fieldtype == "Currency":
- options = "currency"
- if fieldtype == "Date":
- width = 110
-
- self.columns.append(
- dict(label=label, fieldname=fieldname, fieldtype=fieldtype, options=options, width=width)
- )
-
- def setup_ageing_columns(self):
- # for charts
- self.ageing_column_labels = []
- ranges = [*self.ranges, "Above"]
-
- prev_range_value = 0
- for idx, curr_range_value in enumerate(ranges):
- label = f"{prev_range_value}-{curr_range_value}"
- self.add_column(label=label, fieldname="range" + str(idx + 1))
-
- self.ageing_column_labels.append(label)
-
- if curr_range_value.isdigit():
- prev_range_value = cint(curr_range_value) + 1
-
- def get_chart_data(self):
- precision = cint(frappe.db.get_default("float_precision")) or 2
- rows = []
- for row in self.data:
- row = frappe._dict(row)
- if not cint(row.bold):
- values = [flt(row.get(f"range{i}", None), precision) for i in self.range_numbers]
- rows.append({"values": values})
-
- self.chart = {
- "data": {"labels": self.ageing_column_labels, "datasets": rows},
- "type": "percentage",
- }
-
- def get_exchange_rate_revaluations(self):
- je = qb.DocType("Journal Entry")
- results = (
- qb.from_(je)
- .select(je.name)
- .where(
- (je.company == self.filters.company)
- & (je.posting_date.lte(self.filters.report_date))
- & (
- (je.voucher_type == "Exchange Rate Revaluation")
- | (je.voucher_type == "Exchange Gain Or Loss")
- )
- )
- .run()
- )
- self.err_journals = [x[0] for x in results] if results else []
+ break
+ def build_data(self):
+ # Spollex only considers Sales Invoices and Purchase Invoices
+ for _key, row in list(self.voucher_balance.items()):
+ if row.voucher_type not in ("Sales Invoice", "Purchase Invoice"):
+ self.voucher_balance.pop(_key, None)
-def get_customer_group_with_children(customer_groups):
- if not isinstance(customer_groups, list):
- customer_groups = [d.strip() for d in customer_groups.strip().split(",") if d]
+ super().build_data()
- all_customer_groups = []
- for d in customer_groups:
- if frappe.db.exists("Customer Group", d):
- lft, rgt = frappe.db.get_value("Customer Group", d, ["lft", "rgt"])
- children = frappe.get_all("Customer Group", filters={"lft": [">=", lft], "rgt": ["<=", rgt]})
- all_customer_groups += [c.name for c in children]
- else:
- frappe.throw(_("Customer Group: {0} does not exist").format(d))
- return list(set(all_customer_groups))
+# Export alias for backwards compatibility
+ReceivablePayableReport = SpollexReceivablePayableReport
diff --git a/spollex/spollex/report/payable_summary_with_rebate_received/payable_summary_with_rebate_received.py b/spollex/spollex/report/payable_summary_with_rebate_received/payable_summary_with_rebate_received.py
index 7380cae..9e53a87 100644
--- a/spollex/spollex/report/payable_summary_with_rebate_received/payable_summary_with_rebate_received.py
+++ b/spollex/spollex/report/payable_summary_with_rebate_received/payable_summary_with_rebate_received.py
@@ -1,9 +1,8 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
-
from spollex.spollex.report.receivable_summary_with_rebate_given.receivable_summary_with_rebate_given import (
- AccountsReceivableSummary,
+ SpollexAccountsReceivableSummary,
)
@@ -12,4 +11,7 @@ def execute(filters=None):
"account_type": "Payable",
"naming_by": ["Buying Settings", "supp_master_name"],
}
- return AccountsReceivableSummary(filters).run(args)
\ No newline at end of file
+ return SpollexAccountsReceivableSummary(filters).run(args)
+
+
+AccountsReceivableSummary = SpollexAccountsReceivableSummary
\ No newline at end of file
diff --git a/spollex/spollex/report/profit_and_loss_statement_with_gross_profit/profit_and_loss_statement_with_gross_profit.py b/spollex/spollex/report/profit_and_loss_statement_with_gross_profit/profit_and_loss_statement_with_gross_profit.py
index 6ea3e97..d0ba02a 100644
--- a/spollex/spollex/report/profit_and_loss_statement_with_gross_profit/profit_and_loss_statement_with_gross_profit.py
+++ b/spollex/spollex/report/profit_and_loss_statement_with_gross_profit/profit_and_loss_statement_with_gross_profit.py
@@ -1,11 +1,11 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
+from collections import defaultdict
import frappe
from frappe import _
from frappe.utils import flt
from frappe.utils.nestedset import get_descendants_of
-from collections import defaultdict
from erpnext.accounts.report.financial_statements import (
compute_growth_view_data,
@@ -15,6 +15,9 @@
get_filtered_list_for_consolidated_report,
get_period_list,
)
+from erpnext.accounts.report.profit_and_loss_statement.profit_and_loss_statement import (
+ get_net_profit_loss as erpnext_get_net_profit_loss,
+)
def execute(filters=None):
@@ -64,7 +67,7 @@ def execute(filters=None):
direct_income, indirect_income, direct_expense, indirect_expense = [], [], [], []
- for row in income:
+ for row in income or []:
account = row.get("account")
if not account:
continue
@@ -73,7 +76,7 @@ def execute(filters=None):
elif account in indirect_income_accounts or account == indirect_income_root:
indirect_income.append(row)
- for row in expense:
+ for row in expense or []:
account = row.get("account")
if not account:
continue
@@ -134,12 +137,11 @@ def execute(filters=None):
compute_margin_view_data(data, period_list, filters.accumulated_values)
if filters.periodicity == "Yearly":
- # Add a separate "Total" column
columns.append({
"label": _("Total"),
"fieldname": "total",
"fieldtype": "Currency",
- "width": 150
+ "width": 150,
})
for row in data:
@@ -147,20 +149,21 @@ def execute(filters=None):
continue
total_value = 0.0
-
- # Sum across all period columns
for period in period_list:
key = period.key
if key in row:
total_value += flt(row[key])
- if (row.get("is_group") and row.get("indent", 0) == 0) or row.get("account_name") in ("'Total Income (Credit)'", "'Total Expense (Debit)'",
- "'Gross Profit'", "'Net Profit'"):
- # clear yearly column values
+
+ if (row.get("is_group") and row.get("indent", 0) == 0) or row.get("account_name") in (
+ "'Total Income (Credit)'",
+ "'Total Expense (Debit)'",
+ "'Gross Profit'",
+ "'Net Profit'",
+ ):
for period in period_list:
key = period.key
if key in row:
row[key] = None
- # set total only for group accounts
row["total"] = total_value
else:
row["total"] = None
@@ -174,7 +177,6 @@ def get_report_summary(
):
net_income, net_direct_expense, gross_profit, net_indirect_expense, net_profit = 0.0, 0.0, 0.0, 0.0, 0.0
- # Apply consolidated filtering
if filters.get("accumulated_in_group_company"):
period_list = get_filtered_list_for_consolidated_report(filters, period_list)
@@ -257,7 +259,7 @@ def get_gross_profit_loss(income, direct_expense, period_list, company, currency
key = period if consolidated else period.key
total_income = flt(income[-2][key], 3) if income else 0
total_direct_expense = flt(direct_expense[0][key], 3) if direct_expense else 0
-
+
gross_profit_loss[key] = total_income - total_direct_expense
if gross_profit_loss[key]:
@@ -276,7 +278,7 @@ def get_net_profit_loss(income, expense, period_list, company, currency=None, co
"account_name": "'" + _("Net Profit") + "'",
"account": "'" + _("Net Profit") + "'",
"warn_if_negative": True,
- "currency": currency or frappe.get_cached_value("Company", company, "default_currency")
+ "currency": currency or frappe.get_cached_value("Company", company, "default_currency"),
}
has_value = False
@@ -299,12 +301,14 @@ def get_net_profit_loss(income, expense, period_list, company, currency=None, co
def get_chart_data(filters, columns, income, direct_expense, gross_profit_loss, indirect_expense, net_profit_loss, currency):
- labels = [d.get("label") for d in columns[2:]]
+ labels = [d.get("label") for d in columns[2:] if d.get("fieldname") != "total"]
income_data, direct_data, gross_data, indirect_data, net_data = [], [], [], [], []
for col in columns[2:]:
fieldname = col.get("fieldname")
+ if fieldname == "total":
+ continue
if income:
income_data.append(income[-2].get(fieldname, 0.0))
if direct_expense:
@@ -331,21 +335,18 @@ def get_chart_data(filters, columns, income, direct_expense, gross_profit_loss,
chart = {
"data": {
"labels": labels,
- "datasets": datasets
+ "datasets": datasets,
},
"type": "line" if filters.accumulated_values else "bar",
"fieldtype": "Currency",
"options": "currency",
- "currency": currency
+ "currency": currency,
}
return chart
def reset_indent_tree(income_expense_rows, root_account_name, company_abbr):
- from collections import defaultdict
-
- # Build account lookup and parent-child map
account_map = {}
child_map = defaultdict(list)
@@ -358,7 +359,7 @@ def reset_indent_tree(income_expense_rows, root_account_name, company_abbr):
child_map[parent].append(account)
ordered_rows = []
- # Recursive function to set indent
+
def set_indent(account, indent_level):
row = account_map.get(account)
if row:
@@ -366,16 +367,11 @@ def set_indent(account, indent_level):
ordered_rows.append(row)
children = child_map.get(account, [])
-
if account == f"Direct Income - {company_abbr}":
-
children = sorted(children, key=lambda x: (x != f"Sales - {company_abbr}", x.lower()))
for child in children:
set_indent(child, indent_level + 1)
set_indent(root_account_name, 0)
-
income_expense_rows[:] = ordered_rows
-
-
diff --git a/spollex/spollex/report/receivable_summary_with_rebate_given/receivable_summary_with_rebate_given.py b/spollex/spollex/report/receivable_summary_with_rebate_given/receivable_summary_with_rebate_given.py
index 4c56c44..65cb48c 100644
--- a/spollex/spollex/report/receivable_summary_with_rebate_given/receivable_summary_with_rebate_given.py
+++ b/spollex/spollex/report/receivable_summary_with_rebate_given/receivable_summary_with_rebate_given.py
@@ -1,13 +1,14 @@
# Copyright (c) 2025, 4C Solutions and contributors
# For license information, please see license.txt
-import frappe
-from frappe import _, scrub
-from frappe.utils import cint, flt
-
-from erpnext.accounts.party import get_partywise_advanced_payment_amount
-from spollex.spollex.report.accounts_receivable_with_rebate_given.accounts_receivable_with_rebate_given import ReceivablePayableReport
-from erpnext.accounts.utils import get_currency_precision, get_party_types_from_account_type
+from erpnext.accounts.report.accounts_receivable_summary import accounts_receivable_summary
+from erpnext.accounts.report.accounts_receivable_summary.accounts_receivable_summary import (
+ AccountsReceivableSummary as ERPNextAccountsReceivableSummary,
+)
+from frappe import _
+from spollex.spollex.report.accounts_receivable_with_rebate_given.accounts_receivable_with_rebate_given import (
+ SpollexReceivablePayableReport,
+)
def execute(filters=None):
@@ -15,208 +16,63 @@ def execute(filters=None):
"account_type": "Receivable",
"naming_by": ["Selling Settings", "cust_master_name"],
}
+ return SpollexAccountsReceivableSummary(filters).run(args)
- return AccountsReceivableSummary(filters).run(args)
-
-
-class AccountsReceivableSummary(ReceivablePayableReport):
- def run(self, args):
- self.account_type = args.get("account_type")
- self.party_type = get_party_types_from_account_type(self.account_type)
- self.party_naming_by = frappe.db.get_value(args.get("naming_by")[0], None, args.get("naming_by")[1])
- self.get_columns()
- self.get_data(args)
- return self.columns, self.data
-
- def get_data(self, args):
- self.data = []
- self.receivables = ReceivablePayableReport(self.filters).run(args)[1]
- self.currency_precision = get_currency_precision() or 2
- self.get_party_total(args)
-
- party = None
- for party_type in self.party_type:
- if self.filters.get(scrub(party_type)):
- party = self.filters.get(scrub(party_type))
-
- party_advance_amount = (
- get_partywise_advanced_payment_amount(
- self.party_type,
- self.filters.report_date,
- self.filters.show_future_payments,
- self.filters.company,
- party=party,
- )
- or {}
- )
-
- if self.filters.show_gl_balance:
- gl_balance_map = get_gl_balance(self.filters.report_date, self.filters.company)
-
- for party, party_dict in self.party_total.items():
- if flt(party_dict.outstanding, self.currency_precision) == 0:
- continue
-
- row = frappe._dict()
-
- row.party = party
- if self.party_naming_by == "Naming Series":
- if self.account_type == "Payable":
- doctype = "Supplier"
- fieldname = "supplier_name"
- else:
- doctype = "Customer"
- fieldname = "customer_name"
- row.party_name = frappe.get_cached_value(doctype, party, fieldname)
-
- row.update(party_dict)
-
- # Advance against party
- row.advance = party_advance_amount.get(party, 0)
-
- # In AR/AP, advance shown in paid columns,
- # but in summary report advance shown in separate column
- row.paid -= row.advance
-
- if self.filters.show_gl_balance:
- row.gl_balance = gl_balance_map.get(party)
- row.diff = flt(row.outstanding) - flt(row.gl_balance)
-
- if self.filters.show_future_payments:
- row.remaining_balance = flt(row.outstanding) - flt(row.future_amount)
-
- self.data.append(row)
-
- def get_party_total(self, args):
- self.party_total = frappe._dict()
-
- for d in self.receivables:
- self.init_party_total(d)
- # Add all amount columns
- for k in list(self.party_total[d.party]):
- if isinstance(self.party_total[d.party][k], float):
- self.party_total[d.party][k] += d.get(k) or 0.0
-
- # set territory, customer_group, sales person etc
- self.set_party_details(d)
+class SpollexAccountsReceivableSummary(ERPNextAccountsReceivableSummary):
+ def get_columns(self):
+ super().get_columns()
+
+ col_fieldnames = [c.get("fieldname") for c in self.columns]
+ if "credit_note" in col_fieldnames:
+ idx = col_fieldnames.index("credit_note")
+ if self.account_type == "Receivable" and "rebate_given" not in col_fieldnames:
+ self.columns.insert(
+ idx + 1,
+ dict(
+ label=_("Rebate Given"),
+ fieldname="rebate_given",
+ fieldtype="Currency",
+ options="currency",
+ width=120,
+ ),
+ )
+ elif self.account_type == "Payable" and "rebate_received" not in col_fieldnames:
+ self.columns.insert(
+ idx + 1,
+ dict(
+ label=_("Rebate Received"),
+ fieldname="rebate_received",
+ fieldtype="Currency",
+ options="currency",
+ width=120,
+ ),
+ )
+
+ if self.filters.sales_partner and self.account_type == "Receivable":
+ for c in self.columns:
+ if c.get("fieldname") == "sales_partner":
+ c["fieldname"] = "default_sales_partner"
def init_party_total(self, row):
- default_dict = {
- "invoiced": 0.0,
- "paid": 0.0,
- "credit_note": 0.0,
- "outstanding": 0.0,
- "total_due": 0.0,
- "future_amount": 0.0,
- "sales_person": [],
- "party_type": row.party_type,
- "rebate_received": 0.0,
- "rebate_given": 0.0
- }
- for i in self.range_numbers:
- range_key = f"range{i}"
- default_dict[range_key] = 0.0
-
- self.party_total.setdefault(
- row.party,
- frappe._dict(default_dict),
- )
+ super().init_party_total(row)
+ self.party_total[row.party]["rebate_received"] = 0.0
+ self.party_total[row.party]["rebate_given"] = 0.0
def set_party_details(self, row):
- self.party_total[row.party].currency = row.currency
-
- for key in ("territory", "customer_group", "supplier_group"):
- if row.get(key):
- self.party_total[row.party][key] = row.get(key, "")
- if row.sales_person:
- self.party_total[row.party].sales_person.append(row.get("sales_person", ""))
-
+ super().set_party_details(row)
if self.filters.sales_partner:
- self.party_total[row.party]["default_sales_partner"] = row.get("default_sales_partner", "")
-
- def get_columns(self):
- self.columns = []
- self.add_column(
- label=_("Party Type"),
- fieldname="party_type",
- fieldtype="Data",
- width=100,
- )
- self.add_column(
- label=_("Party"),
- fieldname="party",
- fieldtype="Dynamic Link",
- options="party_type",
- width=180,
- )
-
- if self.party_naming_by == "Naming Series":
- self.add_column(
- label=_("Supplier Name") if self.account_type == "Payable" else _("Customer Name"),
- fieldname="party_name",
- fieldtype="Data",
- )
-
- credit_debit_label = "Credit Note" if self.account_type == "Receivable" else "Debit Note"
-
- self.add_column(_("Advance Amount"), fieldname="advance")
- self.add_column(_("Invoiced Amount"), fieldname="invoiced")
- self.add_column(_("Paid Amount"), fieldname="paid")
- self.add_column(_(credit_debit_label), fieldname="credit_note")
- if self.account_type == "Receivable":
- self.add_column(_("Rebate Given"), fieldname="rebate_given")
- else:
- self.add_column(_("Rebate Received"), fieldname="rebate_received")
- self.add_column(_("Outstanding Amount"), fieldname="outstanding")
-
- if self.filters.show_gl_balance:
- self.add_column(_("GL Balance"), fieldname="gl_balance")
- self.add_column(_("Difference"), fieldname="diff")
-
- self.setup_ageing_columns()
- self.add_column(label="Total Amount Due", fieldname="total_due")
-
- if self.filters.show_future_payments:
- self.add_column(label=_("Future Payment Amount"), fieldname="future_amount")
- self.add_column(label=_("Remaining Balance"), fieldname="remaining_balance")
-
- if self.account_type == "Receivable":
- self.add_column(
- label=_("Territory"), fieldname="territory", fieldtype="Link", options="Territory"
+ self.party_total[row.party]["default_sales_partner"] = row.get(
+ "default_sales_partner", ""
)
- self.add_column(
- label=_("Customer Group"),
- fieldname="customer_group",
- fieldtype="Link",
- options="Customer Group",
- )
- if self.filters.show_sales_person:
- self.add_column(label=_("Sales Person"), fieldname="sales_person", fieldtype="Data")
-
- if self.filters.sales_partner:
- self.add_column(label=_("Sales Partner"), fieldname="default_sales_partner", fieldtype="Data")
- else:
- self.add_column(
- label=_("Supplier Group"),
- fieldname="supplier_group",
- fieldtype="Link",
- options="Supplier Group",
- )
-
- self.add_column(
- label=_("Currency"), fieldname="currency", fieldtype="Link", options="Currency", width=80
- )
+ def get_data(self, args):
+ orig_rp = accounts_receivable_summary.ReceivablePayableReport
+ accounts_receivable_summary.ReceivablePayableReport = SpollexReceivablePayableReport
+ try:
+ super().get_data(args)
+ finally:
+ accounts_receivable_summary.ReceivablePayableReport = orig_rp
-def get_gl_balance(report_date, company):
- return frappe._dict(
- frappe.db.get_all(
- "GL Entry",
- fields=["party", "sum(debit - credit)"],
- filters={"posting_date": ("<=", report_date), "is_cancelled": 0, "company": company},
- group_by="party",
- as_list=1,
- )
- )
\ No newline at end of file
+AccountsReceivableSummary = SpollexAccountsReceivableSummary
\ No newline at end of file
diff --git a/spollex/spollex/report/sales_insights/sales_insights.py b/spollex/spollex/report/sales_insights/sales_insights.py
index 2c26a38..fa0237d 100644
--- a/spollex/spollex/report/sales_insights/sales_insights.py
+++ b/spollex/spollex/report/sales_insights/sales_insights.py
@@ -2,494 +2,72 @@
# For license information, please see license.txt
import frappe
-from frappe import _, scrub
-from frappe.query_builder import DocType
-from frappe.query_builder.functions import IfNull
-from frappe.utils import add_days, add_to_date, flt, getdate
+from frappe import _
+from erpnext.selling.report.sales_analytics.sales_analytics import Analytics
-def execute(filters=None):
- return Analytics(filters).run()
-
-class Analytics:
- def __init__(self, filters=None):
- self.filters = frappe._dict(filters or {})
- self.date_field = (
- "transaction_date"
- if self.filters.doc_type in ["Sales Order", "Purchase Order"]
- else "posting_date"
- )
- self.months = [
- "Jan",
- "Feb",
- "Mar",
- "Apr",
- "May",
- "Jun",
- "Jul",
- "Aug",
- "Sep",
- "Oct",
- "Nov",
- "Dec",
- ]
- self.get_period_date_ranges()
-
- def update_company_list_for_parent_company(self):
- company_list = [self.filters.get("company")]
-
- selected_company = self.filters.get("company")
- if (
- selected_company
- and self.filters.get("show_aggregate_value_from_subsidiary_companies")
- and frappe.db.get_value("Company", selected_company, "is_group")
- ):
- lft, rgt = frappe.db.get_value("Company", selected_company, ["lft", "rgt"])
- child_companies = frappe.db.get_list(
- "Company", filters={"lft": [">", lft], "rgt": ["<", rgt]}, pluck="name"
- )
-
- company_list.extend(child_companies)
- self.filters["company"] = company_list
-
- def run(self):
- self.update_company_list_for_parent_company()
- self.get_columns()
- self.get_data()
- self.get_chart_data()
-
- # Skipping total row for tree-view reports
- skip_total_row = 0
-
- if self.filters.tree_type in ["Supplier Group", "Item Group", "Customer Group", "Territory"]:
- skip_total_row = 1
+def execute(filters=None):
+ return SpollexAnalytics(filters).run()
- return self.columns, self.data, None, self.chart, None, skip_total_row
+class SpollexAnalytics(Analytics):
def get_columns(self):
- self.columns = [
- {
- "label": _(self.filters.tree_type),
- "options": self.filters.tree_type if self.filters.tree_type != "Order Type" else "",
- "fieldname": "entity",
- "fieldtype": "Link" if self.filters.tree_type != "Order Type" else "Data",
- "width": 140 if self.filters.tree_type != "Order Type" else 200,
- }
- ]
- if self.filters.tree_type in ["Customer", "Supplier", "Item"]:
- self.columns.append(
- {
- "label": _(self.filters.tree_type + " Name"),
- "fieldname": "entity_name",
- "fieldtype": "Data",
- "width": 140,
- }
- )
+ super().get_columns()
if self.filters.tree_type == "Item":
- self.columns.append(
- {
- "label": _("Item Group"),
- "fieldname": "item_group",
- "fieldtype": "Link",
- "options": "Item Group",
- "width": 100,
- }
- )
- self.columns.append(
- {
- "label": _("UOM"),
- "fieldname": "stock_uom",
- "fieldtype": "Link",
- "options": "UOM",
- "width": 100,
- }
- )
- self.columns.append(
- {
- "label": _("Stock In Hand"),
- "fieldname": "stock_in_hand",
- "fieldtype": "Data",
- "width": 120,
- }
- )
-
- for end_date in self.periodic_daterange:
- period = self.get_period(end_date)
- self.columns.append(
- {"label": _(period), "fieldname": scrub(period), "fieldtype": "Float", "width": 120}
- )
-
- self.columns.append({"label": _("Total"), "fieldname": "total", "fieldtype": "Float", "width": 120})
-
- def get_data(self):
- if self.filters.tree_type in ["Customer", "Supplier"]:
- self.get_sales_transactions_based_on_customers_or_suppliers()
- self.get_rows()
-
- elif self.filters.tree_type == "Item":
- self.get_sales_transactions_based_on_items()
- self.get_rows()
-
- elif self.filters.tree_type in ["Customer Group", "Supplier Group", "Territory"]:
- self.get_sales_transactions_based_on_customer_or_territory_group()
- self.get_rows_by_group()
-
- elif self.filters.tree_type == "Item Group":
- self.get_sales_transactions_based_on_item_group()
- self.get_rows_by_group()
-
- elif self.filters.tree_type == "Order Type":
- if self.filters.doc_type != "Sales Order":
- self.data = []
- return
- self.get_sales_transactions_based_on_order_type()
- self.get_rows_by_group()
-
- elif self.filters.tree_type == "Project":
- self.get_sales_transactions_based_on_project()
- self.get_rows()
-
- def get_sales_transactions_based_on_order_type(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_total"
- else:
- value_field = "total_qty"
-
- doctype = DocType(self.filters.doc_type)
-
- self.entries = (
- frappe.qb.from_(doctype)
- .select(
- doctype.order_type.as_("entity"),
- doctype[self.date_field],
- doctype[value_field].as_("value_field"),
- )
- .where(
- (doctype.docstatus == 1)
- & (doctype.company.isin(self.filters.company))
- & (doctype[self.date_field].between(self.filters.from_date, self.filters.to_date))
- & (IfNull(doctype.order_type, "") != "")
- )
- .orderby(doctype.order_type)
- ).run(as_dict=True)
-
- self.get_teams()
-
- def get_sales_transactions_based_on_customers_or_suppliers(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_total as value_field"
- else:
- value_field = "total_qty as value_field"
-
- if self.filters.tree_type == "Customer":
- entity = "customer as entity"
- entity_name = "customer_name as entity_name"
- else:
- entity = "supplier as entity"
- entity_name = "supplier_name as entity_name"
-
- self.entries = frappe.get_all(
- self.filters.doc_type,
- fields=[entity, entity_name, value_field, self.date_field],
- filters={
- "docstatus": 1,
- "company": ["in", self.filters.company],
- self.date_field: ("between", [self.filters.from_date, self.filters.to_date]),
- },
- )
-
- self.entity_names = {}
- for d in self.entries:
- self.entity_names.setdefault(d.entity, d.entity_name)
-
- def get_sales_transactions_based_on_items(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_amount"
- else:
- value_field = "stock_qty"
-
- doctype = DocType(self.filters.doc_type)
- doctype_item = DocType(f"{self.filters.doc_type} Item")
-
- self.entries = (
- frappe.qb.from_(doctype_item)
- .join(doctype)
- .on(doctype.name == doctype_item.parent)
- .select(
- doctype_item.item_code.as_("entity"),
- doctype_item.item_name.as_("entity_name"),
- doctype_item.item_group,
- doctype_item.stock_uom,
- doctype_item[value_field].as_("value_field"),
- doctype[self.date_field],
- )
- .where(
- (doctype_item.docstatus == 1)
- & (doctype.company.isin(self.filters.company))
- & (doctype[self.date_field].between(self.filters.from_date, self.filters.to_date))
- )
- ).run(as_dict=True)
-
- item_codes = [entry["entity"] for entry in self.entries]
-
- default_warehouse = frappe.db.get_single_value("Stock Settings", "default_warehouse")
-
- # Fetch stock in hand for the items
- stock_in_hand_data = frappe.get_all(
- "Bin",
- fields=["item_code", "actual_qty"],
- filters={
- "item_code": ["in", item_codes],
- "warehouse": default_warehouse
- },
- )
-
- # Map stock in hand to each item
- stock_in_hand_map = {d["item_code"]: d["actual_qty"] for d in stock_in_hand_data}
-
- # Add stock in hand to each entry
- for entry in self.entries:
- entry["stock_in_hand"] = stock_in_hand_map.get(entry["entity"], 0.0)
-
- self.entity_names = {}
- for d in self.entries:
- self.entity_names.setdefault(d.entity, d.entity_name)
-
- def get_sales_transactions_based_on_customer_or_territory_group(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_total as value_field"
- else:
- value_field = "total_qty as value_field"
-
- if self.filters.tree_type == "Customer Group":
- entity_field = "customer_group as entity"
- elif self.filters.tree_type == "Supplier Group":
- entity_field = "supplier as entity"
- self.get_supplier_parent_child_map()
- else:
- entity_field = "territory as entity"
-
- self.entries = frappe.get_all(
- self.filters.doc_type,
- fields=[entity_field, value_field, self.date_field],
- filters={
- "docstatus": 1,
- "company": ["in", self.filters.company],
- self.date_field: ("between", [self.filters.from_date, self.filters.to_date]),
- },
- )
- self.get_groups()
-
- def get_sales_transactions_based_on_item_group(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_amount"
- else:
- value_field = "qty"
-
- doctype = DocType(self.filters.doc_type)
- doctype_item = DocType(f"{self.filters.doc_type} Item")
-
- self.entries = (
- frappe.qb.from_(doctype_item)
- .join(doctype)
- .on(doctype.name == doctype_item.parent)
- .select(
- doctype_item.item_group.as_("entity"),
- doctype_item[value_field].as_("value_field"),
- doctype[self.date_field],
- )
- .where(
- (doctype_item.docstatus == 1)
- & (doctype.company.isin(self.filters.company))
- & (doctype[self.date_field].between(self.filters.from_date, self.filters.to_date))
- )
- ).run(as_dict=True)
-
- self.get_groups()
-
- def get_sales_transactions_based_on_project(self):
- if self.filters["value_quantity"] == "Value":
- value_field = "base_net_total as value_field"
- else:
- value_field = "total_qty as value_field"
-
- entity = "project as entity"
-
- self.entries = frappe.get_all(
- self.filters.doc_type,
- fields=[entity, value_field, self.date_field],
- filters={
- "docstatus": 1,
- "company": ["in", self.filters.company],
- "project": ["!=", ""],
- self.date_field: ("between", [self.filters.from_date, self.filters.to_date]),
- },
- )
+ # Find position of stock_uom to place item_group before it and stock_in_hand after it
+ stock_uom_idx = None
+ for idx, col in enumerate(self.columns):
+ if col.get("fieldname") == "stock_uom":
+ stock_uom_idx = idx
+ break
+
+ if stock_uom_idx is not None:
+ self.columns.insert(
+ stock_uom_idx,
+ {
+ "label": _("Item Group"),
+ "fieldname": "item_group",
+ "fieldtype": "Link",
+ "options": "Item Group",
+ "width": 100,
+ },
+ )
+ # stock_uom is now at stock_uom_idx + 1
+ self.columns.insert(
+ stock_uom_idx + 2,
+ {
+ "label": _("Stock In Hand"),
+ "fieldname": "stock_in_hand",
+ "fieldtype": "Data",
+ "width": 120,
+ },
+ )
def get_rows(self):
- self.data = []
- self.get_periodic_data()
-
- for entity, period_data in self.entity_periodic_data.items():
- row = {
- "entity": entity,
- "entity_name": self.entity_names.get(entity) if hasattr(self, "entity_names") else None,
- }
- total = 0
- for end_date in self.periodic_daterange:
- period = self.get_period(end_date)
- amount = flt(period_data.get(period, 0.0))
- row[scrub(period)] = amount
- total += amount
-
- row["total"] = total
-
- if self.filters.tree_type == "Item":
- row["item_group"] = period_data.get("item_group")
- row["stock_uom"] = period_data.get("stock_uom")
- row["stock_in_hand"] = period_data.get("stock_in_hand")
-
- self.data.append(row)
-
- def get_rows_by_group(self):
- self.get_periodic_data()
- out = []
-
- for d in reversed(self.group_entries):
- row = {"entity": d.name, "indent": self.depth_map.get(d.name)}
- total = 0
- for end_date in self.periodic_daterange:
- period = self.get_period(end_date)
- amount = flt(self.entity_periodic_data.get(d.name, {}).get(period, 0.0))
- row[scrub(period)] = amount
- if d.parent and (self.filters.tree_type != "Order Type" or d.parent == "Order Types"):
- self.entity_periodic_data.setdefault(d.parent, frappe._dict()).setdefault(period, 0.0)
- self.entity_periodic_data[d.parent][period] += amount
- total += amount
-
- row["total"] = total
- out = [row, *out]
-
- self.data = out
-
- def get_periodic_data(self):
- self.entity_periodic_data = frappe._dict()
-
- for d in self.entries:
- if self.filters.tree_type == "Supplier Group":
- d.entity = self.parent_child_map.get(d.entity)
- period = self.get_period(d.get(self.date_field))
- self.entity_periodic_data.setdefault(d.entity, frappe._dict()).setdefault(period, 0.0)
- self.entity_periodic_data[d.entity][period] += flt(d.value_field)
-
- if self.filters.tree_type == "Item":
- self.entity_periodic_data[d.entity]["item_group"] = d.item_group
- self.entity_periodic_data[d.entity]["stock_uom"] = d.stock_uom
- self.entity_periodic_data[d.entity]["stock_in_hand"] = d.stock_in_hand
-
- def get_period(self, posting_date):
- if self.filters.range == "Weekly":
- period = _("Week {0} {1}").format(str(posting_date.isocalendar()[1]), str(posting_date.year))
- elif self.filters.range == "Monthly":
- period = _(str(self.months[posting_date.month - 1])) + " " + str(posting_date.year)
- elif self.filters.range == "Quarterly":
- period = _("Quarter {0} {1}").format(
- str(((posting_date.month - 1) // 3) + 1), str(posting_date.year)
+ super().get_rows()
+
+ if self.filters.tree_type == "Item" and self.data:
+ item_codes = [r["entity"] for r in self.data if "entity" in r]
+
+ item_group_map = frappe._dict(
+ frappe.get_all(
+ "Item",
+ filters={"name": ["in", item_codes]},
+ fields=["name", "item_group"],
+ as_list=1,
+ )
)
- else:
- year = get_fiscal_year(posting_date, company=self.filters.company[0])
- period = str(year[0])
- return period
-
- def get_period_date_ranges(self):
- from dateutil.relativedelta import MO, relativedelta
-
- from_date, to_date = getdate(self.filters.from_date), getdate(self.filters.to_date)
-
- increment = {"Monthly": 1, "Quarterly": 3, "Half-Yearly": 6, "Yearly": 12}.get(self.filters.range, 1)
-
- if self.filters.range in ["Monthly", "Quarterly"]:
- from_date = from_date.replace(day=1)
- elif self.filters.range == "Yearly":
- from_date = get_fiscal_year(from_date)[1]
- else:
- from_date = from_date + relativedelta(from_date, weekday=MO(-1))
-
- self.periodic_daterange = []
- for _dummy in range(1, 53):
- if self.filters.range == "Weekly":
- period_end_date = add_days(from_date, 6)
- else:
- period_end_date = add_to_date(from_date, months=increment, days=-1)
-
- if period_end_date > to_date:
- period_end_date = to_date
-
- self.periodic_daterange.append(period_end_date)
-
- from_date = add_days(period_end_date, 1)
- if period_end_date == to_date:
- break
- def get_groups(self):
- if self.filters.tree_type == "Territory":
- parent = "parent_territory"
- if self.filters.tree_type == "Customer Group":
- parent = "parent_customer_group"
- if self.filters.tree_type == "Item Group":
- parent = "parent_item_group"
- if self.filters.tree_type == "Supplier Group":
- parent = "parent_supplier_group"
-
- self.depth_map = frappe._dict()
-
- self.group_entries = frappe.db.sql(
- f"""select name, lft, rgt , {parent} as parent
- from `tab{self.filters.tree_type}` order by lft""",
- as_dict=1,
- )
-
- for d in self.group_entries:
- if d.parent:
- self.depth_map.setdefault(d.name, self.depth_map.get(d.parent) + 1)
- else:
- self.depth_map.setdefault(d.name, 0)
-
- def get_teams(self):
- self.depth_map = frappe._dict()
-
- self.group_entries = frappe.db.sql(
- f""" select * from (select "Order Types" as name, 0 as lft,
- 2 as rgt, '' as parent union select distinct order_type as name, 1 as lft, 1 as rgt, "Order Types" as parent
- from `tab{self.filters.doc_type}` where ifnull(order_type, '') != '') as b order by lft, name
- """,
- as_dict=1,
- )
-
- for d in self.group_entries:
- if d.parent:
- self.depth_map.setdefault(d.name, self.depth_map.get(d.parent) + 1)
- else:
- self.depth_map.setdefault(d.name, 0)
-
- def get_supplier_parent_child_map(self):
- self.parent_child_map = frappe._dict(
- frappe.db.sql(""" select name, supplier_group from `tabSupplier`""")
- )
-
- def get_chart_data(self):
- length = len(self.columns)
-
- if self.filters.tree_type in ["Customer", "Supplier"]:
- labels = [d.get("label") for d in self.columns[2 : length - 1]]
- elif self.filters.tree_type == "Item":
- labels = [d.get("label") for d in self.columns[3 : length - 1]]
- else:
- labels = [d.get("label") for d in self.columns[1 : length - 1]]
- self.chart = {"data": {"labels": labels, "datasets": []}, "type": "line"}
+ default_warehouse = frappe.db.get_single_value("Stock Settings", "default_warehouse")
+ stock_data = frappe.get_all(
+ "Bin",
+ fields=["item_code", "actual_qty"],
+ filters={"item_code": ["in", item_codes], "warehouse": default_warehouse},
+ )
+ stock_map = {d["item_code"]: d["actual_qty"] for d in stock_data}
- if self.filters["value_quantity"] == "Value":
- self.chart["fieldtype"] = "Currency"
- else:
- self.chart["fieldtype"] = "Float"
+ for r in self.data:
+ item_code = r.get("entity")
+ r["item_group"] = item_group_map.get(item_code)
+ r["stock_in_hand"] = stock_map.get(item_code, 0.0)
diff --git a/spollex/spollex/report/sales_partner_commission_overview/sales_partner_commission_overview.py b/spollex/spollex/report/sales_partner_commission_overview/sales_partner_commission_overview.py
index abe5e1f..beb32d4 100644
--- a/spollex/spollex/report/sales_partner_commission_overview/sales_partner_commission_overview.py
+++ b/spollex/spollex/report/sales_partner_commission_overview/sales_partner_commission_overview.py
@@ -1,117 +1,46 @@
# Copyright (c) 2024, 4C Solutions and contributors
# For license information, please see license.txt
-import frappe
-from frappe import _, msgprint
+from frappe import _
+from frappe.utils import flt
+from erpnext.selling.report.sales_partner_commission_summary.sales_partner_commission_summary import (
+ SalesPartnerCommissionSummaryReport,
+)
+
def execute(filters=None):
if not filters:
filters = {}
- columns = get_columns(filters)
- data = get_entries(filters)
-
- return columns, data
-
-def get_columns(filters):
- if not filters.get("doctype"):
- msgprint(_("Please select the document type first"), raise_exception=1)
-
- columns = [
- {
- "label": _(filters["doctype"]),
- "options": filters["doctype"],
- "fieldname": "name",
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Customer"),
- "options": "Customer",
- "fieldname": "customer",
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Territory"),
- "options": "Territory",
- "fieldname": "territory",
- "fieldtype": "Link",
- "width": 100,
- },
- {"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 100},
- {"label": _("Amount"), "fieldname": "amount", "fieldtype": "Currency", "width": 120},
- {
- "label": _("Sales Partner"),
- "options": "Sales Partner",
- "fieldname": "sales_partner",
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Commission Rate %"),
- "fieldname": "commission_rate",
- "fieldtype": "Data",
- "width": 100,
- },
- {
- "label": _("Total Commission"),
- "fieldname": "total_commission",
- "fieldtype": "Currency",
- "width": 120,
- },
- {
- "label": _("Tax Deduction(9%)"),
- "fieldname": "tax_deduction",
- "fieldtype": "Currency",
- "width": 120,
- },
- {
- "label": _("Commission Payable"),
- "fieldname": "commission_payable",
- "fieldtype": "Currency",
- "width": 120,
- },
- ]
-
- return columns
-
-def get_entries(filters):
- date_field = "transaction_date" if filters.get("doctype") == "Sales Order" else "posting_date"
-
- conditions = get_conditions(filters, date_field)
- entries = frappe.db.sql(
- """
- SELECT
- name, customer, territory, {} as posting_date, base_net_total as amount,
- sales_partner, commission_rate, total_commission, total_commission * 0.09 as tax_deduction,
- total_commission - total_commission * 0.09 as commission_payable
- FROM
- `tab{}`
- WHERE
- {} and docstatus = 1 and sales_partner is not null
- and sales_partner != '' order by name desc, sales_partner
- """.format(date_field, filters.get("doctype"), conditions),
- filters,
- as_dict=1,
- )
-
- return entries
-
-def get_conditions(filters, date_field):
- conditions = "1=1"
-
- for field in ["company", "customer", "territory"]:
- if filters.get(field):
- conditions += f" and {field} = %({field})s"
-
- if filters.get("sales_partner"):
- conditions += " and sales_partner = %(sales_partner)s"
-
- if filters.get("from_date"):
- conditions += f" and {date_field} >= %(from_date)s"
-
- if filters.get("to_date"):
- conditions += f" and {date_field} <= %(to_date)s"
-
- return conditions
\ No newline at end of file
+ return SpollexSalesPartnerCommissionOverviewReport(filters).run()
+
+
+class SpollexSalesPartnerCommissionOverviewReport(SalesPartnerCommissionSummaryReport):
+ def prepare_columns(self):
+ super().prepare_columns()
+
+ # Add custom tax deduction and commission payable columns
+ self.make_column(
+ label=_("Tax Deduction(9%)"),
+ fieldname="tax_deduction",
+ fieldtype="Currency",
+ width=120,
+ )
+ self.make_column(
+ label=_("Commission Payable"),
+ fieldname="commission_payable",
+ fieldtype="Currency",
+ width=120,
+ )
+
+ def get_data(self):
+ super().get_data()
+
+ # Compute tax deduction and commission payable for each row
+ for row in self.data:
+ total_commission = flt(row.get("total_commission", 0.0))
+ tax_deduction = flt(total_commission * 0.09)
+ commission_payable = flt(total_commission - tax_deduction)
+
+ row["tax_deduction"] = tax_deduction
+ row["commission_payable"] = commission_payable
\ No newline at end of file
diff --git a/spollex/spollex/report/sales_person_commission_overview/sales_person_commission_overview.py b/spollex/spollex/report/sales_person_commission_overview/sales_person_commission_overview.py
index cdcd179..73bbbbd 100644
--- a/spollex/spollex/report/sales_person_commission_overview/sales_person_commission_overview.py
+++ b/spollex/spollex/report/sales_person_commission_overview/sales_person_commission_overview.py
@@ -1,151 +1,66 @@
# Copyright (c) 2024, 4C Solutions and contributors
# For license information, please see license.txt
-import frappe
-from frappe import _, msgprint
+from frappe import _
+from frappe.utils import flt
+from erpnext.selling.report.sales_person_commission_summary.sales_person_commission_summary import (
+ execute as erpnext_execute,
+ get_columns as erpnext_get_columns,
+)
+
def execute(filters=None):
if not filters:
filters = {}
columns = get_columns(filters)
- entries = get_entries(filters)
+ base_columns, base_data = erpnext_execute(filters)
+
data = []
+ if base_data:
+ has_total_row = all(x == "" for x in base_data[-1])
+ rows = base_data[:-1] if has_total_row else base_data
- for d in entries:
- data.append(
- [
- d.name,
- d.customer,
- d.territory,
- d.posting_date,
- d.base_net_amount,
- d.sales_person,
- d.allocated_percentage,
- d.commission_rate,
- d.allocated_amount,
- d.incentives,
- d.tax_deduction,
- d.incentives_payable,
- ]
- )
+ for d in rows:
+ incentives = flt(d[9])
+ tax_deduction = flt(incentives * 0.09)
+ incentives_payable = flt(incentives - tax_deduction)
- if data:
- total_row = [""] * len(data[0])
- data.append(total_row)
+ row = list(d) + [tax_deduction, incentives_payable]
+ data.append(row)
- return columns, data
+ if has_total_row and data:
+ total_row = [""] * len(data[0])
+ data.append(total_row)
-def get_columns(filters):
- if not filters.get("doc_type"):
- msgprint(_("Please select the document type first"), raise_exception=1)
-
- columns = [
- {
- "label": _(filters["doc_type"]),
- "options": filters["doc_type"],
- "fieldname": filters["doc_type"],
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Customer"),
- "options": "Customer",
- "fieldname": "customer",
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Territory"),
- "options": "Territory",
- "fieldname": "territory",
- "fieldtype": "Link",
- "width": 100,
- },
- {"label": _("Posting Date"), "fieldname": "posting_date", "fieldtype": "Date", "width": 100},
- {"label": _("Amount"), "fieldname": "amount", "fieldtype": "Currency", "width": 120},
- {
- "label": _("Sales Person"),
- "options": "Sales Person",
- "fieldname": "sales_person",
- "fieldtype": "Link",
- "width": 140,
- },
- {
- "label": _("Contribution %"),
- "fieldname": "contribution_percentage",
- "fieldtype": "Data",
- "width": 100,
- },
- {
- "label": _("Commission Rate %"),
- "fieldname": "commission_rate",
- "fieldtype": "Data",
- "width": 100,
- },
- {
- "label": _("Contribution Amount"),
- "fieldname": "contribution_amount",
- "fieldtype": "Currency",
- "width": 120,
- },
- {"label": _("Incentives"), "fieldname": "incentives", "fieldtype": "Currency", "width": 120},
- {
- "label": _("Tax Deduction(9%)"),
- "fieldname": "tax_deduction",
- "fieldtype": "Currency",
- "width": 120,
- },
- {
- "label": _("Incentives Payable"),
- "fieldname": "incentives_payable",
- "fieldtype": "Currency",
- "width": 120,
- },
- ]
-
- return columns
+ return columns, data
-def get_entries(filters):
- date_field = filters["doc_type"] == "Sales Order" and "transaction_date" or "posting_date"
- conditions, values = get_conditions(filters, date_field)
- entries = frappe.db.sql(
- """
- select
- dt.name, dt.customer, dt.territory, dt.{} as posting_date,dt.base_net_total as base_net_amount,
- st.commission_rate,st.sales_person, st.allocated_percentage, st.allocated_amount, st.incentives,
- st.incentives * 0.09 as tax_deduction, st.incentives - st.incentives * 0.09 as incentives_payable
- from
- `tab{}` dt, `tabSales Team` st
- where
- st.parent = dt.name and st.parenttype = {}
- and dt.docstatus = 1 {} order by dt.name desc,st.sales_person
- """.format(date_field, filters["doc_type"], "%s", conditions),
- tuple([filters["doc_type"], *values]),
- as_dict=1,
+def get_columns(filters):
+ columns = erpnext_get_columns(filters)
+
+ # Adjust width if needed to match custom styling
+ for col in columns:
+ if col.get("fieldname") == "contribution_percentage":
+ col["width"] = 100
+ elif col.get("fieldname") == "commission_rate":
+ col["width"] = 100
+
+ columns.extend(
+ [
+ {
+ "label": _("Tax Deduction(9%)"),
+ "fieldname": "tax_deduction",
+ "fieldtype": "Currency",
+ "width": 120,
+ },
+ {
+ "label": _("Incentives Payable"),
+ "fieldname": "incentives_payable",
+ "fieldtype": "Currency",
+ "width": 120,
+ },
+ ]
)
- return entries
-
-def get_conditions(filters, date_field):
- conditions = [""]
- values = []
-
- for field in ["company", "customer", "territory"]:
- if filters.get(field):
- conditions.append(f"dt.{field}=%s")
- values.append(filters[field])
-
- if filters.get("sales_person"):
- conditions.append("st.sales_person = '{}'".format(filters.get("sales_person")))
-
- if filters.get("from_date"):
- conditions.append(f"dt.{date_field}>=%s")
- values.append(filters["from_date"])
-
- if filters.get("to_date"):
- conditions.append(f"dt.{date_field}<=%s")
- values.append(filters["to_date"])
-
- return " and ".join(conditions), values
\ No newline at end of file
+ return columns
\ No newline at end of file