| {{period}} | + {% previous_period = period; %} + {% } %} + {% for(let value of Object.values(data[period].shift())) { %} +{{ value }} | + {% } %} +
| {{ value }} | + {% } %} +
| + | 2A / 2B | +Purchase | +||
|---|---|---|---|---|
| Document Links + {% if inward_supply.name %} + | {{ frappe.utils.get_form_link("GST Inward Supply", + inward_supply.name, true) }} | + {% else %} +- | + {% endif %} + + {% if purchase.name %} +{{ frappe.utils.get_form_link(purchase.doctype, + purchase.name, true)}} | + {% else %} +- | + {% endif %} +
| Bill No + | {{ inward_supply.bill_no || '-' }} | +{{ purchase.bill_no || '-' }} | +||
| Bill Date + | + {{ frappe.format(inward_supply.bill_date, {'fieldtype': 'Date'}) || '-' }} + | ++ {{ frappe.format(purchase.bill_date, {'fieldtype': 'Date'}) || '-' }} + | +||
| Place of Supply | +{{ inward_supply.place_of_supply || '-' }} | +{{ purchase.place_of_supply || '-' }} | +||
| Reverse Charge | +{{ inward_supply.is_reverse_charge || '-' }} | +{{ purchase.is_reverse_charge || '-' }} | +||
| CGST + | {{ inward_supply.cgst || '-' }} | +{{ purchase.cgst || '-' }} | +||
| SGST + | {{ inward_supply.sgst || '-' }} | +{{ purchase.sgst || '-' }} | +||
| IGST + | {{ inward_supply.igst || '-' }} | +{{ purchase.igst || '-' }} | +||
| CESS + | {{ inward_supply.cess || '-' }} | +{{ purchase.cess || '-' }} | +||
| Taxable Amount + | {{ inward_supply.taxable_value || '-' }} | +{{ purchase.taxable_value || '-' }} | +
![\"No](\"/assets/frappe/images/ui-states/list-empty-state.svg\"){kind=spacer}
\n\t{{ __(\"No data available for selected filters\") }}
" + }, + { + "fieldname": "column_break_12", + "fieldtype": "Column Break" + }, + { + "fieldname": "gst_return", + "fieldtype": "Select", + "label": "GST Return", + "options": "GSTR 2B\nBoth GSTR 2A & 2B" + }, + { + "depends_on": "eval: !doc.reconciliation_data", + "fieldname": "not_reconciled", + "fieldtype": "HTML", + "options": "\n\t{{ __(\"Reconcile to view the data\") }}
" + }, + { + "fieldname": "section_break_cmfa", + "fieldtype": "Section Break", + "hidden": 1 + }, + { + "fieldname": "reconciliation_data", + "fieldtype": "JSON", + "label": "Reconciliation Data" + }, + { + "default": "0", + "fieldname": "is_modified", + "fieldtype": "Check", + "hidden": 1, + "label": "Is Modified" + }, + { + "default": "0", + "fieldname": "include_ignored", + "fieldtype": "Check", + "label": "Include Ignored" + } + ], + "hide_toolbar": 1, + "index_web_pages_for_search": 1, + "issingle": 1, + "links": [], + "modified": "2023-09-14 12:57:00.756535", + "modified_by": "Administrator", + "module": "GST India", + "name": "Purchase Reconciliation Tool", + "owner": "Administrator", + "permissions": [ + { + "create": 1, + "email": 1, + "export": 1, + "print": 1, + "read": 1, + "role": "System Manager", + "share": 1, + "write": 1 + }, + { + "create": 1, + "email": 1, + "export": 1, + "print": 1, + "read": 1, + "role": "Accounts Manager", + "share": 1, + "write": 1 + }, + { + "create": 1, + "email": 1, + "export": 1, + "print": 1, + "read": 1, + "role": "Accounts User", + "write": 1 + } + ], + "sort_field": "modified", + "sort_order": "DESC", + "states": [] +} \ No newline at end of file diff --git a/india_compliance/gst_india/doctype/purchase_reconciliation_tool/purchase_reconciliation_tool.py b/india_compliance/gst_india/doctype/purchase_reconciliation_tool/purchase_reconciliation_tool.py new file mode 100644 index 000000000..d9562cd48 --- /dev/null +++ b/india_compliance/gst_india/doctype/purchase_reconciliation_tool/purchase_reconciliation_tool.py @@ -0,0 +1,1136 @@ +# Copyright (c) 2022, Resilient Tech and contributors +# For license information, please see license.txt + +import json +from typing import List + +import frappe +from frappe.model.document import Document +from frappe.query_builder.functions import IfNull +from frappe.utils.response import json_handler + +from india_compliance.gst_india.constants import ORIGINAL_VS_AMENDED +from india_compliance.gst_india.doctype.purchase_reconciliation_tool import ( + BaseUtil, + BillOfEntry, + PurchaseInvoice, + ReconciledData, + Reconciler, +) +from india_compliance.gst_india.utils import get_json_from_file, get_timespan_date_range +from india_compliance.gst_india.utils.exporter import ExcelExporter +from india_compliance.gst_india.utils.gstr import ( + IMPORT_CATEGORY, + GSTRCategory, + ReturnType, + download_gstr_2a, + download_gstr_2b, + save_gstr_2a, + save_gstr_2b, +) + + +class PurchaseReconciliationTool(Document): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.ReconciledData = ReconciledData(**self.get_reco_doc()) + + def get_reco_doc(self): + fields = ( + "company", + "company_gstin", + "gst_return", + "purchase_from_date", + "purchase_to_date", + "inward_supply_from_date", + "inward_supply_to_date", + "include_ignored", + ) + return {field: self.get(field) for field in fields} + + def validate(self): + # reconcile purchases and inward supplies + if frappe.flags.in_install or frappe.flags.in_migrate: + return + + _Reconciler = Reconciler(**self.get_reco_doc()) + for row in ORIGINAL_VS_AMENDED: + _Reconciler.reconcile(row["original"], row["amended"]) + + self.ReconciledData = ReconciledData(**self.get_reco_doc()) + self.reconciliation_data = json.dumps( + self.ReconciledData.get(), default=json_handler + ) + + self.db_set("is_modified", 0) + + @frappe.whitelist() + def upload_gstr(self, return_type, period, file_path): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + return_type = ReturnType(return_type) + json_data = get_json_from_file(file_path) + if return_type == ReturnType.GSTR2A: + return save_gstr_2a(self.company_gstin, period, json_data) + + if return_type == ReturnType.GSTR2B: + return save_gstr_2b(self.company_gstin, period, json_data) + + @frappe.whitelist() + def download_gstr_2a(self, date_range, force=False, otp=None): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + return_type = ReturnType.GSTR2A + periods = BaseUtil.get_periods(date_range, return_type) + if not force: + periods = self.get_periods_to_download(return_type, periods) + + return download_gstr_2a(self.company_gstin, periods, otp) + + @frappe.whitelist() + def download_gstr_2b(self, date_range, otp=None): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + return_type = ReturnType.GSTR2B + periods = self.get_periods_to_download( + return_type, BaseUtil.get_periods(date_range, return_type) + ) + return download_gstr_2b(self.company_gstin, periods, otp) + + def get_periods_to_download(self, return_type, periods): + existing_periods = get_import_history( + self.company_gstin, + return_type, + periods, + pluck="return_period", + ) + + return [period for period in periods if period not in existing_periods] + + @frappe.whitelist() + def get_import_history(self, return_type, date_range, for_download=True): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + if not return_type: + return + + return_type = ReturnType(return_type) + periods = BaseUtil.get_periods(date_range, return_type, True) + history = get_import_history(self.company_gstin, return_type, periods) + + columns = [ + "Period", + "Classification", + "Status", + f"{'Downloaded' if for_download else 'Uploaded'} On", + ] + + settings = frappe.get_cached_doc("GST Settings") + + data = {} + for period in periods: + # TODO: skip if today is not greater than 14th return period's next months + data[period] = [] + status = "🟢 Downloaded" + for category in GSTRCategory: + if category.value == "ISDA" and return_type == ReturnType.GSTR2A: + continue + + if ( + not settings.enable_overseas_transactions + and category.value in IMPORT_CATEGORY + ): + continue + + download = next( + ( + log + for log in history + if log.return_period == period + and log.classification in (category.value, "") + ), + None, + ) + + status = "🟠Not Downloaded" + if download: + status = "🟢 Downloaded" + if download.data_not_found: + status = "🔵 Data Not Found" + if download.request_id: + status = "🔵 Queued" + + if not for_download: + status = status.replace("Downloaded", "Uploaded") + + _dict = { + "Classification": category.value + if return_type is ReturnType.GSTR2A + else "ALL", + "Status": status, + columns[-1]: "✅ " + + download.last_updated_on.strftime("%d-%m-%Y %H:%M:%S") + if download + else "", + } + if _dict not in data[period]: + data[period].append(_dict) + + return {"columns": columns, "data": data} + + @frappe.whitelist() + def get_return_period_from_file(self, return_type, file_path): + """ + Permissions check not necessary as response is not sensitive + """ + if not file_path: + return + + return_type = ReturnType(return_type) + try: + json_data = get_json_from_file(file_path) + if return_type == ReturnType.GSTR2A: + return json_data.get("fp") + + if return_type == ReturnType.GSTR2B: + return json_data.get("data").get("rtnprd") + + except Exception: + pass + + @frappe.whitelist() + def get_date_range(self, period): + """ + Permissions check not necessary as response is not sensitive + """ + if not period or period == "Custom": + return + + return get_timespan_date_range(period.lower(), self.company) + + @frappe.whitelist() + def get_invoice_details(self, purchase_name, inward_supply_name): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + return self.ReconciledData.get_manually_matched_data( + purchase_name, inward_supply_name + ) + + @frappe.whitelist() + def link_documents(self, purchase_invoice_name, inward_supply_name, link_doctype): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + if not purchase_invoice_name or not inward_supply_name: + return + + purchases = [] + inward_supplies = [] + + # silently handle existing links + if isup_linked_with := frappe.db.get_value( + "GST Inward Supply", inward_supply_name, "link_name" + ): + self._unlink_documents((inward_supply_name,)) + purchases.append(isup_linked_with) + + link_doc = { + "link_doctype": link_doctype, + "link_name": purchase_invoice_name, + } + if pur_linked_with := frappe.db.get_all( + "GST Inward Supply", link_doc, pluck="name" + ): + self._unlink_documents((pur_linked_with)) + inward_supplies.append(pur_linked_with) + + link_doc["match_status"] = "Manual Match" + + # link documents + frappe.db.set_value( + "GST Inward Supply", + inward_supply_name, + link_doc, + ) + purchases.append(purchase_invoice_name) + inward_supplies.append(inward_supply_name) + + self.db_set("is_modified", 1) + + return self.ReconciledData.get(purchases, inward_supplies) + + @frappe.whitelist() + def unlink_documents(self, data): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + if isinstance(data, str): + data = frappe.parse_json(data) + + inward_supplies = set() + purchases = set() + boe = set() + + for doc in data: + inward_supplies.add(doc.get("inward_supply_name")) + + purchase_doctype = doc.get("purchase_doctype") + if purchase_doctype == "Purchase Invoice": + purchases.add(doc.get("purchase_invoice_name")) + + elif purchase_doctype == "Bill of Entry": + boe.add(doc.get("purchase_invoice_name")) + + self.set_reconciliation_status("Purchase Invoice", purchases, "Unreconciled") + self.set_reconciliation_status("Bill of Entry", boe, "Unreconciled") + self._unlink_documents(inward_supplies) + + self.db_set("is_modified", 1) + + return self.ReconciledData.get(purchases.union(boe), inward_supplies) + + def set_reconciliation_status(self, doctype, names, status): + if not names: + return + + frappe.db.set_value( + doctype, {"name": ("in", names)}, "reconciliation_status", status + ) + + def _unlink_documents(self, inward_supplies): + if not inward_supplies: + return + + GSTR2 = frappe.qb.DocType("GST Inward Supply") + ( + frappe.qb.update(GSTR2) + .set("link_doctype", "") + .set("link_name", "") + .set("match_status", "Unlinked") + .where(GSTR2.name.isin(inward_supplies)) + .run() + ) + + # Revert action performed + ( + frappe.qb.update(GSTR2) + .set("action", "No Action") + .where(GSTR2.name.isin(inward_supplies)) + .where(GSTR2.action.notin(("Ignore", "Pending"))) + .run() + ) + + @frappe.whitelist() + def apply_action(self, data, action): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + if isinstance(data, str): + data = frappe.parse_json(data) + + STATUS_MAP = { + "Accept My Values": "Reconciled", + "Accept Supplier Values": "Reconciled", + "Pending": "Unreconciled", + "Ignore": "Ignored", + } + + status = STATUS_MAP.get(action) + + inward_supplies = [] + purchases = [] + boe = [] + + for doc in data: + if action == "Ignore" and "Missing" not in doc.get("match_status"): + continue + + elif "Accept" in action and "Missing" in doc.get("match_status"): + continue + + if inward_supply_name := doc.get("inward_supply_name"): + inward_supplies.append(inward_supply_name) + + purchase_doctype = doc.get("purchase_doctype") + if purchase_doctype == "Purchase Invoice": + purchases.append(doc.get("purchase_invoice_name")) + + elif purchase_doctype == "Bill of Entry": + boe.append(doc.get("purchase_invoice_name")) + + if inward_supplies: + frappe.db.set_value( + "GST Inward Supply", {"name": ("in", inward_supplies)}, "action", action + ) + + self.set_reconciliation_status("Purchase Invoice", purchases, status) + self.set_reconciliation_status("Bill of Entry", boe, status) + + self.db_set("is_modified", 1) + + @frappe.whitelist() + def get_link_options(self, doctype, filters): + frappe.has_permission("Purchase Reconciliation Tool", "write", throw=True) + + if isinstance(filters, dict): + filters = frappe._dict(filters) + + if doctype == "Purchase Invoice": + return self.get_purchase_invoice_options(filters) + + elif doctype == "GST Inward Supply": + return self.get_inward_supply_options(filters) + + elif doctype == "Bill of Entry": + return self.get_bill_of_entry_options(filters) + + def get_purchase_invoice_options(self, filters): + PI = frappe.qb.DocType("Purchase Invoice") + query = ( + self.ReconciledData.query_purchase_invoice(["gst_category", "is_return"]) + .where(PI.supplier_gstin.like(f"%{filters.supplier_gstin}%")) + .where(PI.bill_date[filters.bill_from_date : filters.bill_to_date]) + ) + + if not filters.show_matched: + query = query.where( + PI.name.notin(PurchaseInvoice.query_matched_purchase_invoice()) + ) + + return self._get_link_options(query.run(as_dict=True)) + + def get_inward_supply_options(self, filters): + GSTR2 = frappe.qb.DocType("GST Inward Supply") + query = ( + self.ReconciledData.query_inward_supply(["classification"]) + .where(GSTR2.supplier_gstin.like(f"%{filters.supplier_gstin}%")) + .where(GSTR2.bill_date[filters.bill_from_date : filters.bill_to_date]) + ) + + if filters.get("purchase_doctype") == "Purchase Invoice": + query = query.where(GSTR2.classification.notin(IMPORT_CATEGORY)) + elif filters.get("purchase_doctype") == "Bill of Entry": + query = query.where(GSTR2.classification.isin(IMPORT_CATEGORY)) + + if not filters.show_matched: + query = query.where(IfNull(GSTR2.link_name, "") == "") + + return self._get_link_options(query.run(as_dict=True)) + + def get_bill_of_entry_options(self, filters): + BOE = frappe.qb.DocType("Bill of Entry") + query = self.ReconciledData.query_bill_of_entry().where( + BOE.bill_of_entry_date[filters.bill_from_date : filters.bill_to_date] + ) + + if not filters.show_matched: + query = query.where( + BOE.name.notin(BillOfEntry.query_matched_bill_of_entry()) + ) + + return self._get_link_options(query.run(as_dict=True)) + + def _get_link_options(self, data): + for row in data: + row.value = row.label = row.name + if not row.get("classification"): + row.classification = self.ReconciledData.guess_classification(row) + + row.description = ( + f"{row.bill_no}, {row.bill_date}, Taxable Amount: {row.taxable_value}" + ) + row.description += ( + f", Tax Amount: {BaseUtil.get_total_tax(row)}, {row.classification}" + ) + + return data + + +def get_import_history( + company_gstin, return_type: ReturnType, periods: List[str], fields=None, pluck=None +): + if not (fields or pluck): + fields = ( + "return_period", + "classification", + "data_not_found", + "last_updated_on", + "request_id", + ) + + return frappe.db.get_all( + "GSTR Import Log", + filters={ + "gstin": company_gstin, + "return_type": return_type.value, + "return_period": ("in", periods), + }, + fields=fields, + pluck=pluck, + ) + + +@frappe.whitelist() +def generate_excel_attachment(data, doc): + frappe.has_permission("Purchase Reconciliation Tool", "email", throw=True) + + build_data = BuildExcel(doc, data, is_supplier_specific=True, email=True) + + xlsx_file, filename = build_data.export_data() + xlsx_data = xlsx_file.getvalue() + + # Upload attachment for email xlsx data using communication make() method + folder = frappe.form_dict.folder or "Home" + file_url = frappe.form_dict.file_url or "" + + file = frappe.get_doc( + { + "doctype": "File", + "attached_to_doctype": "Purchase Reconciliation Tool", + "attached_to_name": "Purchase Reconciliation Tool", + "folder": folder, + "file_name": f"{filename}.xlsx", + "file_url": file_url, + "is_private": 0, + "content": xlsx_data, + } + ) + file.save(ignore_permissions=True) + return [file] + + +@frappe.whitelist() +def download_excel_report(data, doc, is_supplier_specific=False): + frappe.has_permission("Purchase Reconciliation Tool", "export", throw=True) + + build_data = BuildExcel(doc, data, is_supplier_specific) + build_data.export_data() + + +def parse_params(fun): + def wrapper(*args, **kwargs): + args = [frappe.parse_json(arg) for arg in args] + kwargs = {k: frappe.parse_json(v) for k, v in kwargs.items()} + return fun(*args, **kwargs) + + return wrapper + + +class BuildExcel: + COLOR_PALLATE = frappe._dict( + { + "dark_gray": "d9d9d9", + "light_gray": "f2f2f2", + "dark_pink": "e6b9b8", + "light_pink": "f2dcdb", + "sky_blue": "c6d9f1", + "light_blue": "dce6f2", + "green": "d7e4bd", + "light_green": "ebf1de", + } + ) + + @parse_params + def __init__(self, doc, data, is_supplier_specific=False, email=False): + """ + :param doc: purchase reconciliation tool doc + :param data: data to be exported + :param is_supplier_specific: if true, data will be downloded for specific supplier + :param email: send the file as email + """ + self.doc = doc + self.data = data + self.is_supplier_specific = is_supplier_specific + self.email = email + self.set_headers() + self.set_filters() + + def export_data(self): + """Exports data to an excel file""" + excel = ExcelExporter() + excel.create_sheet( + sheet_name="Match Summary Data", + filters=self.filters, + headers=self.match_summary_header, + data=self.get_match_summary_data(), + ) + + if not self.is_supplier_specific: + excel.create_sheet( + sheet_name="Supplier Data", + filters=self.filters, + headers=self.supplier_header, + data=self.get_supplier_data(), + ) + + excel.create_sheet( + sheet_name="Invoice Data", + filters=self.filters, + merged_headers=self.get_merge_headers(), + headers=self.invoice_header, + data=self.get_invoice_data(), + ) + + excel.remove_sheet("Sheet") + + file_name = self.get_file_name() + if self.email: + xlsx_data = excel.save_workbook() + return [xlsx_data, file_name] + + excel.export(file_name) + + def set_headers(self): + """Sets headers for the excel file""" + + self.match_summary_header = self.get_match_summary_columns() + self.supplier_header = self.get_supplier_columns() + self.invoice_header = self.get_invoice_columns() + + def set_filters(self): + """Add filters to the sheet""" + + label = "2B" if self.doc.gst_return == "GSTR 2B" else "2A/2B" + self.period = ( + f"{self.doc.inward_supply_from_date} to {self.doc.inward_supply_to_date}" + ) + + self.filters = frappe._dict( + { + "Company Name": self.doc.company, + "GSTIN": self.doc.company_gstin, + f"Return Period ({label})": self.period, + } + ) + + def get_merge_headers(self): + """Returns merged_headers for the excel file""" + return frappe._dict( + { + "2A / 2B": ["inward_supply_bill_no", "inward_supply_cess"], + "Purchase Data": ["bill_no", "cess"], + } + ) + + def get_match_summary_data(self): + return self.process_data( + self.data.get("match_summary"), + self.match_summary_header, + ) + + def get_supplier_data(self): + return self.process_data( + self.data.get("supplier_summary"), self.supplier_header + ) + + def get_invoice_data(self): + data = ReconciledData(**self.doc).get_consolidated_data( + self.data.get("purchases"), + self.data.get("inward_supplies"), + prefix="inward_supply", + ) + + # TODO: Sanitize supplier name and gstin + self.supplier_name = data[0].get("supplier_name") + self.supplier_gstin = data[0].get("supplier_gstin") + + return self.process_data(data, self.invoice_header) + + def process_data(self, data, column_list): + """return required list of dict for the excel file""" + if not data: + return + + out = [] + fields = [d.get("fieldname") for d in column_list] + purchase_fields = [field.get("fieldname") for field in self.pr_columns] + for row in data: + new_row = {} + for field in fields: + if field not in row: + row[field] = None + + # pur data in row (for invoice_summary) is polluted for Missing in PI + if field in purchase_fields and not row.get("name"): + row[field] = None + + self.assign_value(field, row, new_row) + + out.append(new_row) + + return out + + def assign_value(self, field, source_data, target_data): + if source_data.get(field) is None: + target_data[field] = None + return + + if "is_reverse_charge" in field: + target_data[field] = "Yes" if source_data.get(field) else "No" + return + + target_data[field] = source_data.get(field) + + def get_file_name(self): + """Returns file name for the excel file""" + if not self.is_supplier_specific: + return f"{self.doc.company_gstin}_{self.period}_report" + + file_name = f"{self.supplier_name}_{self.supplier_gstin}" + return file_name.replace(" ", "_") + + def get_match_summary_columns(self): + """ + Defaults: + - bg_color: self.COLOR_PALLATE.dark_gray + - bg_color_data": self.COLOR_PALLATE.light_gray + - bold: 1 + - align_header: "center" + - align_data: "general" + - width: 20 + """ + return [ + { + "label": "Match Status", + "fieldname": "match_status", + "data_format": {"horizontal": "left"}, + "header_format": {"horizontal": "center"}, + }, + { + "label": "Count \n 2A/2B Docs", + "fieldname": "inward_supply_count", + "fieldtype": "Int", + "data_format": {"number_format": "#,##0"}, + }, + { + "label": "Count \n Purchase Docs", + "fieldname": "purchase_count", + "fieldtype": "Int", + "data_format": {"number_format": "#,##0"}, + }, + { + "label": "Taxable Amount Diff \n 2A/2B - Purchase", + "fieldname": "taxable_value_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + }, + }, + { + "label": "Tax Difference \n 2A/2B - Purchase", + "fieldname": "tax_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + }, + }, + { + "label": "%Action Taken", + "fieldname": "action_taken_count", + "data_format": {"number_format": "0.00%"}, + "width": 12, + }, + ] + + def get_supplier_columns(self): + return [ + { + "label": "Supplier Name", + "fieldname": "supplier_name", + "data_format": {"horizontal": "left"}, + }, + { + "label": "Supplier GSTIN", + "fieldname": "supplier_gstin", + "data_format": {"horizontal": "left"}, + }, + { + "label": "Count \n 2A/2B Docs", + "fieldname": "inward_supply_count", + "fieldtype": "Int", + "data_format": {"number_format": "#,##0"}, + }, + { + "label": "Count \n Purchase Docs", + "fieldname": "purchase_count", + "fieldtype": "Int", + "data_format": { + "number_format": "#,##0", + }, + }, + { + "label": "Taxable Amount Diff \n 2A/2B - Purchase", + "fieldname": "taxable_value_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + }, + }, + { + "label": "Tax Difference \n 2A/2B - Purchase", + "fieldname": "tax_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + }, + }, + { + "label": "%Action Taken", + "fieldname": "action_taken_count", + "data_format": {"number_format": "0.00%"}, + "header_format": { + "width": 12, + }, + }, + ] + + def get_invoice_columns(self): + self.pr_columns = [ + { + "label": "Bill No", + "fieldname": "bill_no", + "compare_with": "inward_supply_bill_no", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_green, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "Bill Date", + "fieldname": "bill_date", + "compare_with": "inward_supply_bill_date", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_green, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "GSTIN", + "fieldname": "supplier_gstin", + "compare_with": "inward_supply_supplier_gstin", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_green, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 15, + }, + }, + { + "label": "Place of Supply", + "fieldname": "place_of_supply", + "compare_with": "inward_supply_place_of_supply", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_green, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "Reverse Charge", + "fieldname": "is_reverse_charge", + "compare_with": "inward_supply_is_reverse_charge", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_green, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "Taxable Value", + "fieldname": "taxable_value", + "compare_with": "inward_supply_taxable_value", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_green, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "CGST", + "fieldname": "cgst", + "compare_with": "inward_supply_cgst", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_green, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "SGST", + "fieldname": "sgst", + "compare_with": "inward_supply_sgst", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_green, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "IGST", + "fieldname": "igst", + "compare_with": "inward_supply_igst", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_green, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + { + "label": "CESS", + "fieldname": "cess", + "compare_with": "inward_supply_cess", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_green, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.green, + "width": 12, + }, + }, + ] + self.inward_supply_columns = [ + { + "label": "Bill No", + "fieldname": "inward_supply_bill_no", + "compare_with": "bill_no", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "Bill Date", + "fieldname": "inward_supply_bill_date", + "compare_with": "bill_date", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "GSTIN", + "fieldname": "inward_supply_supplier_gstin", + "compare_with": "supplier_gstin", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 15, + }, + }, + { + "label": "Place of Supply", + "fieldname": "inward_supply_place_of_supply", + "compare_with": "place_of_supply", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "Reverse Charge", + "fieldname": "inward_supply_is_reverse_charge", + "compare_with": "is_reverse_charge", + "data_format": { + "horizontal": "left", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "Taxable Value", + "fieldname": "inward_supply_taxable_value", + "compare_with": "taxable_value", + "fieldtype": "Float", + "data_format": { + "number_format": "0.00", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "CGST", + "fieldname": "inward_supply_cgst", + "compare_with": "cgst", + "fieldtype": "Float", + "data_format": { + "number_format": "0.00", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "SGST", + "fieldname": "inward_supply_sgst", + "compare_with": "sgst", + "fieldtype": "Float", + "data_format": { + "number_format": "0.00", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "IGST", + "fieldname": "inward_supply_igst", + "compare_with": "igst", + "fieldtype": "Float", + "data_format": { + "number_format": "0.00", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + { + "label": "CESS", + "fieldname": "inward_supply_cess", + "compare_with": "cess", + "fieldtype": "Float", + "data_format": { + "number_format": "0.00", + "bg_color": self.COLOR_PALLATE.light_blue, + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.sky_blue, + "width": 12, + }, + }, + ] + inv_columns = [ + { + "label": "Action Status", + "fieldname": "action", + "data_format": {"horizontal": "left"}, + }, + { + "label": "Match Status", + "fieldname": "match_status", + "data_format": {"horizontal": "left"}, + }, + { + "label": "Supplier Name", + "fieldname": "supplier_name", + "data_format": {"horizontal": "left"}, + }, + { + "label": "PAN", + "fieldname": "pan", + "data_format": {"horizontal": "center"}, + "header_format": { + "width": 15, + }, + }, + { + "label": "Classification", + "fieldname": "classification", + "data_format": {"horizontal": "left"}, + "header_format": { + "width": 11, + }, + }, + { + "label": "Taxable Value Difference", + "fieldname": "taxable_value_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + "width": 12, + }, + }, + { + "label": "Tax Difference", + "fieldname": "tax_difference", + "fieldtype": "Float", + "data_format": { + "bg_color": self.COLOR_PALLATE.light_pink, + "number_format": "0.00", + }, + "header_format": { + "bg_color": self.COLOR_PALLATE.dark_pink, + "width": 12, + }, + }, + ] + inv_columns.extend(self.inward_supply_columns) + inv_columns.extend(self.pr_columns) + return inv_columns diff --git a/india_compliance/gst_india/doctype/purchase_reconciliation_tool/test_purchase_reconciliation_tool.py b/india_compliance/gst_india/doctype/purchase_reconciliation_tool/test_purchase_reconciliation_tool.py new file mode 100644 index 000000000..a9a7a7d98 --- /dev/null +++ b/india_compliance/gst_india/doctype/purchase_reconciliation_tool/test_purchase_reconciliation_tool.py @@ -0,0 +1,9 @@ +# Copyright (c) 2022, Resilient Tech and Contributors +# See license.txt + +# import frappe +from frappe.tests.utils import FrappeTestCase + + +class TestPurchaseReconciliationTool(FrappeTestCase): + pass diff --git a/india_compliance/gst_india/number_card/number_card.py b/india_compliance/gst_india/number_card/number_card.py index 40d9c4520..70e848b6f 100644 --- a/india_compliance/gst_india/number_card/number_card.py +++ b/india_compliance/gst_india/number_card/number_card.py @@ -23,7 +23,7 @@ def get_active_e_invoice_count_for_cancelled_invoices(filters=None): return 0 default_filters = get_default_filters(filters) - default_filters["exceptions"] = "Invoice Cancelled but e-Invoice Active" + default_filters["exceptions"] = "Invoice Cancelled but not e-Invoice" return get_e_invoice_summary_count(default_filters) diff --git a/india_compliance/gst_india/overrides/gl_entry.py b/india_compliance/gst_india/overrides/gl_entry.py index bfcf3650b..c6a0d5a03 100644 --- a/india_compliance/gst_india/overrides/gl_entry.py +++ b/india_compliance/gst_india/overrides/gl_entry.py @@ -16,7 +16,10 @@ def validate(doc, method=None): return frappe.throw( - _("Company GSTIN is a mandatory field for accounting of GST Accounts.") + _( + "Company GSTIN is a mandatory field for accounting of GST Accounts." + " Run `Update GSTIN` patch from GST Balance Report to update GSTIN in all transactions." + ) ) diff --git a/india_compliance/gst_india/overrides/payment_entry.py b/india_compliance/gst_india/overrides/payment_entry.py index 7f50cb8c1..220924167 100644 --- a/india_compliance/gst_india/overrides/payment_entry.py +++ b/india_compliance/gst_india/overrides/payment_entry.py @@ -1,8 +1,63 @@ import frappe -from frappe.utils import cstr +from frappe import _ +from frappe.contacts.doctype.address.address import get_default_address +from frappe.query_builder.functions import Sum +from frappe.utils import cstr, flt, getdate +from erpnext.accounts.general_ledger import make_gl_entries +from erpnext.accounts.utils import create_payment_ledger_entry +from erpnext.controllers.accounts_controller import get_advance_payment_entries +from india_compliance.gst_india.overrides.transaction import get_gst_details +from india_compliance.gst_india.overrides.transaction import ( + validate_transaction as validate_transaction_for_advance_payment, +) +from india_compliance.gst_india.utils import get_all_gst_accounts -def update_place_of_supply(doc, method): + +def validate(doc, method=None): + if not doc.taxes: + return + + if doc.party_type == "Customer": + # Presume is export with GST if GST accounts are present + doc.is_export_with_gst = 1 + validate_transaction_for_advance_payment(doc, method) + + else: + gst_accounts = get_all_gst_accounts(doc.company) + for row in doc.taxes: + if row.account_head in gst_accounts and row.tax_amount != 0: + frappe.throw( + _("GST Taxes are not allowed for Supplier Advance Payment Entry") + ) + + +def on_submit(doc, method=None): + make_gst_revesal_entry_from_advance_payment(doc) + + +def on_update_after_submit(doc, method=None): + make_gst_revesal_entry_from_advance_payment(doc) + + +@frappe.whitelist() +def update_party_details(party_details, doctype, company): + if isinstance(party_details, str): + party_details = frappe.parse_json(party_details) + + address = get_default_address("Customer", party_details.get("customer")) + party_details.update(customer_address=address) + + # Update address for update + response = { + "customer_address": address, # should be set first as gst_category and gstin is fetched from address + **get_gst_details(party_details, doctype, company, update_place_of_supply=True), + } + + return response + + +def update_place_of_supply(doc): country = frappe.get_cached_value("Company", doc.company, "country") if country != "India": return @@ -17,3 +72,246 @@ def update_place_of_supply(doc, method): doc.place_of_supply = ( cstr(address.gst_state_number) + "-" + cstr(address.gst_state) ) + + +def make_gst_revesal_entry_from_advance_payment(doc): + """ + This functionality aims to create a GST reversal entry where GST was paid in advance + + On Submit: Creates GLEs and PLEs for all references. + On Update after Submit: Creates GLEs for new references. Creates PLEs for all references. + """ + gl_dict = [] + + if not doc.taxes: + return + + for row in doc.get("references"): + gl_dict.extend(get_gl_for_advance_gst_reversal(doc, row)) + + if not gl_dict: + return + + # Creates GLEs and PLEs + make_gl_entries(gl_dict) + + +def get_gl_for_advance_gst_reversal(payment_entry, reference_row): + gl_dicts = [] + voucher_date = frappe.db.get_value( + reference_row.reference_doctype, reference_row.reference_name, "posting_date" + ) + posting_date = ( + payment_entry.posting_date + if getdate(payment_entry.posting_date) > getdate(voucher_date) + else voucher_date + ) + + taxes = get_proportionate_taxes_for_reversal(payment_entry, reference_row) + + if not taxes: + return gl_dicts + + total_amount = sum(taxes.values()) + + args = { + "posting_date": posting_date, + "voucher_detail_no": reference_row.name, + "remarks": f"Reversal for GST on Advance Payment Entry" + f" {payment_entry.name} against {reference_row.reference_doctype} {reference_row.reference_name}", + } + + # Reduce receivables + gl_entry = payment_entry.get_gl_dict( + { + "account": reference_row.account, + "credit": total_amount, + "credit_in_account_currency": total_amount, + "party_type": payment_entry.party_type, + "party": payment_entry.party, + "against_voucher_type": reference_row.reference_doctype, + "against_voucher": reference_row.reference_name, + **args, + }, + item=reference_row, + ) + + if frappe.db.exists("GL Entry", args): + # All existing PLE are delinked and new ones are created everytime on update + # refer: reconcile_against_document in utils.py + create_payment_ledger_entry( + [gl_entry], update_outstanding="No", cancel=0, adv_adj=1 + ) + + return gl_dicts + + gl_dicts.append(gl_entry) + + # Reverse taxes + for account, amount in taxes.items(): + gl_dicts.append( + payment_entry.get_gl_dict( + { + "account": account, + "debit": amount, + "debit_in_account_currency": amount, + "against_voucher_type": payment_entry.doctype, + "against_voucher": payment_entry.name, + **args, + }, + item=reference_row, + ) + ) + + return gl_dicts + + +def get_proportionate_taxes_for_reversal(payment_entry, reference_row): + """ + This function calculates proportionate taxes for reversal of GST paid in advance + """ + # Compile taxes + gst_accounts = get_all_gst_accounts(payment_entry.company) + taxes = {} + for row in payment_entry.taxes: + if row.account_head not in gst_accounts: + continue + + taxes.setdefault(row.account_head, 0) + taxes[row.account_head] += row.base_tax_amount + + if not taxes: + return + + # Ensure there is no rounding error + if ( + not payment_entry.unallocated_amount + and payment_entry.references[-1].idx == reference_row.idx + ): + return balance_taxes(payment_entry, reference_row, taxes) + + return get_proportionate_taxes_for_row(payment_entry, reference_row, taxes) + + +def get_proportionate_taxes_for_row(payment_entry, reference_row, taxes): + base_allocated_amount = payment_entry.calculate_base_allocated_amount_for_reference( + reference_row + ) + for account, amount in taxes.items(): + taxes[account] = flt( + amount * base_allocated_amount / payment_entry.base_paid_amount, 2 + ) + + return taxes + + +def balance_taxes(payment_entry, reference_row, taxes): + for account, amount in taxes.items(): + for allocation_row in payment_entry.references: + if allocation_row.reference_name == reference_row.reference_name: + continue + + taxes[account] = taxes[account] - flt( + amount + * payment_entry.calculate_base_allocated_amount_for_reference( + allocation_row + ) + / payment_entry.base_paid_amount, + 2, + ) + + return taxes + + +def get_advance_payment_entries_for_regional( + party_type, + party, + party_account, + order_doctype, + order_list=None, + include_unallocated=True, + against_all_orders=False, + limit=None, + condition=None, +): + """ + Get Advance Payment Entries with GST Taxes + """ + + payment_entries = get_advance_payment_entries( + party_type=party_type, + party=party, + party_account=party_account, + order_doctype=order_doctype, + order_list=order_list, + include_unallocated=include_unallocated, + against_all_orders=against_all_orders, + limit=limit, + condition=condition, + ) + + # if not Sales Invoice and is Payment Reconciliation + if not condition or not payment_entries: + return payment_entries + + company = frappe.db.get_value("Account", party_account, "company") + taxes = get_taxes_summary(company, payment_entries) + + for pe in payment_entries: + tax_row = taxes.get( + pe.reference_name, + frappe._dict(paid_amount=1, tax_amount=0, tax_amount_reversed=0), + ) + pe.amount += tax_row.tax_amount - tax_row.tax_amount_reversed + + return payment_entries + + +def adjust_allocations_for_taxes_in_payment_reconciliation(doc): + if not doc.allocation: + return + + taxes = get_taxes_summary(doc.company, doc.allocation) + taxes = { + tax.payment_entry: tax.paid_amount / (tax.paid_amount + tax.tax_amount) + for tax in taxes.values() + } + + for row in doc.allocation: + paid_proportion = taxes.get(row.reference_name, 1) + for field in ("amount", "allocated_amount", "unreconciled_amount"): + row.set(field, flt(row.get(field, 0) * paid_proportion, 2)) + + +def get_taxes_summary(company, payment_entries): + gst_accounts = get_all_gst_accounts(company) + references = [ + advance.reference_name + for advance in payment_entries + if advance.reference_type == "Payment Entry" + ] + + gl_entry = frappe.qb.DocType("GL Entry") + pe = frappe.qb.DocType("Payment Entry") + taxes = ( + frappe.qb.from_(gl_entry) + .join(pe) + .on(pe.name == gl_entry.voucher_no) + .select( + Sum(gl_entry.credit_in_account_currency).as_("tax_amount"), + Sum(gl_entry.debit_in_account_currency).as_("tax_amount_reversed"), + pe.name.as_("payment_entry"), + pe.paid_amount, + ) + .where(gl_entry.is_cancelled == 0) + .where(gl_entry.voucher_type == "Payment Entry") + .where(gl_entry.voucher_no.isin(references)) + .where(gl_entry.account.isin(gst_accounts)) + .where(gl_entry.company == company) + .groupby(gl_entry.voucher_no) + .run(as_dict=True) + ) + + taxes = {tax.payment_entry: tax for tax in taxes} + + return taxes diff --git a/india_compliance/gst_india/overrides/purchase_invoice.py b/india_compliance/gst_india/overrides/purchase_invoice.py index 069679fc4..a2aa5f3c6 100644 --- a/india_compliance/gst_india/overrides/purchase_invoice.py +++ b/india_compliance/gst_india/overrides/purchase_invoice.py @@ -45,9 +45,34 @@ def validate(doc, method=None): update_itc_totals(doc) validate_supplier_invoice_number(doc) + validate_with_inward_supply(doc) + set_reconciliation_status(doc) + + +def set_reconciliation_status(doc): + reconciliation_status = "Not Applicable" + + if is_b2b_invoice(doc): + reconciliation_status = "Unreconciled" + + doc.reconciliation_status = reconciliation_status + + +def is_b2b_invoice(doc): + return not ( + doc.supplier_gstin in ["", None] + or doc.gst_category in ["Registered Composition", "Unregistered", "Overseas"] + or doc.supplier_gstin == doc.company_gstin + or doc.is_opening == "Yes" + or any(row for row in doc.items if row.is_non_gst == 1) + ) def update_itc_totals(doc, method=None): + # Set default value + if not doc.eligibility_for_itc: + doc.eligibility_for_itc = "All Other ITC" + # Initialize values doc.itc_integrated_tax = 0 doc.itc_state_tax = 0 @@ -99,7 +124,79 @@ def get_dashboard_data(data): reference_section["items"].append("Bill of Entry") update_dashboard_with_gst_logs( - "Purchase Invoice", data, "e-Waybill Log", "Integration Request" + "Purchase Invoice", + data, + "e-Waybill Log", + "Integration Request", + "GST Inward Supply", ) return data + + +def validate_with_inward_supply(doc): + if not doc.get("_inward_supply"): + return + + mismatch_fields = {} + for field in [ + "company", + "company_gstin", + "supplier_gstin", + "bill_no", + "bill_date", + "is_reverse_charge", + "place_of_supply", + ]: + if doc.get(field) != doc._inward_supply.get(field): + mismatch_fields[field] = doc._inward_supply.get(field) + + # mismatch for taxable_value + taxable_value = sum([item.taxable_value for item in doc.items]) + if taxable_value != doc._inward_supply.get("taxable_value"): + mismatch_fields["Taxable Value"] = doc._inward_supply.get("taxable_value") + + # mismatch for taxes + gst_accounts = get_gst_accounts_by_type(doc.company, "Input") + for tax in ["cgst", "sgst", "igst", "cess"]: + tax_amount = get_tax_amount(doc.taxes, gst_accounts[tax + "_account"]) + if tax == "cess": + tax_amount += get_tax_amount(doc.taxes, gst_accounts.cess_non_advol_account) + + if tax_amount == doc._inward_supply.get(tax): + continue + + mismatch_fields[tax.upper()] = doc._inward_supply.get(tax) + + if mismatch_fields: + message = ( + "Purchase Invoice does not match with releted GST Inward Supply.