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