908 lines
33 KiB
Python
908 lines
33 KiB
Python
from __future__ import unicode_literals
|
|
|
|
import json
|
|
import re
|
|
|
|
import frappe
|
|
from frappe import _
|
|
from frappe.model.utils import get_fetch_values
|
|
from frappe.utils import cint, cstr, date_diff, flt, getdate, nowdate
|
|
from six import string_types
|
|
|
|
from erpnext.controllers.accounts_controller import get_taxes_and_charges
|
|
from erpnext.controllers.taxes_and_totals import get_itemised_tax, get_itemised_taxable_amount
|
|
from erpnext.hr.utils import get_salary_assignment
|
|
from erpnext.payroll.doctype.salary_structure.salary_structure import make_salary_slip
|
|
from erpnext.regional.india import number_state_mapping, state_numbers, states
|
|
|
|
GST_INVOICE_NUMBER_FORMAT = re.compile(r"^[a-zA-Z0-9\-/]+$") #alphanumeric and - /
|
|
GSTIN_FORMAT = re.compile("^[0-9]{2}[A-Z]{4}[0-9A-Z]{1}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}[1-9A-Z]{1}[0-9A-Z]{1}$")
|
|
GSTIN_UIN_FORMAT = re.compile("^[0-9]{4}[A-Z]{3}[0-9]{5}[0-9A-Z]{3}")
|
|
PAN_NUMBER_FORMAT = re.compile("[A-Z]{5}[0-9]{4}[A-Z]{1}")
|
|
|
|
|
|
def validate_gstin_for_india(doc, method):
|
|
if hasattr(doc, 'gst_state') and doc.gst_state:
|
|
doc.gst_state_number = state_numbers[doc.gst_state]
|
|
if not hasattr(doc, 'gstin') or not doc.gstin:
|
|
return
|
|
|
|
gst_category = []
|
|
|
|
if hasattr(doc, 'gst_category'):
|
|
if len(doc.links):
|
|
link_doctype = doc.links[0].get("link_doctype")
|
|
link_name = doc.links[0].get("link_name")
|
|
|
|
if link_doctype in ["Customer", "Supplier"]:
|
|
gst_category = frappe.db.get_value(link_doctype, {'name': link_name}, ['gst_category'])
|
|
|
|
doc.gstin = doc.gstin.upper().strip()
|
|
if not doc.gstin or doc.gstin == 'NA':
|
|
return
|
|
|
|
if len(doc.gstin) != 15:
|
|
frappe.throw(_("A GSTIN must have 15 characters."), title=_("Invalid GSTIN"))
|
|
|
|
if gst_category and gst_category == 'UIN Holders':
|
|
if not GSTIN_UIN_FORMAT.match(doc.gstin):
|
|
frappe.throw(_("The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers"),
|
|
title=_("Invalid GSTIN"))
|
|
else:
|
|
if not GSTIN_FORMAT.match(doc.gstin):
|
|
frappe.throw(_("The input you've entered doesn't match the format of GSTIN."), title=_("Invalid GSTIN"))
|
|
|
|
validate_gstin_check_digit(doc.gstin)
|
|
set_gst_state_and_state_number(doc)
|
|
|
|
if not doc.gst_state:
|
|
frappe.throw(_("Please enter GST state"), title=_("Invalid State"))
|
|
|
|
if doc.gst_state_number != doc.gstin[:2]:
|
|
frappe.throw(_("First 2 digits of GSTIN should match with State number {0}.")
|
|
.format(doc.gst_state_number), title=_("Invalid GSTIN"))
|
|
|
|
def validate_pan_for_india(doc, method):
|
|
if doc.get('country') != 'India' or not doc.get('pan'):
|
|
return
|
|
|
|
if not PAN_NUMBER_FORMAT.match(doc.pan):
|
|
frappe.throw(_("Invalid PAN No. The input you've entered doesn't match the format of PAN."))
|
|
|
|
def validate_tax_category(doc, method):
|
|
if doc.get('gst_state') and frappe.db.get_value('Tax Category', {'gst_state': doc.gst_state, 'is_inter_state': doc.is_inter_state}):
|
|
if doc.is_inter_state:
|
|
frappe.throw(_("Inter State tax category for GST State {0} already exists").format(doc.gst_state))
|
|
else:
|
|
frappe.throw(_("Intra State tax category for GST State {0} already exists").format(doc.gst_state))
|
|
|
|
def update_gst_category(doc, method):
|
|
if hasattr(doc, 'gst_category'):
|
|
for link in doc.links:
|
|
if link.link_doctype in ['Customer', 'Supplier']:
|
|
if doc.get('gstin'):
|
|
frappe.db.set_value(link.link_doctype, {'name': link.link_name, 'gst_category': 'Unregistered'}, 'gst_category', 'Registered Regular')
|
|
|
|
def set_gst_state_and_state_number(doc):
|
|
if not doc.gst_state:
|
|
if not doc.state:
|
|
return
|
|
state = doc.state.lower()
|
|
states_lowercase = {s.lower():s for s in states}
|
|
if state in states_lowercase:
|
|
doc.gst_state = states_lowercase[state]
|
|
else:
|
|
return
|
|
|
|
doc.gst_state_number = state_numbers[doc.gst_state]
|
|
|
|
def validate_gstin_check_digit(gstin, label='GSTIN'):
|
|
''' Function to validate the check digit of the GSTIN.'''
|
|
factor = 1
|
|
total = 0
|
|
code_point_chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
|
mod = len(code_point_chars)
|
|
input_chars = gstin[:-1]
|
|
for char in input_chars:
|
|
digit = factor * code_point_chars.find(char)
|
|
digit = (digit // mod) + (digit % mod)
|
|
total += digit
|
|
factor = 2 if factor == 1 else 1
|
|
if gstin[-1] != code_point_chars[((mod - (total % mod)) % mod)]:
|
|
frappe.throw(_("""Invalid {0}! The check digit validation has failed. Please ensure you've typed the {0} correctly.""").format(label))
|
|
|
|
def get_itemised_tax_breakup_header(item_doctype, tax_accounts):
|
|
hsn_wise_in_gst_settings = frappe.db.get_single_value('GST Settings','hsn_wise_tax_breakup')
|
|
if frappe.get_meta(item_doctype).has_field('gst_hsn_code') and hsn_wise_in_gst_settings:
|
|
return [_("HSN/SAC"), _("Taxable Amount")] + tax_accounts
|
|
else:
|
|
return [_("Item"), _("Taxable Amount")] + tax_accounts
|
|
|
|
def get_itemised_tax_breakup_data(doc, account_wise=False, hsn_wise=False):
|
|
itemised_tax = get_itemised_tax(doc.taxes, with_tax_account=account_wise)
|
|
|
|
itemised_taxable_amount = get_itemised_taxable_amount(doc.items)
|
|
|
|
if not frappe.get_meta(doc.doctype + " Item").has_field('gst_hsn_code'):
|
|
return itemised_tax, itemised_taxable_amount
|
|
|
|
hsn_wise_in_gst_settings = frappe.db.get_single_value('GST Settings','hsn_wise_tax_breakup')
|
|
|
|
tax_breakup_hsn_wise = hsn_wise or hsn_wise_in_gst_settings
|
|
if tax_breakup_hsn_wise:
|
|
item_hsn_map = frappe._dict()
|
|
for d in doc.items:
|
|
item_hsn_map.setdefault(d.item_code or d.item_name, d.get("gst_hsn_code"))
|
|
|
|
hsn_tax = {}
|
|
for item, taxes in itemised_tax.items():
|
|
item_or_hsn = item if not tax_breakup_hsn_wise else item_hsn_map.get(item)
|
|
hsn_tax.setdefault(item_or_hsn, frappe._dict())
|
|
for tax_desc, tax_detail in taxes.items():
|
|
key = tax_desc
|
|
if account_wise:
|
|
key = tax_detail.get('tax_account')
|
|
hsn_tax[item_or_hsn].setdefault(key, {"tax_rate": 0, "tax_amount": 0})
|
|
hsn_tax[item_or_hsn][key]["tax_rate"] = tax_detail.get("tax_rate")
|
|
hsn_tax[item_or_hsn][key]["tax_amount"] += tax_detail.get("tax_amount")
|
|
|
|
# set taxable amount
|
|
hsn_taxable_amount = frappe._dict()
|
|
for item in itemised_taxable_amount:
|
|
item_or_hsn = item if not tax_breakup_hsn_wise else item_hsn_map.get(item)
|
|
hsn_taxable_amount.setdefault(item_or_hsn, 0)
|
|
hsn_taxable_amount[item_or_hsn] += itemised_taxable_amount.get(item)
|
|
|
|
return hsn_tax, hsn_taxable_amount
|
|
|
|
def set_place_of_supply(doc, method=None):
|
|
doc.place_of_supply = get_place_of_supply(doc, doc.doctype)
|
|
|
|
def validate_document_name(doc, method=None):
|
|
"""Validate GST invoice number requirements."""
|
|
|
|
country = frappe.get_cached_value("Company", doc.company, "country")
|
|
|
|
# Date was chosen as start of next FY to avoid irritating current users.
|
|
if country != "India" or getdate(doc.posting_date) < getdate("2021-04-01"):
|
|
return
|
|
|
|
if len(doc.name) > 16:
|
|
frappe.throw(_("Maximum length of document number should be 16 characters as per GST rules. Please change the naming series."))
|
|
|
|
if not GST_INVOICE_NUMBER_FORMAT.match(doc.name):
|
|
frappe.throw(_("Document name should only contain alphanumeric values, dash(-) and slash(/) characters as per GST rules. Please change the naming series."))
|
|
|
|
# don't remove this function it is used in tests
|
|
def test_method():
|
|
'''test function'''
|
|
return 'overridden'
|
|
|
|
def get_place_of_supply(party_details, doctype):
|
|
if not frappe.get_meta('Address').has_field('gst_state'): return
|
|
|
|
if doctype in ("Sales Invoice", "Delivery Note", "Sales Order"):
|
|
address_name = party_details.customer_address or party_details.shipping_address_name
|
|
elif doctype in ("Purchase Invoice", "Purchase Order", "Purchase Receipt"):
|
|
address_name = party_details.shipping_address or party_details.supplier_address
|
|
|
|
if address_name:
|
|
address = frappe.db.get_value("Address", address_name, ["gst_state", "gst_state_number", "gstin"], as_dict=1)
|
|
if address and address.gst_state and address.gst_state_number:
|
|
party_details.gstin = address.gstin
|
|
return cstr(address.gst_state_number) + "-" + cstr(address.gst_state)
|
|
|
|
@frappe.whitelist()
|
|
def get_regional_address_details(party_details, doctype, company):
|
|
if isinstance(party_details, string_types):
|
|
party_details = json.loads(party_details)
|
|
party_details = frappe._dict(party_details)
|
|
|
|
update_party_details(party_details, doctype)
|
|
|
|
party_details.place_of_supply = get_place_of_supply(party_details, doctype)
|
|
|
|
if is_internal_transfer(party_details, doctype):
|
|
party_details.taxes_and_charges = ''
|
|
party_details.taxes = []
|
|
return party_details
|
|
|
|
if doctype in ("Sales Invoice", "Delivery Note", "Sales Order"):
|
|
master_doctype = "Sales Taxes and Charges Template"
|
|
get_tax_template_based_on_category(master_doctype, company, party_details)
|
|
|
|
if party_details.get('taxes_and_charges'):
|
|
return party_details
|
|
|
|
if not party_details.company_gstin:
|
|
return party_details
|
|
|
|
elif doctype in ("Purchase Invoice", "Purchase Order", "Purchase Receipt"):
|
|
master_doctype = "Purchase Taxes and Charges Template"
|
|
get_tax_template_based_on_category(master_doctype, company, party_details)
|
|
|
|
if party_details.get('taxes_and_charges'):
|
|
return party_details
|
|
|
|
if not party_details.supplier_gstin:
|
|
return party_details
|
|
|
|
if not party_details.place_of_supply: return party_details
|
|
|
|
if not party_details.company_gstin: return party_details
|
|
|
|
if ((doctype in ("Sales Invoice", "Delivery Note", "Sales Order") and party_details.company_gstin
|
|
and party_details.company_gstin[:2] != party_details.place_of_supply[:2]) or (doctype in ("Purchase Invoice",
|
|
"Purchase Order", "Purchase Receipt") and party_details.supplier_gstin and party_details.supplier_gstin[:2] != party_details.place_of_supply[:2])):
|
|
default_tax = get_tax_template(master_doctype, company, 1, party_details.company_gstin[:2])
|
|
else:
|
|
default_tax = get_tax_template(master_doctype, company, 0, party_details.company_gstin[:2])
|
|
|
|
if not default_tax:
|
|
return party_details
|
|
party_details["taxes_and_charges"] = default_tax
|
|
party_details.taxes = get_taxes_and_charges(master_doctype, default_tax)
|
|
|
|
return party_details
|
|
|
|
def update_party_details(party_details, doctype):
|
|
for address_field in ['shipping_address', 'company_address', 'supplier_address', 'shipping_address_name', 'customer_address']:
|
|
if party_details.get(address_field):
|
|
party_details.update(get_fetch_values(doctype, address_field, party_details.get(address_field)))
|
|
|
|
def is_internal_transfer(party_details, doctype):
|
|
if doctype in ("Sales Invoice", "Delivery Note", "Sales Order"):
|
|
destination_gstin = party_details.company_gstin
|
|
elif doctype in ("Purchase Invoice", "Purchase Order", "Purchase Receipt"):
|
|
destination_gstin = party_details.supplier_gstin
|
|
|
|
if not destination_gstin or party_details.gstin:
|
|
return False
|
|
|
|
if party_details.gstin == destination_gstin:
|
|
return True
|
|
else:
|
|
False
|
|
|
|
def get_tax_template_based_on_category(master_doctype, company, party_details):
|
|
if not party_details.get('tax_category'):
|
|
return
|
|
|
|
default_tax = frappe.db.get_value(master_doctype, {'company': company, 'tax_category': party_details.get('tax_category')},
|
|
'name')
|
|
|
|
if default_tax:
|
|
party_details["taxes_and_charges"] = default_tax
|
|
party_details.taxes = get_taxes_and_charges(master_doctype, default_tax)
|
|
|
|
def get_tax_template(master_doctype, company, is_inter_state, state_code):
|
|
tax_categories = frappe.get_all('Tax Category', fields = ['name', 'is_inter_state', 'gst_state'],
|
|
filters = {'is_inter_state': is_inter_state})
|
|
|
|
default_tax = ''
|
|
|
|
for tax_category in tax_categories:
|
|
if tax_category.gst_state == number_state_mapping[state_code] or \
|
|
(not default_tax and not tax_category.gst_state):
|
|
default_tax = frappe.db.get_value(master_doctype,
|
|
{'company': company, 'disabled': 0, 'tax_category': tax_category.name}, 'name')
|
|
return default_tax
|
|
|
|
def calculate_annual_eligible_hra_exemption(doc):
|
|
basic_component, hra_component = frappe.db.get_value('Company', doc.company, ["basic_component", "hra_component"])
|
|
if not (basic_component and hra_component):
|
|
frappe.throw(_("Please mention Basic and HRA component in Company"))
|
|
annual_exemption, monthly_exemption, hra_amount = 0, 0, 0
|
|
if hra_component and basic_component:
|
|
assignment = get_salary_assignment(doc.employee, nowdate())
|
|
if assignment:
|
|
hra_component_exists = frappe.db.exists("Salary Detail", {
|
|
"parent": assignment.salary_structure,
|
|
"salary_component": hra_component,
|
|
"parentfield": "earnings",
|
|
"parenttype": "Salary Structure"
|
|
})
|
|
|
|
if hra_component_exists:
|
|
basic_amount, hra_amount = get_component_amt_from_salary_slip(doc.employee,
|
|
assignment.salary_structure, basic_component, hra_component)
|
|
if hra_amount:
|
|
if doc.monthly_house_rent:
|
|
annual_exemption = calculate_hra_exemption(assignment.salary_structure,
|
|
basic_amount, hra_amount, doc.monthly_house_rent, doc.rented_in_metro_city)
|
|
if annual_exemption > 0:
|
|
monthly_exemption = annual_exemption / 12
|
|
else:
|
|
annual_exemption = 0
|
|
|
|
elif doc.docstatus == 1:
|
|
frappe.throw(_("Salary Structure must be submitted before submission of Tax Ememption Declaration"))
|
|
|
|
return frappe._dict({
|
|
"hra_amount": hra_amount,
|
|
"annual_exemption": annual_exemption,
|
|
"monthly_exemption": monthly_exemption
|
|
})
|
|
|
|
def get_component_amt_from_salary_slip(employee, salary_structure, basic_component, hra_component):
|
|
salary_slip = make_salary_slip(salary_structure, employee=employee, for_preview=1, ignore_permissions=True)
|
|
basic_amt, hra_amt = 0, 0
|
|
for earning in salary_slip.earnings:
|
|
if earning.salary_component == basic_component:
|
|
basic_amt = earning.amount
|
|
elif earning.salary_component == hra_component:
|
|
hra_amt = earning.amount
|
|
if basic_amt and hra_amt:
|
|
return basic_amt, hra_amt
|
|
return basic_amt, hra_amt
|
|
|
|
def calculate_hra_exemption(salary_structure, basic, monthly_hra, monthly_house_rent, rented_in_metro_city):
|
|
# TODO make this configurable
|
|
exemptions = []
|
|
frequency = frappe.get_value("Salary Structure", salary_structure, "payroll_frequency")
|
|
# case 1: The actual amount allotted by the employer as the HRA.
|
|
exemptions.append(get_annual_component_pay(frequency, monthly_hra))
|
|
|
|
actual_annual_rent = monthly_house_rent * 12
|
|
annual_basic = get_annual_component_pay(frequency, basic)
|
|
|
|
# case 2: Actual rent paid less 10% of the basic salary.
|
|
exemptions.append(flt(actual_annual_rent) - flt(annual_basic * 0.1))
|
|
# case 3: 50% of the basic salary, if the employee is staying in a metro city (40% for a non-metro city).
|
|
exemptions.append(annual_basic * 0.5 if rented_in_metro_city else annual_basic * 0.4)
|
|
# return minimum of 3 cases
|
|
return min(exemptions)
|
|
|
|
def get_annual_component_pay(frequency, amount):
|
|
if frequency == "Daily":
|
|
return amount * 365
|
|
elif frequency == "Weekly":
|
|
return amount * 52
|
|
elif frequency == "Fortnightly":
|
|
return amount * 26
|
|
elif frequency == "Monthly":
|
|
return amount * 12
|
|
elif frequency == "Bimonthly":
|
|
return amount * 6
|
|
|
|
def validate_house_rent_dates(doc):
|
|
if not doc.rented_to_date or not doc.rented_from_date:
|
|
frappe.throw(_("House rented dates required for exemption calculation"))
|
|
|
|
if date_diff(doc.rented_to_date, doc.rented_from_date) < 14:
|
|
frappe.throw(_("House rented dates should be atleast 15 days apart"))
|
|
|
|
proofs = frappe.db.sql("""
|
|
select name
|
|
from `tabEmployee Tax Exemption Proof Submission`
|
|
where
|
|
docstatus=1 and employee=%(employee)s and payroll_period=%(payroll_period)s
|
|
and (rented_from_date between %(from_date)s and %(to_date)s or rented_to_date between %(from_date)s and %(to_date)s)
|
|
""", {
|
|
"employee": doc.employee,
|
|
"payroll_period": doc.payroll_period,
|
|
"from_date": doc.rented_from_date,
|
|
"to_date": doc.rented_to_date
|
|
})
|
|
|
|
if proofs:
|
|
frappe.throw(_("House rent paid days overlapping with {0}").format(proofs[0][0]))
|
|
|
|
def calculate_hra_exemption_for_period(doc):
|
|
monthly_rent, eligible_hra = 0, 0
|
|
if doc.house_rent_payment_amount:
|
|
validate_house_rent_dates(doc)
|
|
# TODO receive rented months or validate dates are start and end of months?
|
|
# Calc monthly rent, round to nearest .5
|
|
factor = flt(date_diff(doc.rented_to_date, doc.rented_from_date) + 1)/30
|
|
factor = round(factor * 2)/2
|
|
monthly_rent = doc.house_rent_payment_amount / factor
|
|
# update field used by calculate_annual_eligible_hra_exemption
|
|
doc.monthly_house_rent = monthly_rent
|
|
exemptions = calculate_annual_eligible_hra_exemption(doc)
|
|
|
|
if exemptions["monthly_exemption"]:
|
|
# calc total exemption amount
|
|
eligible_hra = exemptions["monthly_exemption"] * factor
|
|
exemptions["monthly_house_rent"] = monthly_rent
|
|
exemptions["total_eligible_hra_exemption"] = eligible_hra
|
|
return exemptions
|
|
|
|
def get_ewb_data(dt, dn):
|
|
|
|
ewaybills = []
|
|
for doc_name in dn:
|
|
doc = frappe.get_doc(dt, doc_name)
|
|
|
|
validate_doc(doc)
|
|
|
|
data = frappe._dict({
|
|
"transporterId": "",
|
|
"TotNonAdvolVal": 0,
|
|
})
|
|
|
|
data.userGstin = data.fromGstin = doc.company_gstin
|
|
data.supplyType = 'O'
|
|
|
|
if dt == 'Delivery Note':
|
|
data.subSupplyType = 1
|
|
elif doc.gst_category in ['Registered Regular', 'SEZ']:
|
|
data.subSupplyType = 1
|
|
elif doc.gst_category in ['Overseas', 'Deemed Export']:
|
|
data.subSupplyType = 3
|
|
else:
|
|
frappe.throw(_('Unsupported GST Category for E-Way Bill JSON generation'))
|
|
|
|
data.docType = 'INV'
|
|
data.docDate = frappe.utils.formatdate(doc.posting_date, 'dd/mm/yyyy')
|
|
|
|
company_address = frappe.get_doc('Address', doc.company_address)
|
|
billing_address = frappe.get_doc('Address', doc.customer_address)
|
|
|
|
#added dispatch address
|
|
dispatch_address = frappe.get_doc('Address', doc.dispatch_address_name) if doc.dispatch_address_name else company_address
|
|
shipping_address = frappe.get_doc('Address', doc.shipping_address_name)
|
|
|
|
data = get_address_details(data, doc, company_address, billing_address, dispatch_address)
|
|
|
|
data.itemList = []
|
|
data.totalValue = doc.total
|
|
|
|
data = get_item_list(data, doc, hsn_wise=True)
|
|
|
|
disable_rounded = frappe.db.get_single_value('Global Defaults', 'disable_rounded_total')
|
|
data.totInvValue = doc.grand_total if disable_rounded else doc.rounded_total
|
|
|
|
data = get_transport_details(data, doc)
|
|
|
|
fields = {
|
|
"/. -": {
|
|
'docNo': doc.name,
|
|
'fromTrdName': doc.company,
|
|
'toTrdName': doc.customer_name,
|
|
'transDocNo': doc.lr_no,
|
|
},
|
|
"@#/,&. -": {
|
|
'fromAddr1': company_address.address_line1,
|
|
'fromAddr2': company_address.address_line2,
|
|
'fromPlace': company_address.city,
|
|
'toAddr1': shipping_address.address_line1,
|
|
'toAddr2': shipping_address.address_line2,
|
|
'toPlace': shipping_address.city,
|
|
'transporterName': doc.transporter_name
|
|
}
|
|
}
|
|
|
|
for allowed_chars, field_map in fields.items():
|
|
for key, value in field_map.items():
|
|
if not value:
|
|
data[key] = ''
|
|
else:
|
|
data[key] = re.sub(r'[^\w' + allowed_chars + ']', '', value)
|
|
|
|
ewaybills.append(data)
|
|
|
|
data = {
|
|
'version': '1.0.0421',
|
|
'billLists': ewaybills
|
|
}
|
|
|
|
return data
|
|
|
|
@frappe.whitelist()
|
|
def generate_ewb_json(dt, dn):
|
|
dn = json.loads(dn)
|
|
return get_ewb_data(dt, dn)
|
|
|
|
@frappe.whitelist()
|
|
def download_ewb_json():
|
|
data = json.loads(frappe.local.form_dict.data)
|
|
frappe.local.response.filecontent = json.dumps(data, indent=4, sort_keys=True)
|
|
frappe.local.response.type = 'download'
|
|
|
|
filename_prefix = 'Bulk'
|
|
docname = frappe.local.form_dict.docname
|
|
if docname:
|
|
if docname.startswith('['):
|
|
docname = json.loads(docname)
|
|
if len(docname) == 1:
|
|
docname = docname[0]
|
|
|
|
if not isinstance(docname, list):
|
|
# removes characters not allowed in a filename (https://stackoverflow.com/a/38766141/4767738)
|
|
filename_prefix = re.sub(r'[^\w_.)( -]', '', docname)
|
|
|
|
frappe.local.response.filename = '{0}_e-WayBill_Data_{1}.json'.format(filename_prefix, frappe.utils.random_string(5))
|
|
|
|
@frappe.whitelist()
|
|
def get_gstins_for_company(company):
|
|
company_gstins =[]
|
|
if company:
|
|
company_gstins = frappe.db.sql("""select
|
|
distinct `tabAddress`.gstin
|
|
from
|
|
`tabAddress`, `tabDynamic Link`
|
|
where
|
|
`tabDynamic Link`.parent = `tabAddress`.name and
|
|
`tabDynamic Link`.parenttype = 'Address' and
|
|
`tabDynamic Link`.link_doctype = 'Company' and
|
|
`tabDynamic Link`.link_name = %(company)s""", {"company": company})
|
|
return company_gstins
|
|
|
|
def get_address_details(data, doc, company_address, billing_address, dispatch_address):
|
|
data.fromPincode = validate_pincode(company_address.pincode, 'Company Address')
|
|
data.fromStateCode = validate_state_code(company_address.gst_state_number, 'Company Address')
|
|
data.actualFromStateCode = validate_state_code(dispatch_address.gst_state_number, 'Dispatch Address')
|
|
|
|
if not doc.billing_address_gstin or len(doc.billing_address_gstin) < 15:
|
|
data.toGstin = 'URP'
|
|
set_gst_state_and_state_number(billing_address)
|
|
else:
|
|
data.toGstin = doc.billing_address_gstin
|
|
|
|
data.toPincode = validate_pincode(billing_address.pincode, 'Customer Address')
|
|
data.toStateCode = validate_state_code(billing_address.gst_state_number, 'Customer Address')
|
|
|
|
if doc.customer_address != doc.shipping_address_name:
|
|
data.transType = 2
|
|
shipping_address = frappe.get_doc('Address', doc.shipping_address_name)
|
|
set_gst_state_and_state_number(shipping_address)
|
|
data.toPincode = validate_pincode(shipping_address.pincode, 'Shipping Address')
|
|
data.actualToStateCode = validate_state_code(shipping_address.gst_state_number, 'Shipping Address')
|
|
else:
|
|
data.transType = 1
|
|
data.actualToStateCode = data.toStateCode
|
|
shipping_address = billing_address
|
|
|
|
if doc.gst_category == 'SEZ':
|
|
data.toStateCode = 99
|
|
|
|
return data
|
|
|
|
def get_item_list(data, doc, hsn_wise=False):
|
|
for attr in ['cgstValue', 'sgstValue', 'igstValue', 'cessValue', 'OthValue']:
|
|
data[attr] = 0
|
|
|
|
gst_accounts = get_gst_accounts(doc.company, account_wise=True)
|
|
tax_map = {
|
|
'sgst_account': ['sgstRate', 'sgstValue'],
|
|
'cgst_account': ['cgstRate', 'cgstValue'],
|
|
'igst_account': ['igstRate', 'igstValue'],
|
|
'cess_account': ['cessRate', 'cessValue']
|
|
}
|
|
item_data_attrs = ['sgstRate', 'cgstRate', 'igstRate', 'cessRate', 'cessNonAdvol']
|
|
hsn_wise_charges, hsn_taxable_amount = get_itemised_tax_breakup_data(doc, account_wise=True, hsn_wise=hsn_wise)
|
|
for hsn_code, taxable_amount in hsn_taxable_amount.items():
|
|
item_data = frappe._dict()
|
|
if not hsn_code:
|
|
frappe.throw(_('GST HSN Code does not exist for one or more items'))
|
|
item_data.hsnCode = int(hsn_code)
|
|
item_data.taxableAmount = taxable_amount
|
|
item_data.qtyUnit = ""
|
|
for attr in item_data_attrs:
|
|
item_data[attr] = 0
|
|
|
|
for account, tax_detail in hsn_wise_charges.get(hsn_code, {}).items():
|
|
account_type = gst_accounts.get(account, '')
|
|
for tax_acc, attrs in tax_map.items():
|
|
if account_type == tax_acc:
|
|
item_data[attrs[0]] = tax_detail.get('tax_rate')
|
|
data[attrs[1]] += tax_detail.get('tax_amount')
|
|
break
|
|
else:
|
|
data.OthValue += tax_detail.get('tax_amount')
|
|
|
|
data.itemList.append(item_data)
|
|
|
|
# Tax amounts rounded to 2 decimals to avoid exceeding max character limit
|
|
for attr in ['sgstValue', 'cgstValue', 'igstValue', 'cessValue']:
|
|
data[attr] = flt(data[attr], 2)
|
|
|
|
return data
|
|
|
|
def validate_doc(doc):
|
|
if doc.docstatus != 1:
|
|
frappe.throw(_('E-Way Bill JSON can only be generated from submitted document'))
|
|
|
|
if doc.is_return:
|
|
frappe.throw(_('E-Way Bill JSON cannot be generated for Sales Return as of now'))
|
|
|
|
if doc.ewaybill:
|
|
frappe.throw(_('e-Way Bill already exists for this document'))
|
|
|
|
reqd_fields = ['company_gstin', 'company_address', 'customer_address',
|
|
'shipping_address_name', 'mode_of_transport', 'distance']
|
|
|
|
for fieldname in reqd_fields:
|
|
if not doc.get(fieldname):
|
|
frappe.throw(_('{} is required to generate E-Way Bill JSON').format(
|
|
doc.meta.get_label(fieldname)
|
|
))
|
|
|
|
if len(doc.company_gstin) < 15:
|
|
frappe.throw(_('You must be a registered supplier to generate e-Way Bill'))
|
|
|
|
def get_transport_details(data, doc):
|
|
if doc.distance > 4000:
|
|
frappe.throw(_('Distance cannot be greater than 4000 kms'))
|
|
|
|
data.transDistance = int(round(doc.distance))
|
|
|
|
transport_modes = {
|
|
'Road': 1,
|
|
'Rail': 2,
|
|
'Air': 3,
|
|
'Ship': 4
|
|
}
|
|
|
|
vehicle_types = {
|
|
'Regular': 'R',
|
|
'Over Dimensional Cargo (ODC)': 'O'
|
|
}
|
|
|
|
data.transMode = transport_modes.get(doc.mode_of_transport)
|
|
|
|
if doc.mode_of_transport == 'Road':
|
|
if not doc.gst_transporter_id and not doc.vehicle_no:
|
|
frappe.throw(_('Either GST Transporter ID or Vehicle No is required if Mode of Transport is Road'))
|
|
if doc.vehicle_no:
|
|
data.vehicleNo = doc.vehicle_no.replace(' ', '')
|
|
if not doc.gst_vehicle_type:
|
|
frappe.throw(_('Vehicle Type is required if Mode of Transport is Road'))
|
|
else:
|
|
data.vehicleType = vehicle_types.get(doc.gst_vehicle_type)
|
|
else:
|
|
if not doc.lr_no or not doc.lr_date:
|
|
frappe.throw(_('Transport Receipt No and Date are mandatory for your chosen Mode of Transport'))
|
|
|
|
if doc.lr_no:
|
|
data.transDocNo = doc.lr_no
|
|
|
|
if doc.lr_date:
|
|
data.transDocDate = frappe.utils.formatdate(doc.lr_date, 'dd/mm/yyyy')
|
|
|
|
if doc.gst_transporter_id:
|
|
if doc.gst_transporter_id[0:2] != "88":
|
|
validate_gstin_check_digit(doc.gst_transporter_id, label='GST Transporter ID')
|
|
data.transporterId = doc.gst_transporter_id
|
|
|
|
return data
|
|
|
|
|
|
def validate_pincode(pincode, address):
|
|
pin_not_found = "Pin Code doesn't exist for {}"
|
|
incorrect_pin = "Pin Code for {} is incorrecty formatted. It must be 6 digits (without spaces)"
|
|
|
|
if not pincode:
|
|
frappe.throw(_(pin_not_found.format(address)))
|
|
|
|
pincode = pincode.replace(' ', '')
|
|
if not pincode.isdigit() or len(pincode) != 6:
|
|
frappe.throw(_(incorrect_pin.format(address)))
|
|
else:
|
|
return int(pincode)
|
|
|
|
def validate_state_code(state_code, address):
|
|
no_state_code = "GST State Code not found for {0}. Please set GST State in {0}"
|
|
if not state_code:
|
|
frappe.throw(_(no_state_code.format(address)))
|
|
else:
|
|
return int(state_code)
|
|
|
|
@frappe.whitelist()
|
|
def get_gst_accounts(company=None, account_wise=False, only_reverse_charge=0, only_non_reverse_charge=0):
|
|
filters={"parent": "GST Settings"}
|
|
|
|
if company:
|
|
filters.update({'company': company})
|
|
if only_reverse_charge:
|
|
filters.update({'is_reverse_charge_account': 1})
|
|
elif only_non_reverse_charge:
|
|
filters.update({'is_reverse_charge_account': 0})
|
|
|
|
gst_accounts = frappe._dict()
|
|
gst_settings_accounts = frappe.get_all("GST Account",
|
|
filters=filters,
|
|
fields=["cgst_account", "sgst_account", "igst_account", "cess_account"])
|
|
|
|
if not gst_settings_accounts and not frappe.flags.in_test and not frappe.flags.in_migrate:
|
|
frappe.throw(_("Please set GST Accounts in GST Settings"))
|
|
|
|
for d in gst_settings_accounts:
|
|
for acc, val in d.items():
|
|
if not account_wise:
|
|
gst_accounts.setdefault(acc, []).append(val)
|
|
elif val:
|
|
gst_accounts[val] = acc
|
|
|
|
return gst_accounts
|
|
|
|
def validate_reverse_charge_transaction(doc, method):
|
|
country = frappe.get_cached_value('Company', doc.company, 'country')
|
|
|
|
if country != 'India':
|
|
return
|
|
|
|
base_gst_tax = 0
|
|
base_reverse_charge_booked = 0
|
|
|
|
if doc.reverse_charge == 'Y':
|
|
gst_accounts = get_gst_accounts(doc.company, only_reverse_charge=1)
|
|
reverse_charge_accounts = gst_accounts.get('cgst_account') + gst_accounts.get('sgst_account') \
|
|
+ gst_accounts.get('igst_account')
|
|
|
|
gst_accounts = get_gst_accounts(doc.company, only_non_reverse_charge=1)
|
|
non_reverse_charge_accounts = gst_accounts.get('cgst_account') + gst_accounts.get('sgst_account') \
|
|
+ gst_accounts.get('igst_account')
|
|
|
|
for tax in doc.get('taxes'):
|
|
if tax.account_head in non_reverse_charge_accounts:
|
|
if tax.add_deduct_tax == 'Add':
|
|
base_gst_tax += tax.base_tax_amount_after_discount_amount
|
|
else:
|
|
base_gst_tax += tax.base_tax_amount_after_discount_amount
|
|
elif tax.account_head in reverse_charge_accounts:
|
|
if tax.add_deduct_tax == 'Add':
|
|
base_reverse_charge_booked += tax.base_tax_amount_after_discount_amount
|
|
else:
|
|
base_reverse_charge_booked += tax.base_tax_amount_after_discount_amount
|
|
|
|
if base_gst_tax != base_reverse_charge_booked:
|
|
msg = _("Booked reverse charge is not equal to applied tax amount")
|
|
msg += "<br>"
|
|
msg += _("Please refer {gst_document_link} to learn more about how to setup and create reverse charge invoice").format(
|
|
gst_document_link='<a href="https://docs.erpnext.com/docs/user/manual/en/regional/india/gst-setup">GST Documentation</a>')
|
|
|
|
frappe.throw(msg)
|
|
|
|
def update_itc_availed_fields(doc, method):
|
|
country = frappe.get_cached_value('Company', doc.company, 'country')
|
|
|
|
if country != 'India':
|
|
return
|
|
|
|
# Initialize values
|
|
doc.itc_integrated_tax = doc.itc_state_tax = doc.itc_central_tax = doc.itc_cess_amount = 0
|
|
gst_accounts = get_gst_accounts(doc.company, only_non_reverse_charge=1)
|
|
|
|
for tax in doc.get('taxes'):
|
|
if tax.account_head in gst_accounts.get('igst_account', []):
|
|
doc.itc_integrated_tax += flt(tax.base_tax_amount_after_discount_amount)
|
|
if tax.account_head in gst_accounts.get('sgst_account', []):
|
|
doc.itc_state_tax += flt(tax.base_tax_amount_after_discount_amount)
|
|
if tax.account_head in gst_accounts.get('cgst_account', []):
|
|
doc.itc_central_tax += flt(tax.base_tax_amount_after_discount_amount)
|
|
if tax.account_head in gst_accounts.get('cess_account', []):
|
|
doc.itc_cess_amount += flt(tax.base_tax_amount_after_discount_amount)
|
|
|
|
def update_place_of_supply(doc, method):
|
|
country = frappe.get_cached_value('Company', doc.company, 'country')
|
|
if country != 'India':
|
|
return
|
|
|
|
address = frappe.db.get_value("Address", doc.get('customer_address'), ["gst_state", "gst_state_number"], as_dict=1)
|
|
if address and address.gst_state and address.gst_state_number:
|
|
doc.place_of_supply = cstr(address.gst_state_number) + "-" + cstr(address.gst_state)
|
|
|
|
@frappe.whitelist()
|
|
def get_regional_round_off_accounts(company, account_list):
|
|
country = frappe.get_cached_value('Company', company, 'country')
|
|
|
|
if country != 'India':
|
|
return
|
|
|
|
if isinstance(account_list, string_types):
|
|
account_list = json.loads(account_list)
|
|
|
|
if not frappe.db.get_single_value('GST Settings', 'round_off_gst_values'):
|
|
return
|
|
|
|
gst_accounts = get_gst_accounts(company)
|
|
|
|
gst_account_list = []
|
|
for account in ['cgst_account', 'sgst_account', 'igst_account']:
|
|
if account in gst_accounts:
|
|
gst_account_list += gst_accounts.get(account)
|
|
|
|
account_list.extend(gst_account_list)
|
|
|
|
return account_list
|
|
|
|
def update_taxable_values(doc, method):
|
|
country = frappe.get_cached_value('Company', doc.company, 'country')
|
|
|
|
if country != 'India':
|
|
return
|
|
|
|
gst_accounts = get_gst_accounts(doc.company)
|
|
|
|
# Only considering sgst account to avoid inflating taxable value
|
|
gst_account_list = gst_accounts.get('sgst_account', []) + gst_accounts.get('sgst_account', []) \
|
|
+ gst_accounts.get('igst_account', [])
|
|
|
|
additional_taxes = 0
|
|
total_charges = 0
|
|
item_count = 0
|
|
considered_rows = []
|
|
|
|
for tax in doc.get('taxes'):
|
|
prev_row_id = cint(tax.row_id) - 1
|
|
if tax.account_head in gst_account_list and prev_row_id not in considered_rows:
|
|
if tax.charge_type == 'On Previous Row Amount':
|
|
additional_taxes += doc.get('taxes')[prev_row_id].tax_amount_after_discount_amount
|
|
considered_rows.append(prev_row_id)
|
|
if tax.charge_type == 'On Previous Row Total':
|
|
additional_taxes += doc.get('taxes')[prev_row_id].base_total - doc.base_net_total
|
|
considered_rows.append(prev_row_id)
|
|
|
|
for item in doc.get('items'):
|
|
proportionate_value = item.base_net_amount if doc.base_net_total else item.qty
|
|
total_value = doc.base_net_total if doc.base_net_total else doc.total_qty
|
|
|
|
applicable_charges = flt(flt(proportionate_value * (flt(additional_taxes) / flt(total_value)),
|
|
item.precision('taxable_value')))
|
|
item.taxable_value = applicable_charges + proportionate_value
|
|
total_charges += applicable_charges
|
|
item_count += 1
|
|
|
|
if total_charges != additional_taxes:
|
|
diff = additional_taxes - total_charges
|
|
doc.get('items')[item_count - 1].taxable_value += diff
|
|
|
|
def get_depreciation_amount(asset, depreciable_value, row):
|
|
depreciation_left = flt(row.total_number_of_depreciations) - flt(asset.number_of_depreciations_booked)
|
|
|
|
if row.depreciation_method in ("Straight Line", "Manual"):
|
|
# if the Depreciation Schedule is being prepared for the first time
|
|
if not asset.flags.increase_in_asset_life:
|
|
depreciation_amount = (flt(row.value_after_depreciation) -
|
|
flt(row.expected_value_after_useful_life)) / depreciation_left
|
|
|
|
# if the Depreciation Schedule is being modified after Asset Repair
|
|
else:
|
|
depreciation_amount = (flt(row.value_after_depreciation) -
|
|
flt(row.expected_value_after_useful_life)) / (date_diff(asset.to_date, asset.available_for_use_date) / 365)
|
|
|
|
else:
|
|
rate_of_depreciation = row.rate_of_depreciation
|
|
# if its the first depreciation
|
|
if depreciable_value == asset.gross_purchase_amount:
|
|
if row.finance_book and frappe.db.get_value('Finance Book', row.finance_book, 'for_income_tax'):
|
|
# as per IT act, if the asset is purchased in the 2nd half of fiscal year, then rate is divided by 2
|
|
diff = date_diff(row.depreciation_start_date, asset.available_for_use_date)
|
|
if diff <= 180:
|
|
rate_of_depreciation = rate_of_depreciation / 2
|
|
frappe.msgprint(
|
|
_('As per IT Act, the rate of depreciation for the first depreciation entry is reduced by 50%.'))
|
|
|
|
depreciation_amount = flt(depreciable_value * (flt(rate_of_depreciation) / 100))
|
|
|
|
return depreciation_amount
|
|
|
|
def set_item_tax_from_hsn_code(item):
|
|
if not item.taxes and item.gst_hsn_code:
|
|
hsn_doc = frappe.get_doc("GST HSN Code", item.gst_hsn_code)
|
|
|
|
for tax in hsn_doc.taxes:
|
|
item.append('taxes', {
|
|
'item_tax_template': tax.item_tax_template,
|
|
'tax_category': tax.tax_category,
|
|
'valid_from': tax.valid_from
|
|
})
|
|
|
|
def delete_gst_settings_for_company(doc, method):
|
|
if doc.country != 'India':
|
|
return
|
|
|
|
gst_settings = frappe.get_doc("GST Settings")
|
|
records_to_delete = []
|
|
|
|
for d in reversed(gst_settings.get('gst_accounts')):
|
|
if d.company == doc.name:
|
|
records_to_delete.append(d)
|
|
|
|
for d in records_to_delete:
|
|
gst_settings.remove(d)
|
|
|
|
gst_settings.save()
|