Shiloh/brotherton-erpnext
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GL Control rewrite and many other cleanup using inheritence

Browse Source
This commit is contained in:
Nabin Hait 2013-01-30 12:49:08 +05:30
parent 021dd54fed
commit bf495c9a6d
16 changed files with 878 additions and 892 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
accounts/doctype/budget_control/budget_control.py
View File

@ -52,6 +52,7 @@ class DocType:
def check_budget(self,gle,cancel):
# get allocated budget
bgt = webnotes.conn.sql("""select t1.budget_allocated, t1.actual, t2.distribution_id
from `tabBudget Detail` t1, `tabCost Center` t2
where t1.account='%s' and t1.parent=t2.name and t2.name = '%s'

163
accounts/doctype/gl_control/gl_control.py
View File

@ -18,7 +18,7 @@ from __future__ import unicode_literals
import webnotes
from webnotes.utils import cstr, flt, get_defaults
from webnotes.model.doc import Document, addchild
from webnotes.model.doc import addchild
from webnotes.model.wrapper import getlist
from webnotes.model.code import get_obj
from webnotes import msgprint
@ -55,8 +55,6 @@ class DocType:
return ac.doc.name
# Add a new cost center
#----------------------
def add_cc(self,arg):
cc = webnotes.model_wrapper(eval(arg))
cc.doc.doctype = "Cost Center"
@ -64,135 +62,7 @@ class DocType:
cc.insert()
return cc.doc.name
# Get field values from the voucher
#------------------------------------------
def get_val(self, src, d, parent=None):
if not src:
return None
if src.startswith('parent:'):
return parent.fields[src.split(':')[1]]
elif src.startswith('value:'):
return eval(src.split(':')[1])
elif src:
return d.fields.get(src)
def check_if_in_list(self, le):
for e in self.entries:
if e.account == le.account and (cstr(e.against_voucher)==cstr(le.against_voucher)) and (cstr(e.against_voucher_type)==cstr(le.against_voucher_type)) and (cstr(e.cost_center)==cstr(le.cost_center)):
return [e]
return 0
# Make a dictionary(le) for every gl entry and append to a list(self.entries)
#----------------------------------------------------------------------------
def make_single_entry(self,parent,d,le_map,cancel, merge_entries):
if self.get_val(le_map['account'], d, parent) and \
(self.get_val(le_map['debit'], d, parent) \
or self.get_val(le_map['credit'], d, parent)):
flist = ['account', 'cost_center', 'against', 'debit', 'credit', 'remarks',
'voucher_type', 'voucher_no', 'posting_date', 'fiscal_year', 'against_voucher',
'against_voucher_type', 'company', 'is_opening', 'aging_date']
# Check budget before gl entry
#check budget only if account is expense account
is_expense_acct = webnotes.conn.sql("""select name from tabAccount
where is_pl_account='Yes' and debit_or_credit='Debit'
and name=%s""",self.get_val(le_map['account'], d, parent))
if is_expense_acct and self.get_val(le_map['cost_center'], d, parent):
get_obj('Budget Control').check_budget([self.get_val(le_map[k], d, parent)
for k in flist if k in ['account', 'cost_center', 'debit',
'credit', 'posting_date', 'fiscal_year', 'company']],cancel)
# Create new GL entry object and map values
le = Document('GL Entry')
for k in flist:
le.fields[k] = self.get_val(le_map[k], d, parent)
# if there is already an entry in this account then just add it to that entry
same_head = self.check_if_in_list(le)
if same_head and merge_entries:
same_head = same_head[0]
same_head.debit = flt(same_head.debit) + flt(le.debit)
same_head.credit = flt(same_head.credit) + flt(le.credit)
else:
self.entries.append(le)
def manage_debit_credit(self, cancel):
total_debit, total_credit = 0, 0
for le in self.entries:
# round off upto 2 decimal
le.debit = flt(le.debit, 2)
le.credit = flt(le.credit, 2)
#toggle debit, credit if negative entry
if flt(le.debit) < 0 or flt(le.credit) < 0:
tmp=le.debit
le.debit, le.credit = abs(flt(le.credit)), abs(flt(tmp))
# toggled debit/credit in two separate condition because both
# should be executed at the time of cancellation when there is
# negative amount (tax discount)
if cancel:
tmp=le.debit
le.debit, le.credit = abs(flt(le.credit)), abs(flt(tmp))
# update total debit / credit
total_debit += flt(le.debit, 2)
total_credit += flt(le.credit, 2)
diff = flt(total_debit - total_credit, 2)
if abs(diff)==0.01:
if self.entries[0].debit:
self.entries[0].debit = self.entries[0].debit - diff
elif self.entries[0].credit:
self.entries[0].credit = self.entries[0].credit + diff
elif abs(diff) > 0.01 and not cancel:
# Due to old wrong entries(total debit!=total credit) some voucher should be cancelled
msgprint("""Debit and Credit not equal for this voucher: Diff (Debit) is %s""" %
diff, raise_exception=1)
def save_entries(self, cancel, adv_adj, update_outstanding):
self.manage_debit_credit(cancel)
for le in self.entries:
le_obj = get_obj(doc=le)
# validate except on_cancel
if not cancel:
le_obj.validate()
le.save(1)
le_obj.on_update(adv_adj, cancel, update_outstanding)
# Make Multiple Entries
def make_gl_entries(self, doc, doclist, cancel=0, adv_adj = 0, use_mapper='', merge_entries = 1, update_outstanding='Yes'):
self.entries = []
# get entries
le_map_list = webnotes.conn.sql("select * from `tabGL Mapper Detail` where parent = %s", use_mapper or doc.doctype, as_dict=1)
for le_map in le_map_list:
if le_map['table_field']:
for d in getlist(doclist,le_map['table_field']):
# purchase_tax_details is the table of other charges in purchase cycle
if le_map['table_field'] != 'purchase_tax_details' or \
(le_map['table_field'] == 'purchase_tax_details' and \
d.fields.get('category') != 'Valuation'):
self.make_single_entry(doc,d,le_map,cancel, merge_entries)
else:
self.make_single_entry(None,doc,le_map,cancel, merge_entries)
# save entries
self.save_entries(cancel, adv_adj, update_outstanding)
# set as cancelled
if cancel:
vt = self.get_val(le_map['voucher_type'], doc, doc)
vn = self.get_val(le_map['voucher_no'], doc, doc)
webnotes.conn.sql("update `tabGL Entry` set is_cancelled='Yes' where voucher_type=%s and voucher_no=%s", (vt, vn))
# ADVANCE ALLOCATION
#-------------------
def get_advances(self, obj, account_head, table_name,table_field_name, dr_or_cr):
jv_detail = webnotes.conn.sql("""select t1.name, t1.remark, t2.%s, t2.name
from `tabJournal Voucher` t1, `tabJournal Voucher Detail` t2
@ -215,8 +85,6 @@ class DocType:
return obj.doclist
# Clear rows which is not adjusted
#-------------------------------------
def clear_advances(self, obj,table_name,table_field_name):
for d in getlist(obj.doclist,table_field_name):
if not flt(d.allocated_amount):
@ -291,31 +159,4 @@ class DocType:
""" % (args))
if not ret:
msgprint("Payment Entry has been modified after you pulled it. Please pull it again.", raise_exception=1)
def repost_illegal_cancelled(self, after_date='2011-01-01'):
"""
Find vouchers that are not cancelled correctly and repost them
"""
vl = webnotes.conn.sql("""
select voucher_type, voucher_no, account, sum(debit) as sum_debit, sum(credit) as sum_credit
from `tabGL Entry`
where is_cancelled='Yes' and creation > %s
group by voucher_type, voucher_no, account
""", after_date, as_dict=1)
ac_list = []
for v in vl:
if v['sum_debit'] != 0 or v['sum_credit'] != 0:
ac_list.append(v['account'])
fy_list = webnotes.conn.sql("""select name from `tabFiscal Year`
where (%s between year_start_date and date_sub(date_add(year_start_date,interval 1 year), interval 1 day))
or year_start_date > %s
order by year_start_date ASC""", (after_date, after_date))
for fy in fy_list:
fy_obj = get_obj('Fiscal Year', fy[0])
for a in set(ac_list):
fy_obj.repost(a)
msgprint("Payment Entry has been modified after you pulled it. Please pull it again.", raise_exception=1)

20
accounts/doctype/gl_entry/gl_entry.py
View File

@ -18,15 +18,11 @@ from __future__ import unicode_literals
import webnotes
from webnotes.utils import flt, fmt_money, get_first_day, get_last_day, getdate
from webnotes.model import db_exists
from webnotes.model.wrapper import copy_doclist
from webnotes.model.code import get_obj
from webnotes import msgprint
sql = webnotes.conn.sql
class DocType:
def __init__(self,d,dl):
self.doc, self.doclist = d, dl
@ -38,28 +34,18 @@ class DocType:
mandatory = ['account','remarks','voucher_type','voucher_no','fiscal_year','company']
for k in mandatory:
if not self.doc.fields.get(k):
msgprint("%s is mandatory for GL Entry" % k)
raise Exception
msgprint("%s is mandatory for GL Entry" % k, raise_exception=1)
# Zero value transaction is not allowed
if not (flt(self.doc.debit) or flt(self.doc.credit)):
msgprint("GL Entry: Debit or Credit amount is mandatory for %s" % self.doc.account)
raise Exception
# COMMMENTED below to allow zero amount (+ and -) entry in tax table
# Debit and credit can not done at the same time
#if flt(self.doc.credit) != 0 and flt(self.doc.debit) != 0:
# msgprint("Sorry you cannot credit and debit under same account head.")
# raise Exception, "Validation Error."
# Cost center is required only if transaction made against pl account
#--------------------------------------------------------------------
def pl_must_have_cost_center(self):
if sql("select name from tabAccount where name=%s and is_pl_account='Yes'", self.doc.account):
if not self.doc.cost_center and self.doc.voucher_type != 'Period Closing Voucher':
msgprint("Error: Cost Center must be specified for PL Account: %s" % self.doc.account)
raise Exception
msgprint("Error: Cost Center must be specified for PL Account: %s" %
self.doc.account, raise_exception=1)
else: # not pl
if self.doc.cost_center:
self.doc.cost_center = ''

7
accounts/doctype/journal_voucher/journal_voucher.py
View File

@ -246,9 +246,10 @@ class DocType(AccountsController):
msgprint("Credit account is not matching with Purchase Invoice", raise_exception=1)
def make_gl_entries(self, cancel=0):
gl_entries = []
from accounts.general_ledger import make_gl_entries
gl_map = []
for d in self.doclist.get({"parentfield": "entries"}):
gl_entries.append(
gl_map.append(
self.get_gl_dict({
"account": d.account,
"against": d.against_account,
@ -263,7 +264,7 @@ class DocType(AccountsController):
}, cancel)
)
super(DocType, self).make_gl_entries(cancel=cancel, gl_map=gl_entries)
make_gl_entries(gl_map, cancel=cancel)
def get_outstanding(self, args):
args = eval(args)

93
accounts/doctype/purchase_invoice/purchase_invoice.py
View File

@ -427,8 +427,97 @@ class DocType(BuyingController):
def make_gl_entries(self, is_cancel = 0):
get_obj(dt='GL Control').make_gl_entries(self.doc, self.doclist, cancel = is_cancel, \
use_mapper = (self.doc.write_off_account and self.doc.write_off_amount and 'Purchase Invoice with write off' or ''))
from accounts.general_ledger import make_gl_entries
gl_entries = []
valuation_tax = 0
auto_inventory_accounting = webnotes.conn.get_value("Global Defaults", None,
"automatic_inventory_accounting")
abbr = self.get_company_abbr()
# parent's gl entry
gl_entries.append(
self.get_gl_dict({
"account": self.doc.credit_to,
"against": self.doc.against_expense_account,
"credit": self.doc.grand_total,
"remarks": self.doc.remarks,
"against_voucher": self.doc.name,
"against_voucher_type": self.doc.doctype,
}, is_cancel)
)
# tax table gl entries
for tax in getlist(self.doclist, "other_charges"):
if tax.category in ("Total", "Valuation and Total"):
valuation_tax += flt(tax.tax_amount)
gl_entries.append(
self.get_gl_dict({
"account": tax.account_head,
"against": self.doc.credit_to,
"debit": tax.tax_amount,
"remarks": self.doc.remarks,
"cost_center": tax.cost_center
}, is_cancel)
)
# item gl entries
stock_item_and_auto_accounting = False
for item in self.doclist.get({"parentfield": "entries"}):
if auto_inventory_accounting and \
webnotes.conn.get_value("Item", item.item_code, "is_stock_item")=="Yes":
# if auto inventory accounting enabled and stock item,
# then do stock related gl entries, expense will be booked in sales invoice
gl_entries.append(
self.get_gl_dict({
"account": "Stock Received But Not Billed - %s" % (abbr,),
"against": self.doc.credit_to,
"debit": flt(item.valuation_rate) * flt(item.conversion_factor) \
* item.qty,
"remarks": self.doc.remarks or "Accounting Entry for Stock"
}, is_cancel)
)
stock_item_and_auto_accounting = True
else:
# if not a stock item or auto inventory accounting disabled, book the expense
gl_entries.append(
self.get_gl_dict({
"account": item.expense_head,
"against": self.doc.credit_to,
"debit": item.amount,
"remarks": self.doc.remarks,
"cost_center": item.cost_center
}, is_cancel)
)
if stock_item_and_auto_accounting and valuation_tax:
# credit valuation tax amount in "Expenses Included In Valuation"
# this will balance out valuation amount included in cost of goods sold
gl_entries.append(
self.get_gl_dict({
"account": "Expenses Included In Valuation - %s" % (abbr,),
"cost_center": "ERP - %s" % abbr, # to-do
"against": self.doc.credit_to,
"credit": valuation_tax,
"remarks": self.doc.remarks or "Accounting Entry for Stock"
}, is_cancel)
)
# writeoff account includes petty difference in the invoice amount
# and the amount that is paid
if self.doc.write_off_account and self.doc.write_off_amount:
gl_entries.append(
self.get_gl_dict({
"account": self.doc.write_off_account,
"against": self.doc.credit_to,
"credit": self.doc.write_off_amount,
"remarks": self.doc.remarks,
"cost_center": self.doc.write_off_cost_center
}, is_cancel)
)
make_gl_entries(gl_entries, cancel=is_cancel)
def check_next_docstatus(self):

274
accounts/doctype/purchase_invoice/test_purchase_invoice.py
View File

@ -20,7 +20,6 @@ import unittest
import webnotes
import webnotes.model
from webnotes.utils import nowdate
from accounts.utils import get_fiscal_year
from stock.doctype.purchase_receipt import test_purchase_receipt
@ -30,6 +29,10 @@ abbr = webnotes.conn.get_value("Company", company, "abbr")
def load_data():
test_purchase_receipt.load_data()
webnotes.insert({"doctype": "Account", "account_name": "Cost for Goods Sold",
"parent_account": "Expenses - %s" % abbr, "company": company,
"group_or_ledger": "Ledger"})
webnotes.insert({"doctype": "Account", "account_name": "Excise Duty",
"parent_account": "Tax Assets - %s" % abbr, "company": company,
"group_or_ledger": "Ledger"})
@ -69,64 +72,67 @@ purchase_invoice_doclist = [
"naming_series": "BILL", "posting_date": nowdate(),
"company": company, "fiscal_year": webnotes.conn.get_default("fiscal_year"),
"currency": webnotes.conn.get_default("currency"), "conversion_rate": 1,
'grand_total_import': 0
'net_total': 1250.00, 'grand_total': 1512.30, 'grand_total_import': 1512.30,
},
# items
{
"doctype": "Purchase Invoice Item",
"item_code": "Home Desktop 100", "qty": 10, "import_rate": 50,
"parentfield": "entries",
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
"item_code": "Home Desktop 100", "qty": 10, "import_rate": 50, "rate": 50,
"amount": 500, "import_amount": 500, "parentfield": "entries",
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10}),
"expense_head": "Cost for Goods Sold - %s" % abbr,
"cost_center": "Default Cost Center - %s" % abbr
},
{
"doctype": "Purchase Invoice Item",
"item_code": "Home Desktop 200", "qty": 5, "import_rate": 150,
"parentfield": "entries",
"uom": "Nos"
"item_code": "Home Desktop 200", "qty": 5, "import_rate": 150, "rate": 150,
"amount": 750, "import_amount": 750, "parentfield": "entries", "uom": "Nos",
"expense_head": "Cost for Goods Sold - %s" % abbr,
"cost_center": "Default Cost Center - %s" % abbr
},
# taxes
{
"doctype": "Purchase Taxes and Charges", "charge_type": "Actual",
"account_head": "Shipping Charges - %s" % abbr, "rate": 100,
"category": "Valuation and Total", "parentfield": "purchase_tax_details",
"account_head": "Shipping Charges - %s" % abbr, "rate": 100, "tax_amount": 100,
"category": "Valuation and Total", "parentfield": "other_charges",
"cost_center": "Default Cost Center - %s" % abbr
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Customs Duty - %s" % abbr, "rate": 10,
"category": "Valuation", "parentfield": "purchase_tax_details",
"account_head": "Customs Duty - %s" % abbr, "rate": 10, "tax_amount": 125.00,
"category": "Valuation", "parentfield": "other_charges",
"cost_center": "Default Cost Center - %s" % abbr
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Excise Duty - %s" % abbr, "rate": 12,
"category": "Total", "parentfield": "purchase_tax_details"
"account_head": "Excise Duty - %s" % abbr, "rate": 12, "tax_amount": 140.00,
"category": "Total", "parentfield": "other_charges"
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Previous Row Amount",
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 3,
"category": "Total", "parentfield": "purchase_tax_details"
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 3, "tax_amount": 2.80,
"category": "Total", "parentfield": "other_charges"
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Previous Row Amount",
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 3,
"category": "Total", "parentfield": "purchase_tax_details"
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 3,
"tax_amount": 1.4, "category": "Total", "parentfield": "other_charges"
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Previous Row Total",
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 5,
"category": "Total", "parentfield": "purchase_tax_details",
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 5, "tax_amount": 29.88,
"category": "Total", "parentfield": "other_charges",
"cost_center": "Default Cost Center - %s" % abbr
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Net Total",
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
"category": "Total", "parentfield": "purchase_tax_details"
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5, "tax_amount": 156.25,
"category": "Total", "parentfield": "other_charges"
},
{
"doctype": "Purchase Taxes and Charges", "charge_type": "On Previous Row Total",
"account_head": "Discount - %s" % abbr, "rate": -10, "row_id": 7,
"category": "Total", "parentfield": "purchase_tax_details",
"account_head": "Discount - %s" % abbr, "rate": -10, "row_id": 7, "tax_amount": -168.03,
"category": "Total", "parentfield": "other_charges",
"cost_center": "Default Cost Center - %s" % abbr
},
]
@ -135,125 +141,18 @@ class TestPurchaseReceipt(unittest.TestCase):
def setUp(self):
webnotes.conn.begin()
load_data()
webnotes.conn.set_value("Global Defaults", None, "automatic_inventory_accounting", 1)
def test_purchase_invoice(self):
from webnotes.model.doclist import DocList
controller = webnotes.insert(DocList(purchase_invoice_doclist))
controller.load_from_db()
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.save()
controller.load_from_db()
dl = controller.doclist
# test net total
self.assertEqual(dl[0].net_total, 1250)
# test tax amounts and totals
expected_values = [
["Shipping Charges - %s" % abbr, 100, 1350],
["Customs Duty - %s" % abbr, 125, 1350],
["Excise Duty - %s" % abbr, 140, 1490],
["Education Cess - %s" % abbr, 2.8, 1492.8],
["S&H Education Cess - %s" % abbr, 1.4, 1494.2],
["CST - %s" % abbr, 29.88, 1524.08],
["VAT - Test - %s" % abbr, 156.25, 1680.33],
["Discount - %s" % abbr, -168.03, 1512.30],
]
for i, tax in enumerate(dl.get({"parentfield": "purchase_tax_details"})):
# print tax.account_head, tax.tax_amount, tax.total
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
# test item tax amount
expected_values = [
["Home Desktop 100", 90],
["Home Desktop 200", 135]
]
for i, item in enumerate(dl.get({"parentfield": "purchase_invoice_items"})):
self.assertEqual(item.item_code, expected_values[i][0])
self.assertEqual(item.item_tax_amount, expected_values[i][1])
# webnotes.conn.set_value("Global Defaults", None, "automatic_inventory_accounting", 1)
def test_purchase_invoice_having_zero_amount_items(self):
from webnotes.model.doclist import DocList
sample_purchase_invoice_doclist = [] + purchase_invoice_doclist
# set rate and amount as 0
sample_purchase_invoice_doclist[1]["import_rate"] = 0
sample_purchase_invoice_doclist[2]["import_rate"] = 0
controller = webnotes.insert(DocList(sample_purchase_invoice_doclist))
controller.load_from_db()
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.save()
controller.load_from_db()
dl = controller.doclist
# test net total
self.assertEqual(dl[0].net_total, 0)
# test tax amounts and totals
expected_values = [
["Shipping Charges - %s" % abbr, 100, 100],
["Customs Duty - %s" % abbr, 0, 100],
["Excise Duty - %s" % abbr, 0, 100],
["Education Cess - %s" % abbr, 0, 100],
["S&H Education Cess - %s" % abbr, 0, 100],
["CST - %s" % abbr, 2, 102],
["VAT - Test - %s" % abbr, 0, 102],
["Discount - %s" % abbr, -10.2, 91.8],
]
for i, tax in enumerate(dl.get({"parentfield": "purchase_tax_details"})):
# print tax.account_head, tax.tax_amount, tax.total
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
# test item tax amount
expected_values = [
["Home Desktop 100", 0],
["Home Desktop 200", 0]
]
for i, item in enumerate(dl.get({"parentfield": "purchase_invoice_items"})):
self.assertEqual(item.item_code, expected_values[i][0])
self.assertEqual(item.item_tax_amount, expected_values[i][1])
def atest_gl_entries(self):
def test_gl_entries(self):
from webnotes.model.doclist import DocList
controller = webnotes.insert(DocList(purchase_invoice_doclist))
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.submit()
controller.load_from_db()
dl = controller.doclist
expected_values = {
expected_gl_entries = {
"East Wind Inc. - %s" % abbr : [0, 1512.30],
"Cost for Goods Sold - %s" % abbr : [1250, 0],
"Shipping Charges - %s" % abbr : [100, 0],
"Excise Duty - %s" % abbr : [140, 0],
"Education Cess - %s" % abbr : [2.8, 0],
@ -261,14 +160,111 @@ class TestPurchaseReceipt(unittest.TestCase):
"CST - %s" % abbr : [29.88, 0],
"VAT - Test - %s" % abbr : [156.25, 0],
"Discount - %s" % abbr : [0, 168.03],
"Stock Received But Not Billed - %s" % abbr : [1475, 0],
"Expenses Included In Valuation - %s" % abbr : [0, 225]
}
gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type = 'Purchase Invoice' and voucher_no = %s""", dl[0].name, as_dict=1)
for d in gl_entries:
self.assertEqual(d["debit"], expected_values.get(d['account'])[0])
self.assertEqual(d["credit"], expected_values.get(d['account'])[1])
self.assertEqual([d.debit, d.credit], expected_gl_entries.get(d.account))
# def test_purchase_invoice(self):
# from webnotes.model.doclist import DocList
# controller = webnotes.insert(DocList(purchase_invoice_doclist))
# controller.load_from_db()
#
# from controllers.tax_controller import TaxController
# tax_controller = TaxController(controller.doc, controller.doclist)
# tax_controller.item_table_field = "entries"
# tax_controller.calculate_taxes_and_totals()
#
# controller.doc = tax_controller.doc
# controller.doclist = tax_controller.doclist
#
# controller.save()
# controller.load_from_db()
# dl = controller.doclist
#
# # test net total
# self.assertEqual(dl[0].net_total, 1250)
#
# # test tax amounts and totals
# expected_values = [
# ["Shipping Charges - %s" % abbr, 100, 1350],
# ["Customs Duty - %s" % abbr, 125, 1350],
# ["Excise Duty - %s" % abbr, 140, 1490],
# ["Education Cess - %s" % abbr, 2.8, 1492.8],
# ["S&H Education Cess - %s" % abbr, 1.4, 1494.2],
# ["CST - %s" % abbr, 29.88, 1524.08],
# ["VAT - Test - %s" % abbr, 156.25, 1680.33],
# ["Discount - %s" % abbr, -168.03, 1512.30],
# ]
# for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# self.assertEqual(tax.account_head, expected_values[i][0])
# self.assertEqual(tax.tax_amount, expected_values[i][1])
# self.assertEqual(tax.total, expected_values[i][2])
#
# # test item tax amount
# expected_values = [
# ["Home Desktop 100", 90],
# ["Home Desktop 200", 135]
# ]
# for i, item in enumerate(dl.get({"parentfield": "purchase_invoice_items"})):
# self.assertEqual(item.item_code, expected_values[i][0])
# self.assertEqual(item.item_tax_amount, expected_values[i][1])
#
#
# def test_purchase_invoice_having_zero_amount_items(self):
# from webnotes.model.doclist import DocList
# sample_purchase_invoice_doclist = [] + purchase_invoice_doclist
#
# # set rate and amount as 0
# sample_purchase_invoice_doclist[1]["import_rate"] = 0
# sample_purchase_invoice_doclist[2]["import_rate"] = 0
#
#
# controller = webnotes.insert(DocList(sample_purchase_invoice_doclist))
# controller.load_from_db()
#
# from controllers.tax_controller import TaxController
# tax_controller = TaxController(controller.doc, controller.doclist)
# tax_controller.item_table_field = "entries"
# tax_controller.calculate_taxes_and_totals()
#
# controller.doc = tax_controller.doc
# controller.doclist = tax_controller.doclist
#
# controller.save()
# controller.load_from_db()
# dl = controller.doclist
#
# # test net total
# self.assertEqual(dl[0].net_total, 0)
#
# # test tax amounts and totals
# expected_values = [
# ["Shipping Charges - %s" % abbr, 100, 100],
# ["Customs Duty - %s" % abbr, 0, 100],
# ["Excise Duty - %s" % abbr, 0, 100],
# ["Education Cess - %s" % abbr, 0, 100],
# ["S&H Education Cess - %s" % abbr, 0, 100],
# ["CST - %s" % abbr, 2, 102],
# ["VAT - Test - %s" % abbr, 0, 102],
# ["Discount - %s" % abbr, -10.2, 91.8],
# ]
# for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# # print tax.account_head, tax.tax_amount, tax.total
# self.assertEqual(tax.account_head, expected_values[i][0])
# self.assertEqual(tax.tax_amount, expected_values[i][1])
# self.assertEqual(tax.total, expected_values[i][2])
#
# # test item tax amount
# expected_values = [
# ["Home Desktop 100", 0],
# ["Home Desktop 200", 0]
# ]
# for i, item in enumerate(dl.get({"parentfield": "purchase_invoice_items"})):
# self.assertEqual(item.item_code, expected_values[i][0])
# self.assertEqual(item.item_tax_amount, expected_values[i][1])
def tearDown(self):

149
accounts/doctype/sales_invoice/sales_invoice.py
View File

@ -196,13 +196,10 @@ class DocType(SellingController):
"""Set Due Date = Posting Date + Credit Days"""
credit_days = 0
if self.doc.debit_to:
credit_days = webnotes.conn.sql("select credit_days from `tabAccount` where name='%s' and docstatus != 2" % self.doc.debit_to)
credit_days = credit_days and cint(credit_days[0][0]) or 0
credit_days = webnotes.conn.get_value("Account", self.doc.debit_to, "credit_days")
if self.doc.company and not credit_days:
credit_days = webnotes.conn.sql("select credit_days from `tabCompany` where name='%s'" % self.doc.company)
credit_days = credit_days and cint(credit_days[0][0]) or 0
# Customer has higher priority than company
# i.e.if not entered in customer will take credit days from company
credit_days = webnotes.conn.get_value("Company", self.doc.company, "credit_days")
self.doc.due_date = add_days(cstr(self.doc.posting_date), credit_days)
if self.doc.debit_to:
@ -211,17 +208,25 @@ class DocType(SellingController):
def pull_details(self):
"""Pull Details of Delivery Note or Sales Order Selected"""
# Delivery Note
if self.doc.delivery_note_main:
self.validate_prev_docname('delivery note')
self.doclist = self.doc.clear_table(self.doclist,'other_charges')
self.doclist = get_obj('DocType Mapper', 'Delivery Note-Sales Invoice').dt_map('Delivery Note', 'Sales Invoice', self.doc.delivery_note_main, self.doc, self.doclist, "[['Delivery Note', 'Sales Invoice'],['Delivery Note Item', 'Sales Invoice Item'],['Sales Taxes and Charges','Sales Taxes and Charges'],['Sales Team','Sales Team']]")
self.doclist = get_obj('DocType Mapper', 'Delivery Note-Sales Invoice').dt_map(
'Delivery Note', 'Sales Invoice', self.doc.delivery_note_main, self.doc,
self.doclist, """[['Delivery Note', 'Sales Invoice'],
['Delivery Note Item', 'Sales Invoice Item'],
['Sales Taxes and Charges','Sales Taxes and Charges'],
['Sales Team','Sales Team']]""")
self.get_income_account('entries')
# Sales Order
elif self.doc.sales_order_main:
self.validate_prev_docname('sales order')
self.doclist = self.doc.clear_table(self.doclist,'other_charges')
get_obj('DocType Mapper', 'Sales Order-Sales Invoice').dt_map('Sales Order', 'Sales Invoice', self.doc.sales_order_main, self.doc, self.doclist, "[['Sales Order', 'Sales Invoice'],['Sales Order Item', 'Sales Invoice Item'],['Sales Taxes and Charges','Sales Taxes and Charges'], ['Sales Team', 'Sales Team']]")
get_obj('DocType Mapper', 'Sales Order-Sales Invoice').dt_map('Sales Order',
'Sales Invoice', self.doc.sales_order_main, self.doc, self.doclist,
"""[['Sales Order', 'Sales Invoice'],['Sales Order Item', 'Sales Invoice Item'],
['Sales Taxes and Charges','Sales Taxes and Charges'],
['Sales Team', 'Sales Team']]""")
self.get_income_account('entries')
ret = self.get_debit_to()
@ -238,9 +243,11 @@ class DocType(SellingController):
def get_income_account(self,doctype):
for d in getlist(self.doclist, doctype):
if d.item_code:
item = webnotes.conn.sql("select default_income_account, default_sales_cost_center from tabItem where name = '%s'" %(d.item_code), as_dict=1)
d.income_account = item and item[0]['default_income_account'] or ''
d.cost_center = item and item[0]['default_sales_cost_center'] or ''
item = webnotes.conn.get_value("Item", d.item_code,
["default_income_account", "default_sales_cost_center"])
d.income_account = item['default_income_account'] or ""
d.cost_center = item['default_sales_cost_center'] or ""
def get_item_details(self, args=None):
@ -620,10 +627,120 @@ class DocType(SellingController):
def make_gl_entries(self, is_cancel=0):
mapper = self.doc.is_pos and self.doc.write_off_account and 'POS with write off' or self.doc.is_pos and not self.doc.write_off_account and 'POS' or ''
update_outstanding = self.doc.is_pos and self.doc.write_off_account and 'No' or 'Yes'
get_obj(dt='GL Control').make_gl_entries(self.doc, self.doclist,cancel = is_cancel, use_mapper = mapper, update_outstanding = update_outstanding, merge_entries = cint(self.doc.is_pos) != 1 and 1 or 0)
from accounts.general_ledger import make_gl_entries
gl_entries = []
auto_inventory_accounting = webnotes.conn.get_value("Global Defaults", None,
"automatic_inventory_accounting")
abbr = self.get_company_abbr()
# parent's gl entry
gl_entries.append(
self.get_gl_dict({
"account": self.doc.debit_to,
"against": self.doc.against_income_account,
"debit": self.doc.grand_total,
"remarks": self.doc.remarks,
"against_voucher": self.doc.name,
"against_voucher_type": self.doc.doctype,
}, is_cancel)
)
# tax table gl entries
for tax in self.doclist.get({"parentfield": "other_charges"}):
gl_entries.append(
self.get_gl_dict({
"account": tax.account_head,
"against": self.doc.debit_to,
"credit": flt(tax.tax_amount),
"remarks": self.doc.remarks,
"cost_center": tax.cost_center_other_charges
}, is_cancel)
)
# item gl entries
for item in getlist(self.doclist, 'entries'):
# income account gl entries
gl_entries.append(
self.get_gl_dict({
"account": item.income_account,
"against": self.doc.debit_to,
"credit": item.amount,
"remarks": self.doc.remarks,
"cost_center": item.cost_center
}, is_cancel)
)
# if auto inventory accounting enabled and stock item,
# then do stock related gl entries
if auto_inventory_accounting and item.delivery_note and \
webnotes.conn.get_value("Item", item.item_code, "is_stock_item")=="Yes":
# to-do
purchase_rate = webnotes.conn.get_value("Delivery Note Item",
item.dn_detail, "purchase_rate")
valuation_amount = purchase_rate * item.qty
# expense account gl entries
gl_entries.append(
self.get_gl_dict({
"account": item.expense_account,
"against": "Stock Delivered But Not Billed - %s" % (abbr,),
"debit": valuation_amount,
"remarks": self.doc.remarks or "Accounting Entry for Stock"
}, is_cancel)
)
gl_entries.append(
self.get_gl_dict({
"account": "Stock Delivered But Not Billed - %s" % (abbr,),
"against": item.expense_account,
"credit": valuation_amount,
"remarks": self.doc.remarks or "Accounting Entry for Stock"
}, is_cancel)
)
if self.doc.is_pos and self.doc.cash_bank_account and self.doc.paid_amount:
# POS, make payment entries
gl_entries.append(
self.get_gl_dict({
"account": self.doc.debit_to,
"against": self.doc.cash_bank_account,
"credit": self.doc.paid_amount,
"remarks": self.doc.remarks,
"against_voucher": self.doc.name,
"against_voucher_type": self.doc.doctype,
}, is_cancel)
)
gl_entries.append(
self.get_gl_dict({
"account": self.doc.cash_bank_account,
"against": self.doc.debit_to,
"debit": self.doc.paid_amount,
"remarks": self.doc.remarks,
}, is_cancel)
)
# write off entries, applicable if only pos
if self.doc.write_off_account and self.doc.write_off_amount:
gl_entries.append(
self.get_gl_dict({
"account": self.doc.debit_to,
"against": self.doc.write_off_account,
"credit": self.doc.write_off_amount,
"remarks": self.doc.remarks,
"against_voucher": self.doc.name,
"against_voucher_type": self.doc.doctype,
}, is_cancel)
)
gl_entries.append(
self.get_gl_dict({
"account": self.doc.write_off_account,
"against": self.doc.debit_to,
"debit": self.doc.write_off_amount,
"remarks": self.doc.remarks,
"cost_center": self.doc.write_off_cost_center
}, is_cancel)
)
update_outstanding = self.doc.is_pos and self.doc.write_off_account and 'No' or 'Yes'
merge_entries=cint(self.doc.is_pos)!=1 and 1 or 0
make_gl_entries(gl_entries, cancel=is_cancel,
update_outstanding=update_outstanding, merge_entries=merge_entries)
def update_c_form(self):
"""Update amended id in C-form"""

722
accounts/doctype/sales_invoice/test_sales_invoice.py
View File

@ -21,7 +21,6 @@ import webnotes
import webnotes.model
from webnotes.model.doclist import DocList
from webnotes.utils import nowdate
from accounts.utils import get_fiscal_year
from stock.doctype.purchase_receipt import test_purchase_receipt
@ -40,7 +39,11 @@ def load_data():
webnotes.insert({"doctype": "Customer", "customer_name": "West Wind Inc.",
"customer_type": "Company", "territory": "Default",
"customer_group": "Default Customer Group", "company": company,
"credit_days": 0, "credit_limit": 0})
"credit_days": 50, "credit_limit": 0})
webnotes.insert({"doctype": "Account", "account_name": "Sales",
"parent_account": "Income - %s" % abbr, "company": company,
"group_or_ledger": "Ledger"})
webnotes.insert({"doctype": "Account", "account_name": "Excise Duty",
"parent_account": "Tax Assets - %s" % abbr, "company": company,
@ -82,64 +85,67 @@ sales_invoice_doclist = [
"company": company, "fiscal_year": webnotes.conn.get_default("fiscal_year"),
"currency": webnotes.conn.get_default("currency"), "conversion_rate": 1.0,
"price_list_currency": webnotes.conn.get_default("currency"),
"plc_conversion_rate": 1.0,
"grand_total_export": 0
"plc_conversion_rate": 1.0, "net_total": 1250, "grand_total": 1627.05,
"grand_total_export": 1627.05
},
# items
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 100", "qty": 10, "export_rate": 50,
"parentfield": "sales_invoice_items",
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
"item_code": "Home Desktop 100", "qty": 10, "basic_rate": 50, "amount": 500,
"parentfield": "entries", "so_detail": None, "dn_detail": None,
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10}),
"income_account": "Sales - %s" % abbr,
"cost_center": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 200", "qty": 5, "export_rate": 150,
"parentfield": "sales_invoice_items",
"uom": "Nos"
"item_code": "Home Desktop 200", "qty": 5, "basic_rate": 150, "amount": 750,
"so_detail": None, "dn_detail": None,
"parentfield": "entries", "uom": "Nos", "income_account": "Sales - %s" % abbr,
"cost_center": "Default Cost Center - %s" % abbr
},
# taxes
{
"doctype": "Sales Taxes and Charges", "charge_type": "Actual",
"account_head": "Shipping Charges - %s" % abbr, "rate": 100,
"account_head": "Shipping Charges - %s" % abbr, "rate": 100, "tax_amount": 100,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Customs Duty - %s" % abbr, "rate": 10,
"account_head": "Customs Duty - %s" % abbr, "rate": 10, "tax_amount": 125,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Excise Duty - %s" % abbr, "rate": 12,
"account_head": "Excise Duty - %s" % abbr, "rate": 12, "tax_amount": 140,
"parentfield": "other_charges"
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Previous Row Amount",
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 3,
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 3, "tax_amount": 2.8,
"parentfield": "other_charges"
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Previous Row Amount",
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 3,
"parentfield": "other_charges"
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 3,
"tax_amount": 1.4, "parentfield": "other_charges"
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Previous Row Total",
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 5,
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 5, "tax_amount": 32.38,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5, "tax_amount": 156.25,
"parentfield": "other_charges"
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Previous Row Total",
"account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7,
"account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7, "tax_amount": -180.78,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
@ -149,23 +155,12 @@ class TestSalesInvoice(unittest.TestCase):
def setUp(self):
webnotes.conn.begin()
load_data()
webnotes.conn.set_value("Global Defaults", None, "automatic_inventory_accounting", 1)
#webnotes.conn.set_value("Global Defaults", None, "automatic_inventory_accounting", 1)
def test_sales_invoice(self):
from webnotes.model.doclist import DocList
doclist = [] + [d.copy() for d in sales_invoice_doclist]
controller = webnotes.insert(DocList(doclist))
controller.load_from_db()
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.save()
controller.submit()
controller.load_from_db()
dl = controller.doclist
@ -176,24 +171,24 @@ class TestSalesInvoice(unittest.TestCase):
expected_values = [
{
"item_code": "Home Desktop 100",
"ref_rate": 50,
"adj_rate": 0,
"export_amount": 500,
"base_ref_rate": 50,
# "ref_rate": 50,
# "adj_rate": 0,
# "export_amount": 500,
# "base_ref_rate": 50,
"basic_rate": 50,
"amount": 500
},
{
"item_code": "Home Desktop 200",
"ref_rate": 150,
"adj_rate": 0,
"export_amount": 750,
"base_ref_rate": 150,
# "ref_rate": 150,
# "adj_rate": 0,
# "export_amount": 750,
# "base_ref_rate": 150,
"basic_rate": 150,
"amount": 750
},
]
for i, item in enumerate(dl.get({"parentfield": "sales_invoice_items"})):
for i, item in enumerate(dl.get({"parentfield": "entries"})):
for key, val in expected_values[i].items():
self.assertEqual(item.fields.get(key), val)
@ -212,323 +207,342 @@ class TestSalesInvoice(unittest.TestCase):
# print tax.account_head, tax.tax_amount, tax.total
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
# self.assertEqual(tax.total, expected_values[i][2])
def test_inclusive_rate_validations(self):
doclist = [] + [d.copy() for d in sales_invoice_doclist]
doclist[1]["export_rate"] = 62.5
doclist[2]["export_rate"] = 191
for i in [3, 5, 6, 7, 8, 9]:
doclist[i]["included_in_print_rate"] = 1
expected_gl_entries = {
"West Wind Inc. - %s" % abbr : [1627.05, 0.0],
"Sales - %s" % abbr: [0.0, 1250.00],
"Shipping Charges - %s" % abbr: [0.0, 100],
"Customs Duty - %s" % abbr: [0, 125.0],
"Excise Duty - %s" % abbr: [0, 140],
"Education Cess - %s" % abbr: [0, 2.8],
"S&H Education Cess - %s" % abbr: [0, 1.4],
"CST - %s" % abbr: [0, 32.38],
"VAT - Test - %s" % abbr: [0, 156.25],
"adj_rate - %s" % abbr: [180.78, 0],
}
# tax type "Actual" cannot be inclusive
self.assertRaises(webnotes.ValidationError, webnotes.insert,
DocList(doclist))
gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type = %s and voucher_no = %s""",
(controller.doc.doctype, controller.doc.name), as_dict=1)
doclist[3]["included_in_print_rate"] = 0
# taxes above included type 'On Previous Row Total' should also be included
self.assertRaises(webnotes.ValidationError, webnotes.insert,
DocList(doclist))
def test_sales_invoice_with_inclusive_tax(self):
doclist = [
# parent
{
"doctype": "Sales Invoice",
"debit_to": "West Wind Inc. - %s" % abbr,
"customer_name": "West Wind Inc.",
"naming_series": "INV", "posting_date": nowdate(),
"company": company,
"fiscal_year": webnotes.conn.get_default("fiscal_year"),
"currency": webnotes.conn.get_default("currency"),
"price_list_currency": webnotes.conn.get_default("currency"),
"conversion_rate": 1.0, "plc_conversion_rate": 1.0,
"grand_total_export": 0
},
# items
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 100", "qty": 10, "export_rate": 62.503,
"parentfield": "sales_invoice_items",
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
},
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 200", "qty": 5, "export_rate": 190.6608,
"parentfield": "sales_invoice_items",
"uom": "Nos"
},
# taxes
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Excise Duty - %s" % abbr, "rate": 12,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Amount",
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 1,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Amount",
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 1,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Total",
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 3,
"parentfield": "other_charges", "included_in_print_rate": 1,
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Customs Duty - %s" % abbr, "rate": 10,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "Actual",
"account_head": "Shipping Charges - %s" % abbr, "rate": 100,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Total",
"account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
]
controller = webnotes.insert(DocList(doclist))
controller.load_from_db()
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.save()
controller.load_from_db()
dl = controller.doclist
# test item values calculation
expected_values = [
{
"item_code": "Home Desktop 100",
"ref_rate": 62.503,
"adj_rate": 0,
"export_amount": 625.03,
"base_ref_rate": 50,
"basic_rate": 50,
"amount": 500
},
{
"item_code": "Home Desktop 200",
"ref_rate": 190.6608,
"adj_rate": 0,
"export_amount": 953.3,
"base_ref_rate": 150,
"basic_rate": 150,
"amount": 750
},
]
for i, item in enumerate(dl.get({"parentfield": "sales_invoice_items"})):
for key, val in expected_values[i].items():
self.assertEqual(item.fields.get(key), val)
# test tax amounts and totals
expected_values = [
["Excise Duty - %s" % abbr, 140, 1390, 0, 1578.33],
["Education Cess - %s" % abbr, 2.8, 1392.8, 0, 1578.33],
["S&H Education Cess - %s" % abbr, 1.4, 1394.2, 0, 1578.33],
["CST - %s" % abbr, 27.88, 1422.08, 0, 1578.33],
["VAT - Test - %s" % abbr, 156.25, 1578.33, 0, 1578.33],
["Customs Duty - %s" % abbr, 125, 1703.33, 125, 1703.33],
["Shipping Charges - %s" % abbr, 100, 1803.33, 100, 1803.33],
["adj_rate - %s" % abbr, -180.33, 1623, -180.33, 1623],
]
for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# print tax.account_head, tax.tax_amount, tax.total, tax.tax_amount_print, \
# tax.total_print
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
# self.assertEqual(tax.tax_amount_print, expected_values[i][3])
self.assertEqual(tax.total_print, expected_values[i][4])
# test net total
self.assertEqual(dl[0].net_total, 1250)
self.assertEqual(dl[0].net_total_print, 1578.33)
# # test grand total
self.assertEqual(dl[0].grand_total, 1623)
self.assertEqual(dl[0].grand_total_export, 1623)
def test_usd_sales_invoice_with_inclusive_tax(self):
# print
# print "-"*80
# print "test_usd_sales_invoice_with_inclusive_tax"
# print "-"*80
# Note: below values were obtained through manual calculation and verified by test
doclist = [
# parent
{
"doctype": "Sales Invoice",
"debit_to": "West Wind Inc. - %s" % abbr,
"customer_name": "West Wind Inc.",
"naming_series": "INV", "posting_date": nowdate(),
"company": company,
"fiscal_year": webnotes.conn.get_default("fiscal_year"),
"currency": "USD", "price_list_currency": "USD", "conversion_rate": 50.0,
"plc_conversion_rate": 50.0, "grand_total_export": 0
},
# items
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 100", "qty": 10, "export_rate": 50,
"adj_rate": 10, "parentfield": "sales_invoice_items",
"uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
},
{
"doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
"item_code": "Home Desktop 200", "qty": 5, "export_rate": 150,
"adj_rate": 20, "parentfield": "sales_invoice_items",
"uom": "Nos"
},
# taxes
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Excise Duty - %s" % abbr, "rate": 12,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Amount",
"account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 1,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Amount",
"account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 1,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Total",
"account_head": "CST - %s" % abbr, "rate": 2, "row_id": 3,
"parentfield": "other_charges", "included_in_print_rate": 1,
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
"parentfield": "other_charges", "included_in_print_rate": 1
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
"account_head": "Customs Duty - %s" % abbr, "rate": 10,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges", "charge_type": "Actual",
"account_head": "Shipping Charges - %s" % abbr, "rate": 100,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
{
"doctype": "Sales Taxes and Charges",
"charge_type": "On Previous Row Total",
"account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7,
"parentfield": "other_charges",
"cost_center_other_charges": "Default Cost Center - %s" % abbr
},
]
controller = webnotes.insert(DocList(doclist))
controller.load_from_db()
from controllers.tax_controller import TaxController
tax_controller = TaxController(controller.doc, controller.doclist)
tax_controller.item_table_field = "entries"
tax_controller.calculate_taxes_and_totals()
controller.doc = tax_controller.doc
controller.doclist = tax_controller.doclist
controller.save()
controller.load_from_db()
dl = controller.doclist
# test item values calculation
expected_values = [
{
"item_code": "Home Desktop 100",
"ref_rate": 55.5556,
"adj_rate": 10,
"export_amount": 500,
"base_ref_rate": 2222.1156,
"basic_rate": 1999.904,
"amount": 19999.04
},
{
"item_code": "Home Desktop 200",
"ref_rate": 187.5,
"adj_rate": 20,
"export_amount": 750,
"base_ref_rate": 7375.664,
"basic_rate": 5900.5312,
"amount": 29502.66
},
]
for i, item in enumerate(dl.get({"parentfield": "sales_invoice_items"})):
for key, val in expected_values[i].items():
self.assertEqual(item.fields.get(key), val)
# test tax amounts and totals
expected_values = [
["Excise Duty - %s" % abbr, 5540.22, 55041.92, 0, 1250],
["Education Cess - %s" % abbr, 110.81, 55152.73, 0, 1250],
["S&H Education Cess - %s" % abbr, 55.4, 55208.13, 0, 1250],
["CST - %s" % abbr, 1104.16, 56312.29, 0, 1250],
["VAT - Test - %s" % abbr, 6187.71, 62500, 0, 1250],
["Customs Duty - %s" % abbr, 4950.17, 67450.17, 99.01, 1349.01],
["Shipping Charges - %s" % abbr, 5000, 72450.17, 100, 1449.01],
["adj_rate - %s" % abbr, -7245.01, 65205.16, -144.9, 1304.11],
]
for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# print tax.account_head, tax.tax_amount, tax.total, tax.tax_amount_print, \
# tax.total_print
self.assertEqual(tax.account_head, expected_values[i][0])
self.assertEqual(tax.tax_amount, expected_values[i][1])
self.assertEqual(tax.total, expected_values[i][2])
# self.assertEqual(tax.tax_amount_print, expected_values[i][3])
self.assertEqual(tax.total_print, expected_values[i][4])
# test net total
self.assertEqual(dl[0].net_total, 49501.7)
self.assertEqual(dl[0].net_total_print, 1250)
# # test grand total
self.assertEqual(dl[0].grand_total, 65205.16)
self.assertEqual(dl[0].grand_total_export, 1304.11)
for gle in gl_entries:
self.assertEqual([gle.debit, gle.credit], expected_gl_entries[gle.account])
#
# def test_inclusive_rate_validations(self):
# doclist = [] + [d.copy() for d in sales_invoice_doclist]
# doclist[1]["export_rate"] = 62.5
# doclist[2]["export_rate"] = 191
# for i in [3, 5, 6, 7, 8, 9]:
# doclist[i]["included_in_print_rate"] = 1
#
# # tax type "Actual" cannot be inclusive
# self.assertRaises(webnotes.ValidationError, webnotes.insert,
# DocList(doclist))
#
# doclist[3]["included_in_print_rate"] = 0
# # taxes above included type 'On Previous Row Total' should also be included
# self.assertRaises(webnotes.ValidationError, webnotes.insert,
# DocList(doclist))
#
# def test_sales_invoice_with_inclusive_tax(self):
# doclist = [
# # parent
# {
# "doctype": "Sales Invoice",
# "debit_to": "West Wind Inc. - %s" % abbr,
# "customer_name": "West Wind Inc.",
# "naming_series": "INV", "posting_date": nowdate(),
# "company": company,
# "fiscal_year": webnotes.conn.get_default("fiscal_year"),
# "currency": webnotes.conn.get_default("currency"),
# "price_list_currency": webnotes.conn.get_default("currency"),
# "conversion_rate": 1.0, "plc_conversion_rate": 1.0,
# "grand_total_export": 0
# },
# # items
# {
# "doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
# "item_code": "Home Desktop 100", "qty": 10, "export_rate": 62.503,
# "parentfield": "entries",
# "uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
# },
# {
# "doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
# "item_code": "Home Desktop 200", "qty": 5, "export_rate": 190.6608,
# "parentfield": "entries",
# "uom": "Nos"
# },
# # taxes
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "Excise Duty - %s" % abbr, "rate": 12,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Amount",
# "account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 1,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Amount",
# "account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 1,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Total",
# "account_head": "CST - %s" % abbr, "rate": 2, "row_id": 3,
# "parentfield": "other_charges", "included_in_print_rate": 1,
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "Customs Duty - %s" % abbr, "rate": 10,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "Actual",
# "account_head": "Shipping Charges - %s" % abbr, "rate": 100,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Total",
# "account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# ]
#
# controller = webnotes.insert(DocList(doclist))
# controller.load_from_db()
#
# from controllers.tax_controller import TaxController
# tax_controller = TaxController(controller.doc, controller.doclist)
# tax_controller.item_table_field = "entries"
# tax_controller.calculate_taxes_and_totals()
#
# controller.doc = tax_controller.doc
# controller.doclist = tax_controller.doclist
#
# controller.save()
# controller.load_from_db()
# dl = controller.doclist
#
# # test item values calculation
# expected_values = [
# {
# "item_code": "Home Desktop 100",
# "ref_rate": 62.503,
# "adj_rate": 0,
# "export_amount": 625.03,
# "base_ref_rate": 50,
# "basic_rate": 50,
# "amount": 500
# },
# {
# "item_code": "Home Desktop 200",
# "ref_rate": 190.6608,
# "adj_rate": 0,
# "export_amount": 953.3,
# "base_ref_rate": 150,
# "basic_rate": 150,
# "amount": 750
# },
# ]
# for i, item in enumerate(dl.get({"parentfield": "entries"})):
# for key, val in expected_values[i].items():
# self.assertEqual(item.fields.get(key), val)
#
# # test tax amounts and totals
# expected_values = [
# ["Excise Duty - %s" % abbr, 140, 1390, 0, 1578.33],
# ["Education Cess - %s" % abbr, 2.8, 1392.8, 0, 1578.33],
# ["S&H Education Cess - %s" % abbr, 1.4, 1394.2, 0, 1578.33],
# ["CST - %s" % abbr, 27.88, 1422.08, 0, 1578.33],
# ["VAT - Test - %s" % abbr, 156.25, 1578.33, 0, 1578.33],
# ["Customs Duty - %s" % abbr, 125, 1703.33, 125, 1703.33],
# ["Shipping Charges - %s" % abbr, 100, 1803.33, 100, 1803.33],
# ["adj_rate - %s" % abbr, -180.33, 1623, -180.33, 1623],
# ]
# for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# # print tax.account_head, tax.tax_amount, tax.total, tax.tax_amount_print, \
# # tax.total_print
# self.assertEqual(tax.account_head, expected_values[i][0])
# self.assertEqual(tax.tax_amount, expected_values[i][1])
# self.assertEqual(tax.total, expected_values[i][2])
# # self.assertEqual(tax.tax_amount_print, expected_values[i][3])
# self.assertEqual(tax.total_print, expected_values[i][4])
#
# # test net total
# self.assertEqual(dl[0].net_total, 1250)
#
# # # test grand total
# self.assertEqual(dl[0].grand_total, 1623)
# self.assertEqual(dl[0].grand_total_export, 1623)
#
# def test_usd_sales_invoice_with_inclusive_tax(self):
# # print
# # print "-"*80
# # print "test_usd_sales_invoice_with_inclusive_tax"
# # print "-"*80
#
# # Note: below values were obtained through manual calculation and verified by test
#
# doclist = [
# # parent
# {
# "doctype": "Sales Invoice",
# "debit_to": "West Wind Inc. - %s" % abbr,
# "customer_name": "West Wind Inc.",
# "naming_series": "INV", "posting_date": nowdate(),
# "company": company,
# "fiscal_year": webnotes.conn.get_default("fiscal_year"),
# "currency": "USD", "price_list_currency": "USD", "conversion_rate": 50.0,
# "plc_conversion_rate": 50.0, "grand_total_export": 0
# },
# # items
# {
# "doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
# "item_code": "Home Desktop 100", "qty": 10, "export_rate": 50,
# "adj_rate": 10, "parentfield": "entries",
# "uom": "Nos", "item_tax_rate": json.dumps({"Excise Duty - %s" % abbr: 10})
# },
# {
# "doctype": "Sales Invoice Item", "warehouse": "Default Warehouse",
# "item_code": "Home Desktop 200", "qty": 5, "export_rate": 150,
# "adj_rate": 20, "parentfield": "entries",
# "uom": "Nos"
# },
# # taxes
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "Excise Duty - %s" % abbr, "rate": 12,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Amount",
# "account_head": "Education Cess - %s" % abbr, "rate": 2, "row_id": 1,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Amount",
# "account_head": "S&H Education Cess - %s" % abbr, "rate": 1, "row_id": 1,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Total",
# "account_head": "CST - %s" % abbr, "rate": 2, "row_id": 3,
# "parentfield": "other_charges", "included_in_print_rate": 1,
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "VAT - Test - %s" % abbr, "rate": 12.5,
# "parentfield": "other_charges", "included_in_print_rate": 1
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "On Net Total",
# "account_head": "Customs Duty - %s" % abbr, "rate": 10,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges", "charge_type": "Actual",
# "account_head": "Shipping Charges - %s" % abbr, "rate": 100,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# {
# "doctype": "Sales Taxes and Charges",
# "charge_type": "On Previous Row Total",
# "account_head": "adj_rate - %s" % abbr, "rate": -10, "row_id": 7,
# "parentfield": "other_charges",
# "cost_center_other_charges": "Default Cost Center - %s" % abbr
# },
# ]
#
# controller = webnotes.insert(DocList(doclist))
# controller.load_from_db()
#
# from controllers.tax_controller import TaxController
# tax_controller = TaxController(controller.doc, controller.doclist)
# tax_controller.item_table_field = "entries"
# tax_controller.calculate_taxes_and_totals()
#
# controller.doc = tax_controller.doc
# controller.doclist = tax_controller.doclist
#
# controller.save()
# controller.load_from_db()
# dl = controller.doclist
#
# # test item values calculation
# expected_values = [
# {
# "item_code": "Home Desktop 100",
# "ref_rate": 55.5556,
# "adj_rate": 10,
# "export_amount": 500,
# "base_ref_rate": 2222.1156,
# "basic_rate": 1999.904,
# "amount": 19999.04
# },
# {
# "item_code": "Home Desktop 200",
# "ref_rate": 187.5,
# "adj_rate": 20,
# "export_amount": 750,
# "base_ref_rate": 7375.664,
# "basic_rate": 5900.5312,
# "amount": 29502.66
# },
# ]
# for i, item in enumerate(dl.get({"parentfield": "entries"})):
# for key, val in expected_values[i].items():
# self.assertEqual(item.fields.get(key), val)
#
# # test tax amounts and totals
# expected_values = [
# ["Excise Duty - %s" % abbr, 5540.22, 55041.92, 0, 1250],
# ["Education Cess - %s" % abbr, 110.81, 55152.73, 0, 1250],
# ["S&H Education Cess - %s" % abbr, 55.4, 55208.13, 0, 1250],
# ["CST - %s" % abbr, 1104.16, 56312.29, 0, 1250],
# ["VAT - Test - %s" % abbr, 6187.71, 62500, 0, 1250],
# ["Customs Duty - %s" % abbr, 4950.17, 67450.17, 99.01, 1349.01],
# ["Shipping Charges - %s" % abbr, 5000, 72450.17, 100, 1449.01],
# ["adj_rate - %s" % abbr, -7245.01, 65205.16, -144.9, 1304.11],
# ]
# for i, tax in enumerate(dl.get({"parentfield": "other_charges"})):
# # print tax.account_head, tax.tax_amount, tax.total, tax.tax_amount_print, \
# # tax.total_print
# self.assertEqual(tax.account_head, expected_values[i][0])
# self.assertEqual(tax.tax_amount, expected_values[i][1])
# self.assertEqual(tax.total, expected_values[i][2])
# # self.assertEqual(tax.tax_amount_print, expected_values[i][3])
# self.assertEqual(tax.total_print, expected_values[i][4])
#
# # test net total
# self.assertEqual(dl[0].net_total, 49501.7)
#
# # # test grand total
# self.assertEqual(dl[0].grand_total, 65205.16)
# self.assertEqual(dl[0].grand_total_export, 1304.11)
#
def tearDown(self):
webnotes.conn.rollback()

109
accounts/general_ledger.py Normal file
View File

@ -0,0 +1,109 @@
# ERPNext - web based ERP (http://erpnext.com)
# Copyright (C) 2012 Web Notes Technologies Pvt Ltd
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from __future__ import unicode_literals
import webnotes
from webnotes.utils import flt, cstr
from webnotes.model.doc import Document
def make_gl_entries(gl_map, cancel=False, adv_adj=False, merge_entries=True,
update_outstanding='Yes'):
if merge_entries:
gl_map = merge_similar_entries(gl_map)
check_budget(gl_map, cancel)
save_entries(gl_map, cancel, adv_adj, update_outstanding)
if cancel:
set_as_cancel(gl_map[0]["voucher_type"], gl_map[0]["voucher_no"])
def merge_similar_entries(gl_map):
merged_gl_map = []
for entry in gl_map:
# if there is already an entry in this account then just add it
# to that entry
same_head = check_if_in_list(entry, merged_gl_map)
if same_head:
same_head['debit'] = flt(same_head['debit']) + flt(entry['debit'])
same_head['credit'] = flt(same_head['credit']) + flt(entry['credit'])
else:
merged_gl_map.append(entry)
return merged_gl_map
def check_if_in_list(gle, gl_mqp):
for e in gl_mqp:
if e['account'] == gle['account'] and \
cstr(e.get('against_voucher'))==cstr(gle.get('against_voucher')) \
and cstr(e.get('against_voucher_type')) == \
cstr(gle.get('against_voucher_type')) \
and cstr(e.get('cost_center')) == cstr(gle.get('cost_center')):
return e
def check_budget(gl_map, cancel):
for gle in gl_map:
if gle.get('cost_center'):
#check budget only if account is expense account
acc_details = webnotes.conn.get_value("Account", gle['account'],
['is_pl_account', 'debit_or_credit'])
if acc_details[0]=="Yes" and acc_details[1]=="Debit":
webnotes.get_obj('Budget Control').check_budget(gle, cancel)
def save_entries(gl_map, cancel, adv_adj, update_outstanding):
total_debit = total_credit = 0.0
def _swap(gle):
gle.debit, gle.credit = abs(flt(gle.credit)), abs(flt(gle.debit))
for entry in gl_map:
gle = Document('GL Entry', fielddata=entry)
# toggle debit, credit if negative entry
if flt(gle.debit) < 0 or flt(gle.credit) < 0:
_swap(gle)
# toggled debit/credit in two separate condition because
# both should be executed at the
# time of cancellation when there is negative amount (tax discount)
if cancel:
_swap(gle)
gle_obj = webnotes.get_obj(doc=gle)
# validate except on_cancel
if not cancel:
gle_obj.validate()
# save
gle.save(1)
gle_obj.on_update(adv_adj, cancel, update_outstanding)
# update total debit / credit
total_debit += flt(gle.debit)
total_credit += flt(gle.credit)
# print gle.account, gle.debit, gle.credit, total_debit, total_credit
if not cancel:
validate_total_debit_credit(total_debit, total_credit)
def validate_total_debit_credit(total_debit, total_credit):
if abs(total_debit - total_credit) > 0.005:
webnotes.msgprint("""Debit and Credit not equal for
this voucher: Diff (Debit) is %s""" %
(total_debit - total_credit), raise_exception=1)
def set_as_cancel(voucher_type, voucher_no):
webnotes.conn.sql("""update `tabGL Entry` set is_cancelled='Yes'
where voucher_type=%s and voucher_no=%s""", (voucher_type, voucher_no))

28
buying/doctype/supplier/supplier.py
View File

@ -17,9 +17,9 @@
from __future__ import unicode_literals
import webnotes
from webnotes.utils import cstr, get_defaults
from webnotes.utils import cstr, cint, get_defaults
from webnotes.model.code import get_obj
from webnotes import msgprint
from webnotes import msgprint, _
from webnotes.model.doc import make_autoname
sql = webnotes.conn.sql
@ -35,28 +35,18 @@ class DocType(TransactionBase):
self.add_communication_list()
def autoname(self):
#get default naming conventional from control panel
supp_master_name = get_defaults()['supp_master_name']
if supp_master_name == 'Supplier Name':
# filter out bad characters in name
#supp = self.doc.supplier_name.replace('&','and').replace('.','').replace("'",'').replace('"','').replace(',','').replace('`','')
supp = self.doc.supplier_name
cust = sql("select name from `tabCustomer` where name = '%s'" % (supp))
cust = cust and cust[0][0] or ''
if cust:
msgprint("You already have a Customer with same name")
raise Exception
self.doc.name = supp
if webnotes.conn.exists("Customer", self.doc.supplier_name):
webnotes.msgprint(_("A Customer exists with same name"), raise_exception=1)
self.doc.name = self.doc.supplier_name
else:
self.doc.name = make_autoname(self.doc.naming_series+'.#####')
self.doc.name = make_autoname(self.doc.naming_series + '.#####')
def update_credit_days_limit(self):
sql("update tabAccount set credit_days = '%s' where name = '%s'" % (self.doc.credit_days, self.doc.name + " - " + self.get_company_abbr()))
sql("""update tabAccount set credit_days = %s where name = %s""",
(cint(self.doc.credit_days), self.doc.name + " - " + self.get_company_abbr()))
def on_update(self):
if not self.doc.naming_series:

149
controllers/accounts_controller.py
View File

@ -16,155 +16,10 @@
from __future__ import unicode_literals
import webnotes
from webnotes.utils import flt, cstr
from webnotes.model.doc import Document
from webnotes.model.controller import DocListController
from utilities.transaction_base import TransactionBase
class AccountsController(DocListController):
def make_gl_entries(self, cancel=False, adv_adj=False, mapper=None, merge_entries=True,
update_outstanding='Yes', gl_map=None):
self.entries = []
self.merged_entries = []
self.total_debit = self.total_credit = 0.0
if gl_map:
self.entries = gl_map
else:
self.make_gl_map(mapper)
self.merge_similar_entries(merge_entries)
self.check_budget(cancel)
self.save_entries(cancel, adv_adj, update_outstanding)
if cancel:
self.set_as_cancel()
else:
self.validate_total_debit_credit()
def make_gl_map(self, mapper):
def _gl_map(parent, d, entry_map):
if self.get_val(entry_map['account'], d, parent) \
and (self.get_val(entry_map['debit'], d, parent)
or self.get_val(entry_map['credit'], d, parent)):
gl_dict = {}
for k in entry_map:
gl_dict[k] = self.get_val(entry_map[k], d, parent)
self.entries.append(gl_dict)
# get entries
gl_fields = ", ".join([d.fieldname for d in \
webnotes.model.doctype.get("GL Mapper Detail").get({
"doctype": "DocField", "parent": "GL Mapper Detail"})])
entry_map_list = webnotes.conn.sql("""select %s from `tabGL Mapper Detail`
where parent = %s""" % (gl_fields, '%s'), mapper or self.doc.doctype, as_dict=1)
for entry_map in entry_map_list:
table_field = entry_map.get("table_field")
# table_field does not exist in gl entry table
entry_map.pop("table_field")
if table_field:
for d in self.doclist.get({"parentfield": table_field}):
# taxes_and_charges is the table of other charges in purchase cycle
if table_field == "taxes_and_charges" and \
d.fields.get("category") == "Valuation":
# don't create gl entry for only valuation type charges
continue
_gl_map(self.doc, d, entry_map)
else:
_gl_map(None, self.doc, entry_map)
def get_val(self, src, d, parent=None):
"""Get field values from the voucher"""
if not src:
return None
if src.startswith('parent:'):
return parent.fields[src.split(':')[1]]
elif src.startswith('value:'):
return eval(src.split(':')[1])
elif src:
return d.fields.get(src)
def merge_similar_entries(self, merge_entries):
if merge_entries:
for entry in self.entries:
# if there is already an entry in this account then just add it
# to that entry
same_head = self.check_if_in_list(entry)
if same_head:
same_head['debit'] = flt(same_head['debit']) + flt(entry['debit'])
same_head['credit'] = flt(same_head['credit']) + flt(entry['credit'])
else:
self.merged_entries.append(entry)
else:
self.merged_entries = self.entries
def save_entries(self, cancel, adv_adj, update_outstanding):
def _swap(gle):
gle.debit, gle.credit = abs(flt(gle.credit)), abs(flt(gle.debit))
for entry in self.merged_entries:
gle = Document('GL Entry', fielddata=entry)
# toggle debit, credit if negative entry
if flt(gle.debit) < 0 or flt(gle.credit) < 0:
_swap(gle)
# toggled debit/credit in two separate condition because
# both should be executed at the
# time of cancellation when there is negative amount (tax discount)
if cancel:
_swap(gle)
gle_obj = webnotes.get_obj(doc=gle)
# validate except on_cancel
if not cancel:
gle_obj.validate()
# save
gle.save(1)
gle_obj.on_update(adv_adj, cancel, update_outstanding)
# update total debit / credit
self.total_debit += flt(gle.debit)
self.total_credit += flt(gle.credit)
def check_if_in_list(self, gle):
for e in self.merged_entries:
if e['account'] == gle['account'] and \
cstr(e.get('against_voucher'))==cstr(gle.get('against_voucher')) \
and cstr(e.get('against_voucher_type')) == \
cstr(gle.get('against_voucher_type')) \
and cstr(e.get('cost_center')) == cstr(gle.get('cost_center')):
return e
def validate_total_debit_credit(self):
if abs(self.total_debit - self.total_credit) > 0.005:
webnotes.msgprint("""Debit and Credit not equal for
this voucher: Diff (Debit) is %s""" %
(self.total_debit - self.total_credit), raise_exception=1)
def set_as_cancel(self):
webnotes.conn.sql("""update `tabGL Entry` set is_cancelled='Yes'
where voucher_type=%s and voucher_no=%s""", (self.doc.doctype, self.doc.name))
def check_budget(self, cancel):
for gle in self.merged_entries:
if gle.get('cost_center'):
#check budget only if account is expense account
acc_details = webnotes.conn.get_value("Account", gle['account'],
['is_pl_account', 'debit_or_credit'])
if acc_details[0]=="Yes" and acc_details[1]=="Debit":
webnotes.get_obj('Budget Control').check_budget(gle, cancel)
class AccountsController(TransactionBase):
def get_gl_dict(self, args, cancel):
"""this method populates the common properties of a gl entry record"""
gl_dict = {

5
controllers/buying_controller.py
View File

@ -22,8 +22,9 @@ from webnotes.utils import flt
from buying.utils import get_item_details
from setup.utils import get_company_currency
from utilities.transaction_base import TransactionBase
class BuyingController(TransactionBase):
from controllers.accounts_controller import AccountsController
class BuyingController(AccountsController):
def validate(self):
if self.meta.get_field("currency"):
self.company_currency = get_company_currency(self.doc.company)

5
controllers/selling_controller.py
View File

@ -18,8 +18,9 @@ from __future__ import unicode_literals
import webnotes
from setup.utils import get_company_currency
from utilities.transaction_base import TransactionBase
class SellingController(TransactionBase):
from controllers.accounts_controller import AccountsController
class SellingController(AccountsController):
def validate(self):
self.set_total_in_words()

16
selling/doctype/customer/customer.py
View File

@ -20,7 +20,7 @@ import webnotes
from webnotes.utils import cstr, get_defaults
from webnotes.model.doc import Document, make_autoname
from webnotes.model.code import get_obj
from webnotes import msgprint
from webnotes import msgprint, _
sql = webnotes.conn.sql
@ -37,17 +37,9 @@ class DocType(TransactionBase):
def autoname(self):
cust_master_name = get_defaults().get('cust_master_name')
if cust_master_name == 'Customer Name':
# filter out bad characters in name
#cust = self.doc.customer_name.replace('&','and').replace('.','').replace("'",'').replace('"','').replace(',','').replace('`','')
cust = self.doc.customer_name
supp = sql("select name from `tabSupplier` where name = %s", (cust))
supp = supp and supp[0][0] or ''
if supp:
msgprint("You already have a Supplier with same name")
raise Exception("You already have a Supplier with same name")
else:
self.doc.name = cust
if webnotes.conn.exists("Supplier", self.doc.customer_name):
msgprint(_("A Supplier exists with same name"), raise_exception=1)
self.doc.name = self.doc.customer_name
else:
self.doc.name = make_autoname(self.doc.naming_series+'.#####')

24
stock/doctype/purchase_receipt/test_purchase_receipt.py
View File

@ -19,8 +19,8 @@ from __future__ import unicode_literals
import unittest
import webnotes
import webnotes.model
from webnotes.model.doclist import DocList
from webnotes.utils import nowdate
from accounts.utils import get_fiscal_year
company = webnotes.conn.get_default("company")
abbr = webnotes.conn.get_value("Company", company, "abbr")
@ -53,7 +53,7 @@ def load_data():
# create default cost center if not exists
if not webnotes.conn.exists("Cost Center", "Default Cost Center - %s" % abbr):
dl = webnotes.insert({"doctype": "Cost Center", "group_or_ledger": "Ledger",
webnotes.insert({"doctype": "Cost Center", "group_or_ledger": "Ledger",
"cost_center_name": "Default Cost Center",
"parent_cost_center": "Root - %s" % abbr,
"company_name": company, "company_abbr": abbr})
@ -75,15 +75,14 @@ def load_data():
"group_or_ledger": "Ledger"})
# create BOM
webnotes.insert([
{"doctype": "BOM", "item": "Nebula 7", "quantity": 1,
"is_active": "Yes", "is_default": 1, "uom": "Nos"},
{"doctype": "BOM Operation", "operation_no": 1, "parentfield": "bom_operations",
"opn_description": "Development"},
{"doctype": "BOM Item", "item_code": "Android Jack D", "operation_no": 1,
"qty": 5, "rate": 20, "amount": 100, "stock_uom": "Nos",
"parentfield": "bom_materials"}
])
# webnotes.insert(DocList([
# {"doctype": "BOM", "item": "Nebula 7", "quantity": 1,
# "is_active": "Yes", "is_default": 1, "uom": "Nos"},
# {"doctype": "BOM Operation", "operation_no": 1, "parentfield": "bom_operations",
# "opn_description": "Development"},
# {"doctype": "BOM Item", "item_code": "Android Jack D", "operation_no": 1, "qty": 5,
# "rate": 20, "amount": 100, "stock_uom": "Nos", "parentfield": "bom_materials"}
# ]))
base_purchase_receipt = [
@ -139,8 +138,6 @@ def insert_accounts():
acc_name = "%s - %s" % (acc['account_name'], d['abbr'])
if not webnotes.conn.exists('Account', acc_name):
webnotes.insert(acc)
else:
print "Account %s already exists" % acc_name
def make_account_dict(account, parent, company_detail, group_or_ledger):
return {
@ -166,7 +163,6 @@ class TestPurchaseReceipt(unittest.TestCase):
def run_purchase_receipt_test(self, purchase_receipt, debit_account,
credit_account, stock_value):
from webnotes.model.doclist import DocList
dl = webnotes.insert(DocList(purchase_receipt))
from controllers.tax_controller import TaxController

5
utilities/transaction_base.py
View File

@ -16,16 +16,13 @@
from __future__ import unicode_literals
import webnotes
from webnotes.utils import load_json, cstr, flt, get_defaults
from webnotes.utils import load_json, cstr, flt
from webnotes.model.doc import addchild
from webnotes.model.wrapper import copy_doclist
from webnotes.model.controller import DocListController
class TransactionBase(DocListController):
# Get Customer Default Primary Address - first load
# -----------------------
def get_default_customer_address(self, args=''):
address_text, address_name = self.get_address_text(customer=self.doc.customer)
self.doc.customer_address = address_name or ''