9979cf5fcc
When two transactions are inserted parallelly then previous SLE could be incorrect for some of them. Locking SLE table would prevent reading from it till transaction is complete.
912 lines
34 KiB
Python
912 lines
34 KiB
Python
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
|
|
# License: GNU General Public License v3. See license.txt
|
|
from __future__ import unicode_literals
|
|
|
|
import frappe
|
|
import erpnext
|
|
import copy
|
|
from frappe import _
|
|
from frappe.utils import cint, flt, cstr, now, get_link_to_form
|
|
from frappe.model.meta import get_field_precision
|
|
from erpnext.stock.utils import get_valuation_method, get_incoming_outgoing_rate_for_cancel
|
|
from erpnext.stock.utils import get_bin
|
|
import json
|
|
from six import iteritems
|
|
|
|
# future reposting
|
|
class NegativeStockError(frappe.ValidationError): pass
|
|
class SerialNoExistsInFutureTransaction(frappe.ValidationError):
|
|
pass
|
|
|
|
_exceptions = frappe.local('stockledger_exceptions')
|
|
# _exceptions = []
|
|
|
|
def make_sl_entries(sl_entries, allow_negative_stock=False, via_landed_cost_voucher=False):
|
|
if sl_entries:
|
|
from erpnext.stock.utils import update_bin
|
|
|
|
cancel = sl_entries[0].get("is_cancelled")
|
|
if cancel:
|
|
validate_cancellation(sl_entries)
|
|
set_as_cancel(sl_entries[0].get('voucher_type'), sl_entries[0].get('voucher_no'))
|
|
|
|
for sle in sl_entries:
|
|
if sle.serial_no:
|
|
validate_serial_no(sle)
|
|
|
|
if cancel:
|
|
sle['actual_qty'] = -flt(sle.get('actual_qty'))
|
|
|
|
if sle['actual_qty'] < 0 and not sle.get('outgoing_rate'):
|
|
sle['outgoing_rate'] = get_incoming_outgoing_rate_for_cancel(sle.item_code,
|
|
sle.voucher_type, sle.voucher_no, sle.voucher_detail_no)
|
|
sle['incoming_rate'] = 0.0
|
|
|
|
if sle['actual_qty'] > 0 and not sle.get('incoming_rate'):
|
|
sle['incoming_rate'] = get_incoming_outgoing_rate_for_cancel(sle.item_code,
|
|
sle.voucher_type, sle.voucher_no, sle.voucher_detail_no)
|
|
sle['outgoing_rate'] = 0.0
|
|
|
|
if sle.get("actual_qty") or sle.get("voucher_type")=="Stock Reconciliation":
|
|
sle_doc = make_entry(sle, allow_negative_stock, via_landed_cost_voucher)
|
|
|
|
args = sle_doc.as_dict()
|
|
update_bin(args, allow_negative_stock, via_landed_cost_voucher)
|
|
|
|
def validate_serial_no(sle):
|
|
from erpnext.stock.doctype.serial_no.serial_no import get_serial_nos
|
|
for sn in get_serial_nos(sle.serial_no):
|
|
args = copy.deepcopy(sle)
|
|
args.serial_no = sn
|
|
args.warehouse = ''
|
|
|
|
vouchers = []
|
|
for row in get_stock_ledger_entries(args, '>'):
|
|
voucher_type = frappe.bold(row.voucher_type)
|
|
voucher_no = frappe.bold(get_link_to_form(row.voucher_type, row.voucher_no))
|
|
vouchers.append(f'{voucher_type} {voucher_no}')
|
|
|
|
if vouchers:
|
|
serial_no = frappe.bold(sn)
|
|
msg = (f'''The serial no {serial_no} has been used in the future transactions so you need to cancel them first.
|
|
The list of the transactions are as below.''' + '<br><br><ul><li>')
|
|
|
|
msg += '</li><li>'.join(vouchers)
|
|
msg += '</li></ul>'
|
|
|
|
title = 'Cannot Submit' if not sle.get('is_cancelled') else 'Cannot Cancel'
|
|
frappe.throw(_(msg), title=_(title), exc=SerialNoExistsInFutureTransaction)
|
|
|
|
def validate_cancellation(args):
|
|
if args[0].get("is_cancelled"):
|
|
repost_entry = frappe.db.get_value("Repost Item Valuation", {
|
|
'voucher_type': args[0].voucher_type,
|
|
'voucher_no': args[0].voucher_no,
|
|
'docstatus': 1
|
|
}, ['name', 'status'], as_dict=1)
|
|
|
|
if repost_entry:
|
|
if repost_entry.status == 'In Progress':
|
|
frappe.throw(_("Cannot cancel the transaction. Reposting of item valuation on submission is not completed yet."))
|
|
if repost_entry.status == 'Queued':
|
|
doc = frappe.get_doc("Repost Item Valuation", repost_entry.name)
|
|
doc.cancel()
|
|
doc.delete()
|
|
|
|
def set_as_cancel(voucher_type, voucher_no):
|
|
frappe.db.sql("""update `tabStock Ledger Entry` set is_cancelled=1,
|
|
modified=%s, modified_by=%s
|
|
where voucher_type=%s and voucher_no=%s and is_cancelled = 0""",
|
|
(now(), frappe.session.user, voucher_type, voucher_no))
|
|
|
|
def make_entry(args, allow_negative_stock=False, via_landed_cost_voucher=False):
|
|
args.update({"doctype": "Stock Ledger Entry"})
|
|
sle = frappe.get_doc(args)
|
|
sle.flags.ignore_permissions = 1
|
|
sle.allow_negative_stock=allow_negative_stock
|
|
sle.via_landed_cost_voucher = via_landed_cost_voucher
|
|
sle.insert()
|
|
sle.submit()
|
|
return sle
|
|
|
|
def repost_future_sle(args=None, voucher_type=None, voucher_no=None, allow_negative_stock=None, via_landed_cost_voucher=False):
|
|
if not args and voucher_type and voucher_no:
|
|
args = get_args_for_voucher(voucher_type, voucher_no)
|
|
|
|
distinct_item_warehouses = [(d.item_code, d.warehouse) for d in args]
|
|
|
|
i = 0
|
|
while i < len(args):
|
|
obj = update_entries_after({
|
|
"item_code": args[i].item_code,
|
|
"warehouse": args[i].warehouse,
|
|
"posting_date": args[i].posting_date,
|
|
"posting_time": args[i].posting_time,
|
|
"creation": args[i].get("creation")
|
|
}, allow_negative_stock=allow_negative_stock, via_landed_cost_voucher=via_landed_cost_voucher)
|
|
|
|
for item_wh, new_sle in iteritems(obj.new_items):
|
|
if item_wh not in distinct_item_warehouses:
|
|
args.append(new_sle)
|
|
|
|
i += 1
|
|
|
|
def get_args_for_voucher(voucher_type, voucher_no):
|
|
return frappe.db.get_all("Stock Ledger Entry",
|
|
filters={"voucher_type": voucher_type, "voucher_no": voucher_no},
|
|
fields=["item_code", "warehouse", "posting_date", "posting_time", "creation"],
|
|
order_by="creation asc",
|
|
group_by="item_code, warehouse"
|
|
)
|
|
|
|
class update_entries_after(object):
|
|
"""
|
|
update valution rate and qty after transaction
|
|
from the current time-bucket onwards
|
|
|
|
:param args: args as dict
|
|
|
|
args = {
|
|
"item_code": "ABC",
|
|
"warehouse": "XYZ",
|
|
"posting_date": "2012-12-12",
|
|
"posting_time": "12:00"
|
|
}
|
|
"""
|
|
def __init__(self, args, allow_zero_rate=False, allow_negative_stock=None, via_landed_cost_voucher=False, verbose=1):
|
|
self.exceptions = {}
|
|
self.verbose = verbose
|
|
self.allow_zero_rate = allow_zero_rate
|
|
self.via_landed_cost_voucher = via_landed_cost_voucher
|
|
self.allow_negative_stock = allow_negative_stock \
|
|
or cint(frappe.db.get_single_value("Stock Settings", "allow_negative_stock"))
|
|
|
|
self.args = frappe._dict(args)
|
|
self.item_code = args.get("item_code")
|
|
if self.args.sle_id:
|
|
self.args['name'] = self.args.sle_id
|
|
|
|
self.company = frappe.get_cached_value("Warehouse", self.args.warehouse, "company")
|
|
self.get_precision()
|
|
self.valuation_method = get_valuation_method(self.item_code)
|
|
self.new_items = {}
|
|
|
|
self.data = frappe._dict()
|
|
self.initialize_previous_data(self.args)
|
|
|
|
self.build()
|
|
|
|
def get_precision(self):
|
|
company_base_currency = frappe.get_cached_value('Company', self.company, "default_currency")
|
|
self.precision = get_field_precision(frappe.get_meta("Stock Ledger Entry").get_field("stock_value"),
|
|
currency=company_base_currency)
|
|
|
|
def initialize_previous_data(self, args):
|
|
"""
|
|
Get previous sl entries for current item for each related warehouse
|
|
and assigns into self.data dict
|
|
|
|
:Data Structure:
|
|
|
|
self.data = {
|
|
warehouse1: {
|
|
'previus_sle': {},
|
|
'qty_after_transaction': 10,
|
|
'valuation_rate': 100,
|
|
'stock_value': 1000,
|
|
'prev_stock_value': 1000,
|
|
'stock_queue': '[[10, 100]]',
|
|
'stock_value_difference': 1000
|
|
}
|
|
}
|
|
|
|
"""
|
|
self.data.setdefault(args.warehouse, frappe._dict())
|
|
warehouse_dict = self.data[args.warehouse]
|
|
previous_sle = self.get_previous_sle_of_current_voucher(args)
|
|
warehouse_dict.previous_sle = previous_sle
|
|
|
|
for key in ("qty_after_transaction", "valuation_rate", "stock_value"):
|
|
setattr(warehouse_dict, key, flt(previous_sle.get(key)))
|
|
|
|
warehouse_dict.update({
|
|
"prev_stock_value": previous_sle.stock_value or 0.0,
|
|
"stock_queue": json.loads(previous_sle.stock_queue or "[]"),
|
|
"stock_value_difference": 0.0
|
|
})
|
|
|
|
def get_previous_sle_of_current_voucher(self, args):
|
|
"""get stock ledger entries filtered by specific posting datetime conditions"""
|
|
|
|
args['time_format'] = '%H:%i:%s'
|
|
if not args.get("posting_date"):
|
|
args["posting_date"] = "1900-01-01"
|
|
if not args.get("posting_time"):
|
|
args["posting_time"] = "00:00"
|
|
|
|
sle = frappe.db.sql("""
|
|
select *, timestamp(posting_date, posting_time) as "timestamp"
|
|
from `tabStock Ledger Entry`
|
|
where item_code = %(item_code)s
|
|
and warehouse = %(warehouse)s
|
|
and is_cancelled = 0
|
|
and timestamp(posting_date, time_format(posting_time, %(time_format)s)) < timestamp(%(posting_date)s, time_format(%(posting_time)s, %(time_format)s))
|
|
order by timestamp(posting_date, posting_time) desc, creation desc
|
|
limit 1
|
|
for update""", args, as_dict=1)
|
|
|
|
return sle[0] if sle else frappe._dict()
|
|
|
|
|
|
def build(self):
|
|
from erpnext.controllers.stock_controller import future_sle_exists
|
|
|
|
if self.args.get("sle_id"):
|
|
self.process_sle_against_current_timestamp()
|
|
if not future_sle_exists(self.args):
|
|
self.update_bin()
|
|
else:
|
|
entries_to_fix = self.get_future_entries_to_fix()
|
|
|
|
i = 0
|
|
while i < len(entries_to_fix):
|
|
sle = entries_to_fix[i]
|
|
i += 1
|
|
|
|
self.process_sle(sle)
|
|
|
|
if sle.dependant_sle_voucher_detail_no:
|
|
entries_to_fix = self.get_dependent_entries_to_fix(entries_to_fix, sle)
|
|
|
|
self.update_bin()
|
|
|
|
if self.exceptions:
|
|
self.raise_exceptions()
|
|
|
|
def process_sle_against_current_timestamp(self):
|
|
sl_entries = self.get_sle_against_current_voucher()
|
|
for sle in sl_entries:
|
|
self.process_sle(sle)
|
|
|
|
def get_sle_against_current_voucher(self):
|
|
self.args['time_format'] = '%H:%i:%s'
|
|
|
|
return frappe.db.sql("""
|
|
select
|
|
*, timestamp(posting_date, posting_time) as "timestamp"
|
|
from
|
|
`tabStock Ledger Entry`
|
|
where
|
|
item_code = %(item_code)s
|
|
and warehouse = %(warehouse)s
|
|
and timestamp(posting_date, time_format(posting_time, %(time_format)s)) = timestamp(%(posting_date)s, time_format(%(posting_time)s, %(time_format)s))
|
|
|
|
order by
|
|
creation ASC
|
|
for update
|
|
""", self.args, as_dict=1)
|
|
|
|
def get_future_entries_to_fix(self):
|
|
# includes current entry!
|
|
args = self.data[self.args.warehouse].previous_sle \
|
|
or frappe._dict({"item_code": self.item_code, "warehouse": self.args.warehouse})
|
|
|
|
return list(self.get_sle_after_datetime(args))
|
|
|
|
def get_dependent_entries_to_fix(self, entries_to_fix, sle):
|
|
dependant_sle = get_sle_by_voucher_detail_no(sle.dependant_sle_voucher_detail_no,
|
|
excluded_sle=sle.name)
|
|
|
|
if not dependant_sle:
|
|
return entries_to_fix
|
|
elif dependant_sle.item_code == self.item_code and dependant_sle.warehouse == self.args.warehouse:
|
|
return entries_to_fix
|
|
elif dependant_sle.item_code != self.item_code:
|
|
if (dependant_sle.item_code, dependant_sle.warehouse) not in self.new_items:
|
|
self.new_items[(dependant_sle.item_code, dependant_sle.warehouse)] = dependant_sle
|
|
return entries_to_fix
|
|
elif dependant_sle.item_code == self.item_code and dependant_sle.warehouse in self.data:
|
|
return entries_to_fix
|
|
self.initialize_previous_data(dependant_sle)
|
|
|
|
args = self.data[dependant_sle.warehouse].previous_sle \
|
|
or frappe._dict({"item_code": self.item_code, "warehouse": dependant_sle.warehouse})
|
|
future_sle_for_dependant = list(self.get_sle_after_datetime(args))
|
|
|
|
entries_to_fix.extend(future_sle_for_dependant)
|
|
return sorted(entries_to_fix, key=lambda k: k['timestamp'])
|
|
|
|
def process_sle(self, sle):
|
|
# previous sle data for this warehouse
|
|
self.wh_data = self.data[sle.warehouse]
|
|
|
|
if (sle.serial_no and not self.via_landed_cost_voucher) or not cint(self.allow_negative_stock):
|
|
# validate negative stock for serialized items, fifo valuation
|
|
# or when negative stock is not allowed for moving average
|
|
if not self.validate_negative_stock(sle):
|
|
self.wh_data.qty_after_transaction += flt(sle.actual_qty)
|
|
return
|
|
|
|
# Get dynamic incoming/outgoing rate
|
|
self.get_dynamic_incoming_outgoing_rate(sle)
|
|
|
|
if sle.serial_no:
|
|
self.get_serialized_values(sle)
|
|
self.wh_data.qty_after_transaction += flt(sle.actual_qty)
|
|
if sle.voucher_type == "Stock Reconciliation":
|
|
self.wh_data.qty_after_transaction = sle.qty_after_transaction
|
|
|
|
self.wh_data.stock_value = flt(self.wh_data.qty_after_transaction) * flt(self.wh_data.valuation_rate)
|
|
else:
|
|
if sle.voucher_type=="Stock Reconciliation" and not sle.batch_no:
|
|
# assert
|
|
self.wh_data.valuation_rate = sle.valuation_rate
|
|
self.wh_data.qty_after_transaction = sle.qty_after_transaction
|
|
self.wh_data.stock_queue = [[self.wh_data.qty_after_transaction, self.wh_data.valuation_rate]]
|
|
self.wh_data.stock_value = flt(self.wh_data.qty_after_transaction) * flt(self.wh_data.valuation_rate)
|
|
else:
|
|
if self.valuation_method == "Moving Average":
|
|
self.get_moving_average_values(sle)
|
|
self.wh_data.qty_after_transaction += flt(sle.actual_qty)
|
|
self.wh_data.stock_value = flt(self.wh_data.qty_after_transaction) * flt(self.wh_data.valuation_rate)
|
|
else:
|
|
self.get_fifo_values(sle)
|
|
self.wh_data.qty_after_transaction += flt(sle.actual_qty)
|
|
self.wh_data.stock_value = sum((flt(batch[0]) * flt(batch[1]) for batch in self.wh_data.stock_queue))
|
|
|
|
# rounding as per precision
|
|
self.wh_data.stock_value = flt(self.wh_data.stock_value, self.precision)
|
|
stock_value_difference = self.wh_data.stock_value - self.wh_data.prev_stock_value
|
|
self.wh_data.prev_stock_value = self.wh_data.stock_value
|
|
|
|
# update current sle
|
|
sle.qty_after_transaction = self.wh_data.qty_after_transaction
|
|
sle.valuation_rate = self.wh_data.valuation_rate
|
|
sle.stock_value = self.wh_data.stock_value
|
|
sle.stock_queue = json.dumps(self.wh_data.stock_queue)
|
|
sle.stock_value_difference = stock_value_difference
|
|
sle.doctype="Stock Ledger Entry"
|
|
frappe.get_doc(sle).db_update()
|
|
|
|
self.update_outgoing_rate_on_transaction(sle)
|
|
|
|
def validate_negative_stock(self, sle):
|
|
"""
|
|
validate negative stock for entries current datetime onwards
|
|
will not consider cancelled entries
|
|
"""
|
|
diff = self.wh_data.qty_after_transaction + flt(sle.actual_qty)
|
|
|
|
if diff < 0 and abs(diff) > 0.0001:
|
|
# negative stock!
|
|
exc = sle.copy().update({"diff": diff})
|
|
self.exceptions.setdefault(sle.warehouse, []).append(exc)
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
def get_dynamic_incoming_outgoing_rate(self, sle):
|
|
# Get updated incoming/outgoing rate from transaction
|
|
if sle.recalculate_rate:
|
|
rate = self.get_incoming_outgoing_rate_from_transaction(sle)
|
|
|
|
if flt(sle.actual_qty) >= 0:
|
|
sle.incoming_rate = rate
|
|
else:
|
|
sle.outgoing_rate = rate
|
|
|
|
def get_incoming_outgoing_rate_from_transaction(self, sle):
|
|
rate = 0
|
|
# Material Transfer, Repack, Manufacturing
|
|
if sle.voucher_type == "Stock Entry":
|
|
rate = frappe.db.get_value("Stock Entry Detail", sle.voucher_detail_no, "valuation_rate")
|
|
# Sales and Purchase Return
|
|
elif sle.voucher_type in ("Purchase Receipt", "Purchase Invoice", "Delivery Note", "Sales Invoice"):
|
|
if frappe.get_cached_value(sle.voucher_type, sle.voucher_no, "is_return"):
|
|
from erpnext.controllers.sales_and_purchase_return import get_rate_for_return # don't move this import to top
|
|
rate = get_rate_for_return(sle.voucher_type, sle.voucher_no, sle.item_code,
|
|
voucher_detail_no=sle.voucher_detail_no, sle = sle)
|
|
else:
|
|
if sle.voucher_type in ("Purchase Receipt", "Purchase Invoice"):
|
|
rate_field = "valuation_rate"
|
|
else:
|
|
rate_field = "incoming_rate"
|
|
|
|
# check in item table
|
|
item_code, incoming_rate = frappe.db.get_value(sle.voucher_type + " Item",
|
|
sle.voucher_detail_no, ["item_code", rate_field])
|
|
|
|
if item_code == sle.item_code:
|
|
rate = incoming_rate
|
|
else:
|
|
if sle.voucher_type in ("Delivery Note", "Sales Invoice"):
|
|
ref_doctype = "Packed Item"
|
|
else:
|
|
ref_doctype = "Purchase Receipt Item Supplied"
|
|
|
|
rate = frappe.db.get_value(ref_doctype, {"parent_detail_docname": sle.voucher_detail_no,
|
|
"item_code": sle.item_code}, rate_field)
|
|
|
|
return rate
|
|
|
|
def update_outgoing_rate_on_transaction(self, sle):
|
|
"""
|
|
Update outgoing rate in Stock Entry, Delivery Note, Sales Invoice and Sales Return
|
|
In case of Stock Entry, also calculate FG Item rate and total incoming/outgoing amount
|
|
"""
|
|
if sle.actual_qty and sle.voucher_detail_no:
|
|
outgoing_rate = abs(flt(sle.stock_value_difference)) / abs(sle.actual_qty)
|
|
|
|
if flt(sle.actual_qty) < 0 and sle.voucher_type == "Stock Entry":
|
|
self.update_rate_on_stock_entry(sle, outgoing_rate)
|
|
elif sle.voucher_type in ("Delivery Note", "Sales Invoice"):
|
|
self.update_rate_on_delivery_and_sales_return(sle, outgoing_rate)
|
|
elif flt(sle.actual_qty) < 0 and sle.voucher_type in ("Purchase Receipt", "Purchase Invoice"):
|
|
self.update_rate_on_purchase_receipt(sle, outgoing_rate)
|
|
|
|
def update_rate_on_stock_entry(self, sle, outgoing_rate):
|
|
frappe.db.set_value("Stock Entry Detail", sle.voucher_detail_no, "basic_rate", outgoing_rate)
|
|
|
|
# Update outgoing item's rate, recalculate FG Item's rate and total incoming/outgoing amount
|
|
stock_entry = frappe.get_doc("Stock Entry", sle.voucher_no, for_update=True)
|
|
stock_entry.calculate_rate_and_amount(reset_outgoing_rate=False, raise_error_if_no_rate=False)
|
|
stock_entry.db_update()
|
|
for d in stock_entry.items:
|
|
d.db_update()
|
|
|
|
def update_rate_on_delivery_and_sales_return(self, sle, outgoing_rate):
|
|
# Update item's incoming rate on transaction
|
|
item_code = frappe.db.get_value(sle.voucher_type + " Item", sle.voucher_detail_no, "item_code")
|
|
if item_code == sle.item_code:
|
|
frappe.db.set_value(sle.voucher_type + " Item", sle.voucher_detail_no, "incoming_rate", outgoing_rate)
|
|
else:
|
|
# packed item
|
|
frappe.db.set_value("Packed Item",
|
|
{"parent_detail_docname": sle.voucher_detail_no, "item_code": sle.item_code},
|
|
"incoming_rate", outgoing_rate)
|
|
|
|
def update_rate_on_purchase_receipt(self, sle, outgoing_rate):
|
|
if frappe.db.exists(sle.voucher_type + " Item", sle.voucher_detail_no):
|
|
frappe.db.set_value(sle.voucher_type + " Item", sle.voucher_detail_no, "base_net_rate", outgoing_rate)
|
|
else:
|
|
frappe.db.set_value("Purchase Receipt Item Supplied", sle.voucher_detail_no, "rate", outgoing_rate)
|
|
|
|
# Recalculate subcontracted item's rate in case of subcontracted purchase receipt/invoice
|
|
if frappe.db.get_value(sle.voucher_type, sle.voucher_no, "is_subcontracted"):
|
|
doc = frappe.get_doc(sle.voucher_type, sle.voucher_no)
|
|
doc.update_valuation_rate(reset_outgoing_rate=False)
|
|
for d in (doc.items + doc.supplied_items):
|
|
d.db_update()
|
|
|
|
def get_serialized_values(self, sle):
|
|
incoming_rate = flt(sle.incoming_rate)
|
|
actual_qty = flt(sle.actual_qty)
|
|
serial_nos = cstr(sle.serial_no).split("\n")
|
|
|
|
if incoming_rate < 0:
|
|
# wrong incoming rate
|
|
incoming_rate = self.wh_data.valuation_rate
|
|
|
|
stock_value_change = 0
|
|
if incoming_rate:
|
|
stock_value_change = actual_qty * incoming_rate
|
|
elif actual_qty < 0:
|
|
# In case of delivery/stock issue, get average purchase rate
|
|
# of serial nos of current entry
|
|
if not sle.is_cancelled:
|
|
outgoing_value = self.get_incoming_value_for_serial_nos(sle, serial_nos)
|
|
stock_value_change = -1 * outgoing_value
|
|
else:
|
|
stock_value_change = actual_qty * sle.outgoing_rate
|
|
|
|
new_stock_qty = self.wh_data.qty_after_transaction + actual_qty
|
|
|
|
if new_stock_qty > 0:
|
|
new_stock_value = (self.wh_data.qty_after_transaction * self.wh_data.valuation_rate) + stock_value_change
|
|
if new_stock_value >= 0:
|
|
# calculate new valuation rate only if stock value is positive
|
|
# else it remains the same as that of previous entry
|
|
self.wh_data.valuation_rate = new_stock_value / new_stock_qty
|
|
|
|
if not self.wh_data.valuation_rate and sle.voucher_detail_no:
|
|
allow_zero_rate = self.check_if_allow_zero_valuation_rate(sle.voucher_type, sle.voucher_detail_no)
|
|
if not allow_zero_rate:
|
|
self.wh_data.valuation_rate = get_valuation_rate(sle.item_code, sle.warehouse,
|
|
sle.voucher_type, sle.voucher_no, self.allow_zero_rate,
|
|
currency=erpnext.get_company_currency(sle.company))
|
|
|
|
def get_incoming_value_for_serial_nos(self, sle, serial_nos):
|
|
# get rate from serial nos within same company
|
|
all_serial_nos = frappe.get_all("Serial No",
|
|
fields=["purchase_rate", "name", "company"],
|
|
filters = {'name': ('in', serial_nos)})
|
|
|
|
incoming_values = sum([flt(d.purchase_rate) for d in all_serial_nos if d.company==sle.company])
|
|
|
|
# Get rate for serial nos which has been transferred to other company
|
|
invalid_serial_nos = [d.name for d in all_serial_nos if d.company!=sle.company]
|
|
for serial_no in invalid_serial_nos:
|
|
incoming_rate = frappe.db.sql("""
|
|
select incoming_rate
|
|
from `tabStock Ledger Entry`
|
|
where
|
|
company = %s
|
|
and actual_qty > 0
|
|
and (serial_no = %s
|
|
or serial_no like %s
|
|
or serial_no like %s
|
|
or serial_no like %s
|
|
)
|
|
order by posting_date desc
|
|
limit 1
|
|
""", (sle.company, serial_no, serial_no+'\n%', '%\n'+serial_no, '%\n'+serial_no+'\n%'))
|
|
|
|
incoming_values += flt(incoming_rate[0][0]) if incoming_rate else 0
|
|
|
|
return incoming_values
|
|
|
|
def get_moving_average_values(self, sle):
|
|
actual_qty = flt(sle.actual_qty)
|
|
new_stock_qty = flt(self.wh_data.qty_after_transaction) + actual_qty
|
|
if new_stock_qty >= 0:
|
|
if actual_qty > 0:
|
|
if flt(self.wh_data.qty_after_transaction) <= 0:
|
|
self.wh_data.valuation_rate = sle.incoming_rate
|
|
else:
|
|
new_stock_value = (self.wh_data.qty_after_transaction * self.wh_data.valuation_rate) + \
|
|
(actual_qty * sle.incoming_rate)
|
|
|
|
self.wh_data.valuation_rate = new_stock_value / new_stock_qty
|
|
|
|
elif sle.outgoing_rate:
|
|
if new_stock_qty:
|
|
new_stock_value = (self.wh_data.qty_after_transaction * self.wh_data.valuation_rate) + \
|
|
(actual_qty * sle.outgoing_rate)
|
|
|
|
self.wh_data.valuation_rate = new_stock_value / new_stock_qty
|
|
else:
|
|
self.wh_data.valuation_rate = sle.outgoing_rate
|
|
else:
|
|
if flt(self.wh_data.qty_after_transaction) >= 0 and sle.outgoing_rate:
|
|
self.wh_data.valuation_rate = sle.outgoing_rate
|
|
|
|
if not self.wh_data.valuation_rate and actual_qty > 0:
|
|
self.wh_data.valuation_rate = sle.incoming_rate
|
|
|
|
# Get valuation rate from previous SLE or Item master, if item does not have the
|
|
# allow zero valuration rate flag set
|
|
if not self.wh_data.valuation_rate and sle.voucher_detail_no:
|
|
allow_zero_valuation_rate = self.check_if_allow_zero_valuation_rate(sle.voucher_type, sle.voucher_detail_no)
|
|
if not allow_zero_valuation_rate:
|
|
self.wh_data.valuation_rate = get_valuation_rate(sle.item_code, sle.warehouse,
|
|
sle.voucher_type, sle.voucher_no, self.allow_zero_rate,
|
|
currency=erpnext.get_company_currency(sle.company))
|
|
|
|
def get_fifo_values(self, sle):
|
|
incoming_rate = flt(sle.incoming_rate)
|
|
actual_qty = flt(sle.actual_qty)
|
|
outgoing_rate = flt(sle.outgoing_rate)
|
|
|
|
if actual_qty > 0:
|
|
if not self.wh_data.stock_queue:
|
|
self.wh_data.stock_queue.append([0, 0])
|
|
|
|
# last row has the same rate, just updated the qty
|
|
if self.wh_data.stock_queue[-1][1]==incoming_rate:
|
|
self.wh_data.stock_queue[-1][0] += actual_qty
|
|
else:
|
|
if self.wh_data.stock_queue[-1][0] > 0:
|
|
self.wh_data.stock_queue.append([actual_qty, incoming_rate])
|
|
else:
|
|
qty = self.wh_data.stock_queue[-1][0] + actual_qty
|
|
self.wh_data.stock_queue[-1] = [qty, incoming_rate]
|
|
else:
|
|
qty_to_pop = abs(actual_qty)
|
|
while qty_to_pop:
|
|
if not self.wh_data.stock_queue:
|
|
# Get valuation rate from last sle if exists or from valuation rate field in item master
|
|
allow_zero_valuation_rate = self.check_if_allow_zero_valuation_rate(sle.voucher_type, sle.voucher_detail_no)
|
|
if not allow_zero_valuation_rate:
|
|
_rate = get_valuation_rate(sle.item_code, sle.warehouse,
|
|
sle.voucher_type, sle.voucher_no, self.allow_zero_rate,
|
|
currency=erpnext.get_company_currency(sle.company))
|
|
else:
|
|
_rate = 0
|
|
|
|
self.wh_data.stock_queue.append([0, _rate])
|
|
|
|
index = None
|
|
if outgoing_rate > 0:
|
|
# Find the entry where rate matched with outgoing rate
|
|
for i, v in enumerate(self.wh_data.stock_queue):
|
|
if v[1] == outgoing_rate:
|
|
index = i
|
|
break
|
|
|
|
# If no entry found with outgoing rate, collapse stack
|
|
if index == None:
|
|
new_stock_value = sum((d[0]*d[1] for d in self.wh_data.stock_queue)) - qty_to_pop*outgoing_rate
|
|
new_stock_qty = sum((d[0] for d in self.wh_data.stock_queue)) - qty_to_pop
|
|
self.wh_data.stock_queue = [[new_stock_qty, new_stock_value/new_stock_qty if new_stock_qty > 0 else outgoing_rate]]
|
|
break
|
|
else:
|
|
index = 0
|
|
|
|
# select first batch or the batch with same rate
|
|
batch = self.wh_data.stock_queue[index]
|
|
if qty_to_pop >= batch[0]:
|
|
# consume current batch
|
|
qty_to_pop = _round_off_if_near_zero(qty_to_pop - batch[0])
|
|
self.wh_data.stock_queue.pop(index)
|
|
if not self.wh_data.stock_queue and qty_to_pop:
|
|
# stock finished, qty still remains to be withdrawn
|
|
# negative stock, keep in as a negative batch
|
|
self.wh_data.stock_queue.append([-qty_to_pop, outgoing_rate or batch[1]])
|
|
break
|
|
|
|
else:
|
|
# qty found in current batch
|
|
# consume it and exit
|
|
batch[0] = batch[0] - qty_to_pop
|
|
qty_to_pop = 0
|
|
|
|
stock_value = _round_off_if_near_zero(sum((flt(batch[0]) * flt(batch[1]) for batch in self.wh_data.stock_queue)))
|
|
stock_qty = _round_off_if_near_zero(sum((flt(batch[0]) for batch in self.wh_data.stock_queue)))
|
|
|
|
if stock_qty:
|
|
self.wh_data.valuation_rate = stock_value / flt(stock_qty)
|
|
|
|
if not self.wh_data.stock_queue:
|
|
self.wh_data.stock_queue.append([0, sle.incoming_rate or sle.outgoing_rate or self.wh_data.valuation_rate])
|
|
|
|
def check_if_allow_zero_valuation_rate(self, voucher_type, voucher_detail_no):
|
|
ref_item_dt = ""
|
|
|
|
if voucher_type == "Stock Entry":
|
|
ref_item_dt = voucher_type + " Detail"
|
|
elif voucher_type in ["Purchase Invoice", "Sales Invoice", "Delivery Note", "Purchase Receipt"]:
|
|
ref_item_dt = voucher_type + " Item"
|
|
|
|
if ref_item_dt:
|
|
return frappe.db.get_value(ref_item_dt, voucher_detail_no, "allow_zero_valuation_rate")
|
|
else:
|
|
return 0
|
|
|
|
def get_sle_before_datetime(self, args):
|
|
"""get previous stock ledger entry before current time-bucket"""
|
|
sle = get_stock_ledger_entries(args, "<", "desc", "limit 1", for_update=False)
|
|
sle = sle[0] if sle else frappe._dict()
|
|
return sle
|
|
|
|
def get_sle_after_datetime(self, args):
|
|
"""get Stock Ledger Entries after a particular datetime, for reposting"""
|
|
return get_stock_ledger_entries(args, ">", "asc", for_update=True, check_serial_no=False)
|
|
|
|
def raise_exceptions(self):
|
|
msg_list = []
|
|
for warehouse, exceptions in iteritems(self.exceptions):
|
|
deficiency = min(e["diff"] for e in exceptions)
|
|
|
|
if ((exceptions[0]["voucher_type"], exceptions[0]["voucher_no"]) in
|
|
frappe.local.flags.currently_saving):
|
|
|
|
msg = _("{0} units of {1} needed in {2} to complete this transaction.").format(
|
|
abs(deficiency), frappe.get_desk_link('Item', exceptions[0]["item_code"]),
|
|
frappe.get_desk_link('Warehouse', warehouse))
|
|
else:
|
|
msg = _("{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.").format(
|
|
abs(deficiency), frappe.get_desk_link('Item', exceptions[0]["item_code"]),
|
|
frappe.get_desk_link('Warehouse', warehouse),
|
|
exceptions[0]["posting_date"], exceptions[0]["posting_time"],
|
|
frappe.get_desk_link(exceptions[0]["voucher_type"], exceptions[0]["voucher_no"]))
|
|
|
|
if msg:
|
|
msg_list.append(msg)
|
|
|
|
if msg_list:
|
|
message = "\n\n".join(msg_list)
|
|
if self.verbose:
|
|
frappe.throw(message, NegativeStockError, title='Insufficient Stock')
|
|
else:
|
|
raise NegativeStockError(message)
|
|
|
|
def update_bin(self):
|
|
# update bin for each warehouse
|
|
for warehouse, data in iteritems(self.data):
|
|
bin_doc = get_bin(self.item_code, warehouse)
|
|
bin_doc.update({
|
|
"valuation_rate": data.valuation_rate,
|
|
"actual_qty": data.qty_after_transaction,
|
|
"stock_value": data.stock_value
|
|
})
|
|
bin_doc.flags.via_stock_ledger_entry = True
|
|
bin_doc.save(ignore_permissions=True)
|
|
|
|
def get_previous_sle(args, for_update=False):
|
|
"""
|
|
get the last sle on or before the current time-bucket,
|
|
to get actual qty before transaction, this function
|
|
is called from various transaction like stock entry, reco etc
|
|
|
|
args = {
|
|
"item_code": "ABC",
|
|
"warehouse": "XYZ",
|
|
"posting_date": "2012-12-12",
|
|
"posting_time": "12:00",
|
|
"sle": "name of reference Stock Ledger Entry"
|
|
}
|
|
"""
|
|
args["name"] = args.get("sle", None) or ""
|
|
sle = get_stock_ledger_entries(args, "<=", "desc", "limit 1", for_update=for_update)
|
|
return sle and sle[0] or {}
|
|
|
|
def get_stock_ledger_entries(previous_sle, operator=None,
|
|
order="desc", limit=None, for_update=False, debug=False, check_serial_no=True):
|
|
"""get stock ledger entries filtered by specific posting datetime conditions"""
|
|
conditions = " and timestamp(posting_date, posting_time) {0} timestamp(%(posting_date)s, %(posting_time)s)".format(operator)
|
|
if previous_sle.get("warehouse"):
|
|
conditions += " and warehouse = %(warehouse)s"
|
|
elif previous_sle.get("warehouse_condition"):
|
|
conditions += " and " + previous_sle.get("warehouse_condition")
|
|
|
|
if check_serial_no and previous_sle.get("serial_no"):
|
|
# conditions += " and serial_no like {}".format(frappe.db.escape('%{0}%'.format(previous_sle.get("serial_no"))))
|
|
serial_no = previous_sle.get("serial_no")
|
|
conditions += (""" and
|
|
(
|
|
serial_no = {0}
|
|
or serial_no like {1}
|
|
or serial_no like {2}
|
|
or serial_no like {3}
|
|
)
|
|
""").format(frappe.db.escape(serial_no), frappe.db.escape('{}\n%'.format(serial_no)),
|
|
frappe.db.escape('%\n{}'.format(serial_no)), frappe.db.escape('%\n{}\n%'.format(serial_no)))
|
|
|
|
if not previous_sle.get("posting_date"):
|
|
previous_sle["posting_date"] = "1900-01-01"
|
|
if not previous_sle.get("posting_time"):
|
|
previous_sle["posting_time"] = "00:00"
|
|
|
|
if operator in (">", "<=") and previous_sle.get("name"):
|
|
conditions += " and name!=%(name)s"
|
|
|
|
return frappe.db.sql("""
|
|
select *, timestamp(posting_date, posting_time) as "timestamp"
|
|
from `tabStock Ledger Entry`
|
|
where item_code = %%(item_code)s
|
|
and is_cancelled = 0
|
|
%(conditions)s
|
|
order by timestamp(posting_date, posting_time) %(order)s, creation %(order)s
|
|
%(limit)s %(for_update)s""" % {
|
|
"conditions": conditions,
|
|
"limit": limit or "",
|
|
"for_update": for_update and "for update" or "",
|
|
"order": order
|
|
}, previous_sle, as_dict=1, debug=debug)
|
|
|
|
def get_sle_by_voucher_detail_no(voucher_detail_no, excluded_sle=None):
|
|
return frappe.db.get_value('Stock Ledger Entry',
|
|
{'voucher_detail_no': voucher_detail_no, 'name': ['!=', excluded_sle]},
|
|
['item_code', 'warehouse', 'posting_date', 'posting_time', 'timestamp(posting_date, posting_time) as timestamp'],
|
|
as_dict=1)
|
|
|
|
def get_valuation_rate(item_code, warehouse, voucher_type, voucher_no,
|
|
allow_zero_rate=False, currency=None, company=None, raise_error_if_no_rate=True):
|
|
# Get valuation rate from last sle for the same item and warehouse
|
|
if not company:
|
|
company = erpnext.get_default_company()
|
|
|
|
last_valuation_rate = frappe.db.sql("""select valuation_rate
|
|
from `tabStock Ledger Entry`
|
|
where
|
|
item_code = %s
|
|
AND warehouse = %s
|
|
AND valuation_rate >= 0
|
|
AND NOT (voucher_no = %s AND voucher_type = %s)
|
|
order by posting_date desc, posting_time desc, name desc limit 1""", (item_code, warehouse, voucher_no, voucher_type))
|
|
|
|
if not last_valuation_rate:
|
|
# Get valuation rate from last sle for the item against any warehouse
|
|
last_valuation_rate = frappe.db.sql("""select valuation_rate
|
|
from `tabStock Ledger Entry`
|
|
where
|
|
item_code = %s
|
|
AND valuation_rate > 0
|
|
AND NOT(voucher_no = %s AND voucher_type = %s)
|
|
order by posting_date desc, posting_time desc, name desc limit 1""", (item_code, voucher_no, voucher_type))
|
|
|
|
if last_valuation_rate:
|
|
return flt(last_valuation_rate[0][0])
|
|
|
|
# If negative stock allowed, and item delivered without any incoming entry,
|
|
# system does not found any SLE, then take valuation rate from Item
|
|
valuation_rate = frappe.db.get_value("Item", item_code, "valuation_rate")
|
|
|
|
if not valuation_rate:
|
|
# try Item Standard rate
|
|
valuation_rate = frappe.db.get_value("Item", item_code, "standard_rate")
|
|
|
|
if not valuation_rate:
|
|
# try in price list
|
|
valuation_rate = frappe.db.get_value('Item Price',
|
|
dict(item_code=item_code, buying=1, currency=currency),
|
|
'price_list_rate')
|
|
|
|
if not allow_zero_rate and not valuation_rate and raise_error_if_no_rate \
|
|
and cint(erpnext.is_perpetual_inventory_enabled(company)):
|
|
frappe.local.message_log = []
|
|
form_link = get_link_to_form("Item", item_code)
|
|
|
|
message = _("Valuation Rate for the Item {0}, is required to do accounting entries for {1} {2}.").format(form_link, voucher_type, voucher_no)
|
|
message += "<br><br>" + _("Here are the options to proceed:")
|
|
solutions = "<li>" + _("If the item is transacting as a Zero Valuation Rate item in this entry, please enable 'Allow Zero Valuation Rate' in the {0} Item table.").format(voucher_type) + "</li>"
|
|
solutions += "<li>" + _("If not, you can Cancel / Submit this entry") + " {0} ".format(frappe.bold("after")) + _("performing either one below:") + "</li>"
|
|
sub_solutions = "<ul><li>" + _("Create an incoming stock transaction for the Item.") + "</li>"
|
|
sub_solutions += "<li>" + _("Mention Valuation Rate in the Item master.") + "</li></ul>"
|
|
msg = message + solutions + sub_solutions + "</li>"
|
|
|
|
frappe.throw(msg=msg, title=_("Valuation Rate Missing"))
|
|
|
|
return valuation_rate
|
|
|
|
def update_qty_in_future_sle(args, allow_negative_stock=None):
|
|
frappe.db.sql("""
|
|
update `tabStock Ledger Entry`
|
|
set qty_after_transaction = qty_after_transaction + {qty}
|
|
where
|
|
item_code = %(item_code)s
|
|
and warehouse = %(warehouse)s
|
|
and voucher_no != %(voucher_no)s
|
|
and is_cancelled = 0
|
|
and (timestamp(posting_date, posting_time) > timestamp(%(posting_date)s, %(posting_time)s)
|
|
or (
|
|
timestamp(posting_date, posting_time) = timestamp(%(posting_date)s, %(posting_time)s)
|
|
and creation > %(creation)s
|
|
)
|
|
)
|
|
""".format(qty=args.actual_qty), args)
|
|
|
|
validate_negative_qty_in_future_sle(args, allow_negative_stock)
|
|
|
|
def validate_negative_qty_in_future_sle(args, allow_negative_stock=None):
|
|
allow_negative_stock = allow_negative_stock \
|
|
or cint(frappe.db.get_single_value("Stock Settings", "allow_negative_stock"))
|
|
|
|
if args.actual_qty < 0 and not allow_negative_stock:
|
|
sle = get_future_sle_with_negative_qty(args)
|
|
if sle:
|
|
message = _("{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.").format(
|
|
abs(sle[0]["qty_after_transaction"]),
|
|
frappe.get_desk_link('Item', args.item_code),
|
|
frappe.get_desk_link('Warehouse', args.warehouse),
|
|
sle[0]["posting_date"], sle[0]["posting_time"],
|
|
frappe.get_desk_link(sle[0]["voucher_type"], sle[0]["voucher_no"]))
|
|
|
|
frappe.throw(message, NegativeStockError, title='Insufficient Stock')
|
|
|
|
def get_future_sle_with_negative_qty(args):
|
|
return frappe.db.sql("""
|
|
select
|
|
qty_after_transaction, posting_date, posting_time,
|
|
voucher_type, voucher_no
|
|
from `tabStock Ledger Entry`
|
|
where
|
|
item_code = %(item_code)s
|
|
and warehouse = %(warehouse)s
|
|
and voucher_no != %(voucher_no)s
|
|
and timestamp(posting_date, posting_time) >= timestamp(%(posting_date)s, %(posting_time)s)
|
|
and is_cancelled = 0
|
|
and qty_after_transaction < 0
|
|
order by timestamp(posting_date, posting_time) asc
|
|
limit 1
|
|
""", args, as_dict=1)
|
|
|
|
def _round_off_if_near_zero(number: float, precision: int = 6) -> float:
|
|
""" Rounds off the number to zero only if number is close to zero for decimal
|
|
specified in precision. Precision defaults to 6.
|
|
"""
|
|
if flt(number) < (1.0 / (10**precision)):
|
|
return 0
|
|
|
|
return flt(number)
|