Added test cases for asset accounting, asset value adjustment (#14572)

* Added test cases for asset accounting, asset value adjustment

* Accounting entry for the asset created manually

* Added asset movement test cases and validation

* Added validation to make asset from purchase receupt, invoice only
This commit is contained in:
rohitwaghchaure 2018-06-22 15:40:59 +05:30 committed by Nabin Hait
parent ce26610d39
commit d3fb0fbb20
14 changed files with 568 additions and 105 deletions

View File

@ -58,7 +58,7 @@ frappe.ui.form.on('Asset', {
});
}
if (frm.doc.purchase_receipt) {
if (frm.doc.purchase_receipt || !frm.doc.is_existing_asset) {
frm.add_custom_button("General Ledger", function() {
frappe.route_options = {
"voucher_no": frm.doc.name,
@ -89,6 +89,10 @@ frappe.ui.form.on('Asset', {
frm.page.set_inner_btn_group_as_primary(__("Make"));
frm.trigger("setup_chart");
}
if (frm.doc.docstatus == 0) {
frm.toggle_reqd("finance_books", frm.doc.calculate_depreciation);
}
},
setup_chart: function(frm) {
@ -261,6 +265,8 @@ frappe.ui.form.on('Asset', {
})
}
})
frm.toggle_reqd("finance_books", frm.doc.calculate_depreciation);
}
});

View File

@ -1628,7 +1628,7 @@
"in_standard_filter": 0,
"label": "Booked Fixed Asset",
"length": 0,
"no_copy": 0,
"no_copy": 1,
"permlevel": 0,
"precision": "",
"print_hide": 0,
@ -1771,6 +1771,39 @@
"translatable": 0,
"unique": 0
},
{
"allow_bulk_edit": 0,
"allow_in_quick_entry": 0,
"allow_on_submit": 0,
"bold": 0,
"collapsible": 0,
"columns": 0,
"fieldname": "default_finance_book",
"fieldtype": "Read Only",
"hidden": 1,
"ignore_user_permissions": 0,
"ignore_xss_filter": 0,
"in_filter": 0,
"in_global_search": 0,
"in_list_view": 0,
"in_standard_filter": 0,
"label": "Default Finance Book",
"length": 0,
"no_copy": 0,
"options": "company.default_finance_book",
"permlevel": 0,
"precision": "",
"print_hide": 0,
"print_hide_if_no_value": 0,
"read_only": 0,
"remember_last_selected_value": 0,
"report_hide": 0,
"reqd": 0,
"search_index": 0,
"set_only_once": 0,
"translatable": 0,
"unique": 0
},
{
"allow_bulk_edit": 0,
"allow_in_quick_entry": 0,
@ -1815,7 +1848,7 @@
"issingle": 0,
"istable": 0,
"max_attachments": 0,
"modified": "2018-06-15 13:56:35.211418",
"modified": "2018-06-18 19:20:27.668745",
"modified_by": "Administrator",
"module": "Assets",
"name": "Asset",

View File

@ -3,7 +3,7 @@
# For license information, please see license.txt
from __future__ import unicode_literals
import frappe
import frappe, erpnext
from frappe import _
from frappe.utils import flt, add_months, cint, nowdate, getdate, today, date_diff
from frappe.model.document import Document
@ -16,19 +16,19 @@ from erpnext.controllers.accounts_controller import AccountsController
class Asset(AccountsController):
def validate(self):
self.status = self.get_status()
self.validate_asset_values()
self.validate_item()
self.set_missing_values()
self.validate_asset_values()
if self.calculate_depreciation:
self.make_depreciation_schedule()
self.set_accumulated_depreciation()
get_depreciation_accounts(self)
else:
self.finance_books = []
if self.get("schedules"):
self.validate_expected_value_after_useful_life()
self.status = self.get_status()
def on_submit(self):
self.validate_in_use_date()
self.set_status()
@ -71,8 +71,19 @@ class Asset(AccountsController):
if not flt(self.gross_purchase_amount):
frappe.throw(_("Gross Purchase Amount is mandatory"), frappe.MandatoryError)
if not self.is_existing_asset and not (self.purchase_receipt or self.purchase_invoice):
frappe.throw(_("Please create purchase receipt or purchase invoice for the item {0}").
format(self.item_code))
if (not self.purchase_receipt and self.purchase_invoice
and not frappe.db.get_value('Purchase Invoice', self.purchase_invoice, 'update_stock')):
frappe.throw(_("Update stock must be enable for the purchase invoice {0}").
format(self.purchase_invoice))
if not self.calculate_depreciation:
return
elif not self.finance_books:
frappe.throw(_("Enter depreciation details"))
if self.available_for_use_date and getdate(self.available_for_use_date) < getdate(nowdate()):
frappe.throw(_("Available-for-use Date is entered as past date"))
@ -303,23 +314,32 @@ class Asset(AccountsController):
status = "Draft"
elif self.docstatus == 1:
status = "Submitted"
expected_value_after_useful_life = flt(sum([d.expected_value_after_useful_life
for d in self.get('finance_books')]))
value_after_depreciation = flt(sum([d.value_after_depreciation
for d in self.get('finance_books')]))
idx = self.get_default_finance_book_idx() or 0
expected_value_after_useful_life = self.finance_books[idx].expected_value_after_useful_life
value_after_depreciation = self.finance_books[idx].value_after_depreciation
if self.journal_entry_for_scrap:
status = "Scrapped"
elif self.finance_books:
if flt(value_after_depreciation) <= expected_value_after_useful_life:
status = "Fully Depreciated"
elif flt(self.value_after_depreciation) < flt(self.gross_purchase_amount):
elif flt(value_after_depreciation) < flt(self.gross_purchase_amount):
status = 'Partially Depreciated'
elif self.docstatus == 2:
status = "Cancelled"
return status
def get_default_finance_book_idx(self):
if not self.get('default_finance_book') and self.company:
self.default_finance_book = erpnext.get_default_finance_book(self.company)
if self.get('default_finance_book'):
for d in self.get('finance_books'):
if d.finance_books == self.default_finance_book:
return cint(d.idx) - 1
def update_stock_movement(self):
asset_movement = frappe.db.get_value('Asset Movement',
{'asset': self.name, 'reference_name': self.purchase_receipt, 'docstatus': 0}, 'name')
@ -329,17 +349,17 @@ class Asset(AccountsController):
doc.submit()
def make_gl_entries(self):
if self.purchase_receipt and self.purchase_receipt_amount and self.available_for_use_date <= nowdate():
from erpnext.accounts.general_ledger import make_gl_entries
gl_entries = []
gl_entries = []
if ((self.purchase_receipt or (self.purchase_invoice and
frappe.db.get_value('Purchase Invoice', self.purchase_invoice, 'update_stock')))
and self.purchase_receipt_amount and self.available_for_use_date <= nowdate()):
fixed_aseet_account = get_asset_category_account(self.name, 'fixed_asset_account',
asset_category = self.asset_category, company = self.company)
cwip_account = get_asset_account("capital_work_in_progress_account",
self.name, self.asset_category, self.company)
fixed_aseet_account = get_asset_category_account(self.name, 'fixed_asset_account',
asset_category = self.asset_category, company = self.company)
gl_entries.append(self.get_gl_dict({
"account": cwip_account,
"against": fixed_aseet_account,
@ -358,6 +378,9 @@ class Asset(AccountsController):
"debit_in_account_currency": self.purchase_receipt_amount
}))
if gl_entries:
from erpnext.accounts.general_ledger import make_gl_entries
make_gl_entries(gl_entries)
self.db_set('booked_fixed_asset', 1)

View File

@ -5,19 +5,38 @@ from __future__ import unicode_literals
import frappe
import unittest
from frappe.utils import cstr, nowdate, getdate, flt
from frappe.utils import cstr, nowdate, getdate, flt, get_last_day, add_days, add_months
from erpnext.assets.doctype.asset.depreciation import post_depreciation_entries, scrap_asset, restore_asset
from erpnext.assets.doctype.asset.asset import make_sales_invoice, make_purchase_invoice
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
class TestAsset(unittest.TestCase):
def setUp(self):
set_depreciation_settings_in_company()
remove_prorated_depreciation_schedule()
create_asset()
create_asset_data()
frappe.db.sql("delete from `tabTax Rule`")
def test_purchase_asset(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset.available_for_use_date = purchase_date
asset.purchase_date = purchase_date
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset.submit()
pi = make_purchase_invoice(asset.name, asset.item_code, asset.gross_purchase_amount,
@ -27,7 +46,7 @@ class TestAsset(unittest.TestCase):
pi.submit()
asset.load_from_db()
self.assertEqual(asset.supplier, "_Test Supplier")
self.assertEqual(asset.purchase_date, getdate("2015-01-01"))
self.assertEqual(asset.purchase_date, getdate(purchase_date))
self.assertEqual(asset.purchase_invoice, pi.name)
expected_gle = (
@ -51,8 +70,15 @@ class TestAsset(unittest.TestCase):
def test_schedule_for_straight_line_method(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"next_depreciation_date": "2020-12-31",
@ -61,7 +87,7 @@ class TestAsset(unittest.TestCase):
"frequency_of_depreciation": 10,
"depreciation_start_date": "2020-06-06"
})
asset.insert()
asset.save()
self.assertEqual(asset.status, "Draft")
expected_schedules = [
["2020-06-06", 163.93, 163.93],
@ -75,8 +101,8 @@ class TestAsset(unittest.TestCase):
self.assertEqual(schedules, expected_schedules)
def test_schedule_for_straight_line_method_for_existing_asset(self):
create_asset(is_existing_asset=1)
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
asset.is_existing_asset = 1
asset.calculate_depreciation = 1
asset.number_of_depreciations_booked = 1
asset.opening_accumulated_depreciation = 40000
@ -101,8 +127,14 @@ class TestAsset(unittest.TestCase):
self.assertEqual(schedules, expected_schedules)
def test_schedule_for_double_declining_method(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"next_depreciation_date": "2020-12-31",
@ -127,6 +159,7 @@ class TestAsset(unittest.TestCase):
self.assertEqual(schedules, expected_schedules)
def test_schedule_for_double_declining_method_for_existing_asset(self):
create_asset(is_existing_asset = 1)
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
asset.calculate_depreciation = 1
asset.is_existing_asset = 1
@ -158,8 +191,13 @@ class TestAsset(unittest.TestCase):
def test_schedule_for_prorated_straight_line_method(self):
set_prorated_depreciation_schedule()
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.purchase_date = '2020-06-06'
asset.is_existing_asset = 0
asset.available_for_use_date = "2020-01-30"
asset.append("finance_books", {
@ -188,8 +226,13 @@ class TestAsset(unittest.TestCase):
remove_prorated_depreciation_schedule()
def test_depreciation(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.purchase_date = '2020-06-06'
asset.available_for_use_date = "2020-01-30"
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
@ -201,7 +244,7 @@ class TestAsset(unittest.TestCase):
asset.insert()
asset.submit()
asset.load_from_db()
self.assertEqual(asset.status, "Partially Depreciated")
self.assertEqual(asset.status, "Submitted")
frappe.db.set_value("Company", "_Test Company", "series_for_depreciation_entry", "DEPR-")
post_depreciation_entries(date="2021-01-01")
@ -223,8 +266,14 @@ class TestAsset(unittest.TestCase):
self.assertEqual(asset.get("value_after_depreciation"), 0)
def test_depreciation_entry_cancellation(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
@ -248,8 +297,14 @@ class TestAsset(unittest.TestCase):
self.assertFalse(depr_entry)
def test_scrap_asset(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
@ -284,8 +339,14 @@ class TestAsset(unittest.TestCase):
self.assertEqual(asset.status, "Partially Depreciated")
def test_asset_sale(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
@ -325,8 +386,14 @@ class TestAsset(unittest.TestCase):
self.assertEqual(frappe.db.get_value("Asset", asset.name, "status"), "Partially Depreciated")
def test_asset_expected_value_after_useful_life(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"depreciation_method": "Straight Line",
@ -343,16 +410,91 @@ class TestAsset(unittest.TestCase):
self.assertTrue(asset.finance_books[0].expected_value_after_useful_life >= asset_value_after_full_schedule)
def tearDown(self):
asset = frappe.get_doc("Asset", {"asset_name": "Macbook Pro 1"})
if asset.docstatus == 1 and asset.status not in ("Scrapped", "Sold", "Draft", "Cancelled"):
asset.cancel()
def test_cwip_accounting(self):
from erpnext.stock.doctype.purchase_receipt.purchase_receipt import (
make_purchase_invoice as make_purchase_invoice_from_pr)
self.assertEqual(frappe.db.get_value("Asset", {"asset_name": "Macbook Pro 1"}, "status"), "Cancelled")
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=5000, do_not_submit=True, location="Test Location")
frappe.delete_doc("Asset", {"asset_name": "Macbook Pro 1"})
pr.set('taxes', [{
'category': 'Total',
'add_deduct_tax': 'Add',
'charge_type': 'On Net Total',
'account_head': '_Test Account Service Tax - _TC',
'description': '_Test Account Service Tax',
'cost_center': 'Main - _TC',
'rate': 5.0
}, {
'category': 'Valuation and Total',
'add_deduct_tax': 'Add',
'charge_type': 'On Net Total',
'account_head': '_Test Account Shipping Charges - _TC',
'description': '_Test Account Shipping Charges',
'cost_center': 'Main - _TC',
'rate': 5.0
}])
def create_asset():
pr.submit()
expected_gle = (
("Asset Received But Not Billed - _TC", 0.0, 5250.0),
("CWIP Account - _TC", 5250.0, 0.0)
)
gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type='Purchase Receipt' and voucher_no = %s
order by account""", pr.name)
self.assertEqual(gle, expected_gle)
pi = make_purchase_invoice_from_pr(pr.name)
pi.submit()
expected_gle = (
("_Test Account Service Tax - _TC", 250.0, 0.0),
("_Test Account Shipping Charges - _TC", 250.0, 0.0),
("Asset Received But Not Billed - _TC", 5250.0, 0.0),
("Creditors - _TC", 0.0, 5500.0),
("Expenses Included In Asset Valuation - _TC", 0.0, 250.0),
)
gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type='Purchase Invoice' and voucher_no = %s
order by account""", pi.name)
self.assertEqual(gle, expected_gle)
asset = frappe.db.get_value('Asset',
{'purchase_receipt': pr.name, 'docstatus': 0}, 'name')
asset_doc = frappe.get_doc('Asset', asset)
month_end_date = get_last_day(nowdate())
asset_doc.available_for_use_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
self.assertEqual(asset_doc.gross_purchase_amount, 5250.0)
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
expected_gle = (
("_Test Fixed Asset - _TC", 5250.0, 0.0),
("CWIP Account - _TC", 0.0, 5250.0)
)
gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type='Asset' and voucher_no = %s
order by account""", asset_doc.name)
self.assertEqual(gle, expected_gle)
def create_asset_data():
if not frappe.db.exists("Asset Category", "Computers"):
create_asset_category()
@ -365,6 +507,11 @@ def create_asset():
'location_name': 'Test Location'
}).insert()
def create_asset(**args):
args = frappe._dict(args)
create_asset_data()
asset = frappe.get_doc({
"doctype": "Asset",
"asset_name": "Macbook Pro 1",
@ -378,7 +525,8 @@ def create_asset():
"warehouse": "_Test Warehouse - _TC",
"available_for_use_date": "2020-06-06",
"location": "Test Location",
"asset_owner": "Company"
"asset_owner": "Company",
"is_existing_asset": args.is_existing_asset or 0
})
try:

View File

@ -5,16 +5,40 @@ from __future__ import unicode_literals
import frappe
import unittest
from frappe.utils import nowdate, add_days
from frappe.utils import nowdate, get_last_day, add_days
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
from erpnext.assets.doctype.asset_maintenance.asset_maintenance import calculate_next_due_date
class TestAssetMaintenance(unittest.TestCase):
def setUp(self):
set_depreciation_settings_in_company()
create_asset()
create_asset_data()
create_maintenance_team()
def test_create_asset_maintenance(self):
pr = make_purchase_receipt(item_code="Photocopier",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.save()
if not frappe.db.exists("Asset Maintenance", "Photocopier"):
asset_maintenance = frappe.get_doc({
"doctype": "Asset Maintenance",
@ -40,7 +64,7 @@ class TestAssetMaintenance(unittest.TestCase):
next_due_date = calculate_next_due_date(asset_maintenance_log.completion_date, "Monthly")
self.assertEqual(asset_maintenance.asset_maintenance_tasks[0].next_due_date, next_due_date)
def create_asset():
def create_asset_data():
if not frappe.db.exists("Asset Category", "Equipment"):
create_asset_category()
@ -62,23 +86,6 @@ def create_asset():
"asset_category": "Equipment"
}).insert()
if not frappe.db.exists("Asset", "Photocopier"):
frappe.get_doc({
"doctype": "Asset",
"asset_name": "Photocopier",
"item_code": "Photocopier",
"asset_category": "Equipment",
"gross_purchase_amount": 100000,
"expected_value_after_useful_life": 10000,
"warehouse": "_Test Warehouse - _TC",
"location": "Test Location",
"available_for_use_date": add_days(nowdate(),3),
"company": "_Test Company",
"purchase_date": nowdate(),
"maintenance_required": 1,
"asset_owner": "Company"
}).insert()
def create_maintenance_team():
user_list = ["marcus@abc.com", "thalia@abc.com", "mathias@abc.com"]
if not frappe.db.exists("Role", "Technician"):

View File

@ -11,7 +11,7 @@ from frappe.model.document import Document
class AssetMovement(Document):
def validate(self):
self.validate_asset()
self.validate_warehouses()
self.validate_location()
def validate_asset(self):
status, company = frappe.db.get_value("Asset", self.asset, ["status", "company"])
@ -27,13 +27,33 @@ class AssetMovement(Document):
if not(self.source_location or self.target_location or self.from_employee or self.to_employee):
frappe.throw(_("Either location or employee must be required"))
def validate_warehouses(self):
if self.purpose in ['Transfer', 'Issue']:
self.source_location = frappe.db.get_value("Asset", self.asset, "location")
if (not self.serial_no and
frappe.db.get_value('Serial No', {'asset': self.asset}, 'name')):
frappe.throw(_("Serial no is required for the asset {0}").format(self.asset))
if self.source_location == self.target_location and self.purpose == 'Transfer':
def validate_location(self):
if self.purpose in ['Transfer', 'Issue']:
if not self.serial_no and not (self.from_employee or self.to_employee):
self.source_location = frappe.db.get_value("Asset", self.asset, "location")
if self.purpose == 'Issue' and not self.source_location:
frappe.throw(_("Source Location is required for the asset {0}").format(self.asset))
if self.serial_no and self.source_location:
s_nos = get_serial_nos(self.serial_no)
serial_nos = frappe.db.sql_list(""" select name from `tabSerial No` where location != '%s'
and name in (%s)""" %(self.source_location, ','.join(['%s'] * len(s_nos))), tuple(s_nos))
if serial_nos:
frappe.throw(_("Serial nos {0} does not belongs to the location {1}").
format(','.join(serial_nos), self.source_location))
if self.source_location and self.source_location == self.target_location and self.purpose == 'Transfer':
frappe.throw(_("Source and Target Location cannot be same"))
if self.purpose == 'Receipt' and not self.target_location:
frappe.throw(_("Target Location is required for the asset {0}").format(self.asset))
def on_submit(self):
self.set_latest_location_in_asset()
@ -41,19 +61,42 @@ class AssetMovement(Document):
self.set_latest_location_in_asset()
def set_latest_location_in_asset(self):
latest_movement_entry = frappe.db.sql("""select target_location from `tabAsset Movement`
where asset=%s and docstatus=1 and company=%s
order by transaction_date desc limit 1""", (self.asset, self.company))
location, employee = '', ''
cond = "1=1"
args = {
'asset': self.asset,
'company': self.company
}
if self.serial_no:
cond = "serial_no like %(txt)s"
args.update({
'txt': "%%%s%%" % self.serial_no
})
latest_movement_entry = frappe.db.sql("""select target_location, to_employee from `tabAsset Movement`
where asset=%(asset)s and docstatus=1 and company=%(company)s and {0}
order by transaction_date desc limit 1""".format(cond), args)
if latest_movement_entry:
location = latest_movement_entry[0][0]
else:
location = frappe.db.sql("""select source_location from `tabAsset Movement`
where asset=%s and docstatus=2 and company=%s
order by transaction_date asc limit 1""", (self.asset, self.company))[0][0]
employee = latest_movement_entry[0][1]
elif self.purpose in ['Transfer', 'Receipt']:
movement_entry = frappe.db.sql("""select source_location, from_employee from `tabAsset Movement`
where asset=%(asset)s and docstatus=2 and company=%(company)s and {0}
order by transaction_date asc limit 1""".format(cond), args)
if movement_entry:
location = movement_entry[0][0]
employee = movement_entry[0][1]
frappe.db.set_value("Asset", self.asset, "location", location)
if not self.serial_no:
frappe.db.set_value("Asset", self.asset, "location", location)
if self.serial_no:
for d in get_serial_nos(self.serial_no):
frappe.db.set_value('Serial No', d, 'location', location)
if (location or self.purpose == 'Issue'):
frappe.db.set_value('Serial No', d, 'location', location)
if employee:
frappe.db.set_value('Serial No', d, 'employee', employee)

View File

@ -4,14 +4,37 @@
from __future__ import unicode_literals
import frappe
from frappe.utils import now
import unittest
from erpnext.assets.doctype.asset.test_asset import create_asset
from erpnext.stock.doctype.item.test_item import make_item
from frappe.utils import now, nowdate, get_last_day, add_days
from erpnext.assets.doctype.asset.test_asset import create_asset_data
from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
from erpnext.hr.doctype.employee.test_employee import make_employee
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
class TestAssetMovement(unittest.TestCase):
def setUp(self):
create_asset_data()
make_location()
make_serialized_item()
def test_movement(self):
asset = create_asset()
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset = frappe.get_doc('Asset', asset_name)
asset.calculate_depreciation = 1
asset.available_for_use_date = '2020-06-06'
asset.purchase_date = '2020-06-06'
asset.append("finance_books", {
"expected_value_after_useful_life": 10000,
"next_depreciation_date": "2020-12-31",
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": "2020-06-06"
})
if asset.docstatus == 0:
asset.submit()
@ -21,10 +44,12 @@ class TestAssetMovement(unittest.TestCase):
'location_name': 'Test Location 2'
}).insert()
movement1 = create_asset_movement(asset, target_location="Test Location 2")
movement1 = create_asset_movement(asset= asset.name, purpose = 'Transfer',
company=asset.company, source_location="Test Location", target_location="Test Location 2")
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location 2")
movement2 = create_asset_movement(asset, target_location="Test Location")
movement2 = create_asset_movement(asset= asset.name, purpose = 'Transfer',
company=asset.company, source_location = "Test Location 2", target_location="Test Location")
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
movement1.cancel()
@ -33,23 +58,112 @@ class TestAssetMovement(unittest.TestCase):
movement2.cancel()
self.assertEqual(frappe.db.get_value("Asset", asset.name, "location"), "Test Location")
asset.load_from_db()
asset.cancel()
frappe.delete_doc("Asset", asset.name)
def test_movement_for_serialized_asset(self):
asset_item = "Test Serialized Asset Item"
pr = make_purchase_receipt(item_code=asset_item, rate = 1000, qty=3, location = "Mumbai")
asset_name = frappe.db.get_value('Asset', {'purchase_receipt': pr.name}, 'name')
def create_asset_movement(asset, target_location, transaction_date=None):
if not transaction_date:
transaction_date = now()
asset = frappe.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
asset.available_for_use_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset.calculate_depreciation = 1
asset.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset.submit()
serial_nos = frappe.db.get_value('Asset Movement', {'reference_name': pr.name}, 'serial_no')
mov1 = create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, source_location = "Mumbai", target_location="Pune", serial_no=serial_nos)
self.assertEqual(mov1.target_location, "Pune")
serial_no = frappe.db.get_value('Serial No', {'asset': asset_name}, 'name')
employee = make_employee("testassetemp@example.com")
create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, serial_no=serial_no, to_employee=employee)
self.assertEqual(frappe.db.get_value('Serial No', serial_no, 'employee'), employee)
create_asset_movement(asset=asset_name, purpose = 'Transfer', company=asset.company,
serial_no=serial_no, from_employee=employee, to_employee="_T-Employee-00001")
self.assertEqual(frappe.db.get_value('Serial No', serial_no, 'location'), "Pune")
mov4 = create_asset_movement(asset=asset_name, purpose = 'Transfer',
company=asset.company, source_location = "Pune", target_location="Nagpur", serial_no=serial_nos)
self.assertEqual(mov4.target_location, "Nagpur")
self.assertEqual(frappe.db.get_value('Serial No', serial_no, 'location'), "Nagpur")
self.assertEqual(frappe.db.get_value('Serial No', serial_no, 'employee'), "_T-Employee-00001")
def create_asset_movement(**args):
args = frappe._dict(args)
if not args.transaction_date:
args.transaction_date = now()
movement = frappe.new_doc("Asset Movement")
movement.update({
"asset": asset.name,
"transaction_date": transaction_date,
"target_location": target_location,
"company": asset.company
"asset": args.asset,
"transaction_date": args.transaction_date,
"target_location": args.target_location,
"company": args.company,
'purpose': args.purpose or 'Receipt',
'serial_no': args.serial_no,
'quantity': len(get_serial_nos(args.serial_no)) if args.serial_no else 1,
'from_employee': "_T-Employee-00001" or args.from_employee,
'to_employee': args.to_employee
})
if args.source_location:
movement.update({
'source_location': args.source_location
})
movement.insert()
movement.submit()
return movement
def make_location():
for location in ['Pune', 'Mumbai', 'Nagpur']:
if not frappe.db.exists('Location', location):
frappe.get_doc({
'doctype': 'Location',
'location_name': location
}).insert(ignore_permissions = True)
def make_serialized_item():
asset_item = "Test Serialized Asset Item"
if not frappe.db.exists('Item', asset_item):
asset_category = frappe.get_all('Asset Category')
if asset_category:
asset_category = asset_category[0].name
if not asset_category:
doc = frappe.get_doc({
'doctype': 'Asset Category',
'asset_category_name': 'Test Asset Category',
'depreciation_method': 'Straight Line',
'total_number_of_depreciations': 12,
'frequency_of_depreciation': 1,
'accounts': [{
'company_name': '_Test Company',
'fixed_asset_account': '_Test Fixed Asset - _TC',
'accumulated_depreciation_account': 'Depreciation - _TC',
'depreciation_expense_account': 'Depreciation - _TC'
}]
}).insert()
asset_category = doc.name
make_item(asset_item, {'is_stock_item':0,
'stock_uom': 'Box', 'is_fixed_asset': 1, 'has_serial_no': 1,
'asset_category': asset_category, 'serial_no_series': 'ABC.###'})

View File

@ -23,9 +23,9 @@ frappe.ui.form.on('Asset Value Adjustment', {
},
set_current_asset_value: function(frm) {
if (frm.doc.finance_book && frm.doc.asset) {
if (frm.doc.asset) {
frm.call({
method: "erpnext.assets.doctype.asset_adjustment.asset_adjustment.get_current_asset_value",
method: "erpnext.assets.doctype.asset_value_adjustment.asset_value_adjustment.get_current_asset_value",
args: {
asset: frm.doc.asset,
finance_book: frm.doc.finance_book

View File

@ -139,7 +139,7 @@
"read_only": 0,
"remember_last_selected_value": 0,
"report_hide": 0,
"reqd": 1,
"reqd": 0,
"search_index": 0,
"set_only_once": 0,
"translatable": 0,
@ -413,7 +413,7 @@
"issingle": 0,
"istable": 0,
"max_attachments": 0,
"modified": "2018-06-15 11:48:52.880894",
"modified": "2018-06-18 17:44:42.383087",
"modified_by": "Administrator",
"module": "Assets",
"name": "Asset Value Adjustment",

View File

@ -28,7 +28,7 @@ class AssetValueAdjustment(Document):
self.difference_amount = flt(self.current_asset_value - self.new_asset_value)
def set_current_asset_value(self):
if not self.current_asset_value and self.asset and self.finance_book:
if not self.current_asset_value and self.asset:
self.current_asset_value = get_current_asset_value(self.asset, self.finance_book)
def make_depreciation_entry(self):
@ -101,6 +101,9 @@ class AssetValueAdjustment(Document):
asset_data.db_update()
@frappe.whitelist()
def get_current_asset_value(asset, finance_book):
return frappe.db.get_value('Asset Finance Book',
{'parent': asset, 'parenttype': 'Asset', 'finance_book': finance_book}, 'value_after_depreciation', debug=1)
def get_current_asset_value(asset, finance_book=None):
cond = {'parent': asset, 'parenttype': 'Asset'}
if finance_book:
cond.update({'finance_book': finance_book})
return frappe.db.get_value('Asset Finance Book', cond, 'value_after_depreciation')

View File

@ -5,6 +5,90 @@ from __future__ import unicode_literals
import frappe
import unittest
from frappe.utils import nowdate, get_last_day, add_days
from erpnext.assets.doctype.asset.test_asset import create_asset_data
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
from erpnext.assets.doctype.asset_value_adjustment.asset_value_adjustment import get_current_asset_value
class TestAssetValueAdjustment(unittest.TestCase):
pass
def setUp(self):
create_asset_data()
def test_current_asset_value(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
current_value = get_current_asset_value(asset_doc.name)
self.assertEqual(current_value, 100000.0)
def test_asset_depreciation_value_adjustment(self):
pr = make_purchase_receipt(item_code="Macbook Pro",
qty=1, rate=100000.0, location="Test Location")
asset_name = frappe.db.get_value("Asset", {"purchase_receipt": pr.name}, 'name')
asset_doc = frappe.get_doc('Asset', asset_name)
asset_doc.calculate_depreciation = 1
month_end_date = get_last_day(nowdate())
purchase_date = nowdate() if nowdate() != month_end_date else add_days(nowdate(), -15)
asset_doc.available_for_use_date = purchase_date
asset_doc.purchase_date = purchase_date
asset_doc.calculate_depreciation = 1
asset_doc.append("finance_books", {
"expected_value_after_useful_life": 200,
"depreciation_method": "Straight Line",
"total_number_of_depreciations": 3,
"frequency_of_depreciation": 10,
"depreciation_start_date": month_end_date
})
asset_doc.submit()
current_value = get_current_asset_value(asset_doc.name)
adj_doc = make_asset_value_adjustment(asset = asset_doc.name,
current_asset_value = current_value, new_asset_value = 50000.0)
adj_doc.submit()
expected_gle = (
("_Test Accumulated Depreciations - _TC", 0.0, 50000.0),
("_Test Depreciations - _TC", 50000.0, 0.0)
)
gle = frappe.db.sql("""select account, debit, credit from `tabGL Entry`
where voucher_type='Journal Entry' and voucher_no = %s
order by account""", adj_doc.journal_entry)
self.assertEqual(gle, expected_gle)
def make_asset_value_adjustment(**args):
args = frappe._dict(args)
doc = frappe.get_doc({
"doctype": "Asset Value Adjustment",
"company": args.company or "_Test Company",
"asset": args.asset,
"date": args.date or nowdate(),
"new_asset_value": args.new_asset_value,
"current_asset_value": args.current_asset_value,
"cost_center": args.cost_center or "Main - _TC"
}).insert()
return doc

View File

@ -578,7 +578,6 @@ class BuyingController(StockController):
'doctype': 'Asset',
'item_code': row.item_code,
'asset_name': row.item_name,
'status': 'Receipt',
'naming_series': item_data.get('asset_naming_series') or 'AST',
'asset_category': item_data.get('asset_category'),
'location': row.asset_location,

View File

@ -33,8 +33,6 @@ class TestEmployee(unittest.TestCase):
self.assertTrue("Subject: Birthday Reminder for {0}".format(employee.employee_name) \
in email_queue[0].message)
def make_employee(user):
if not frappe.db.get_value("User", user):
frappe.get_doc({

View File

@ -332,6 +332,10 @@ class TestPurchaseReceipt(unittest.TestCase):
serial_nos = frappe.get_all('Serial No', {'asset': asset}, 'name')
self.assertEquals(len(serial_nos), 3)
location = frappe.db.get_value('Serial No', serial_nos[0].name, 'location')
self.assertEquals(location, "Test Location")
pr.cancel()
serial_nos = frappe.get_all('Serial No', {'asset': asset}, 'name') or []
self.assertEquals(len(serial_nos), 0)
@ -373,7 +377,8 @@ def make_purchase_receipt(**args):
"serial_no": args.serial_no,
"stock_uom": args.stock_uom or "_Test UOM",
"uom": args.uom or "_Test UOM",
"asset_location": "Test Location" if args.item_code == "Test Serialized Asset Item" else ""
"cost_center": args.cost_center or frappe.db.get_value('Company', pr.company, 'cost_center'),
"asset_location": args.location or "Test Location"
})
if not args.do_not_save: