def postprocess(source, target):
from \
.dfactoring \
.doctype \
.party_portfolio \
.party_portfolio \
import \
get_temporary_opening_account \
as get_temp_acc
default_uom = db.get_single_value("Stock Settings",
"stock_uom") or _("Nos")
cost_center = db.get_value("Company", source.company, "cost_center")
target.append(
"items", {
"doctype": "Purchase Invoice Item",
"parenttype": "Purchase Invoice",
"parentfield": "items",
"rate": source.total_amount,
"amount": source.total_amount,
"qty": 1,
"conversion_factor": 1,
"uom": default_uom,
"cost_center": cost_center,
"item_name": _("Opening Invoice Item"),
"description": _("Opening Invoice Item"),
"expense_account": get_temp_acc(source.company),
})
def get_parent_department(option):
name = get_department(option)
doctype = "Department"
fieldname = "parent_department"
return database.get_value(doctype, name, fieldname)
def get_item_dict():
default_uom = db.get_single_value("Stock Settings",
"stock_uom") or _("Nos")
cost_center = db.get_value("Company", self.get("company"),
"cost_center")
if not cost_center:
frappe.throw(
_("Please set the Default Cost Center in {0} company") \
.format(frappe.bold(self.get("company")))
)
item_name = _("Opening Invoice Item")
return frappe._dict({
"uom":
default_uom,
"rate":
flt(self.due_capital_balance),
"qty":
1.000,
"conversion_factor":
1.000,
"item_name":
item_name,
"description":
item_name,
income_expense_account_field:
self.get("temporary_opening_account"),
"cost_center":
cost_center,
})
def make_sales_quotation(source_name, target_doc=None):
cost_estimation = database.get_value("Cost Estimation",
source_name,
["generated_on", "valid_until"],
as_dict=1)
if cost_estimation.valid_until and (
cost_estimation.valid_until < cost_estimation.generated_on
or cost_estimation.valid_until < getdate(nowdate())):
frappe.throw(translate("Validity period of this quotation has ended."))
return _make_sales_quotation(source_name, target_doc)
def fwd_uti_cancel(self):
if self.forward_contract:
existing_row_id = db.get_value("Forward Booking Utilization",
filters={
"parent": self.forward_contract,
"payment_entry": self.name
},
fieldname="name")
frappe.delete_doc("Forward Booking Utilization", existing_row_id)
db.commit()
def create_igst_jv(self):
if self.export_type == "With Payment of Tax" and self.currency != "INR" and self.total_igst_amount and self.shipping_bill_date:
refund_receivable_account = db.get_value(
"Company", {"company_name": self.company},
"refund_receivable_on_export_account")
igst_payable_account = db.get_value("Company",
{"company_name": self.company},
"igst_payable_account")
cost_center = db.get_value("Company", {"company_name": self.company},
"cost_center")
if not refund_receivable_account:
frappe.throw(
_("Set Refund Receivable on Export Account in Company"))
elif not igst_payable_account:
frappe.throw(_("Set IGST Payable Account in Company"))
elif not cost_center:
frappe.throw(_("Set Default Cost Center in Company"))
else:
jv = frappe.new_doc("Journal Entry")
jv.voucher_type = "GST Payable Entry"
jv.posting_date = self.shipping_bill_date
jv.company = self.company
jv.cheque_no = self.name
jv.cheque_date = self.shipping_bill_date
jv.user_remark = "IGST Payable against" + self.name + " for " + self.customer
jv.append(
"accounts", {
"account": refund_receivable_account,
"cost_center": cost_center,
"debit_in_account_currency": self.total_igst_amount
})
jv.append(
"accounts", {
"account": igst_payable_account,
"cost_center": cost_center,
"credit_in_account_currency": self.total_igst_amount
})
jv.save(ignore_permissions=True)
self.db_set('gst_jv', jv.name)
jv.submit()
db.commit()
def create_drawback_jv(self):
if self.currency != "INR" and self.total_duty_drawback:
drawback_receivable_account = db.get_value(
"Company", {"company_name": self.company},
"duty_drawback_receivable_account")
drawback_income_account = db.get_value("Company",
{"company_name": self.company},
"duty_drawback_income_account")
drawback_cost_center = db.get_value("Company",
{"company_name": self.company},
"duty_drawback_cost_center")
if not drawback_receivable_account:
frappe.throw(_("Set Duty Drawback Receivable Account in Company"))
elif not drawback_income_account:
frappe.throw(_("Set Duty Drawback Income Account in Company"))
elif not drawback_cost_center:
frappe.throw(_("Set Duty Drawback Cost Center in Company"))
else:
jv = frappe.new_doc("Journal Entry")
jv.voucher_type = "Duty Drawback Entry"
jv.posting_date = self.posting_date
jv.company = self.company
jv.cheque_no = self.name
jv.cheque_date = self.posting_date
jv.user_remark = "Duty draw back against" + self.name + " for " + self.customer
jv.append(
"accounts", {
"account": drawback_receivable_account,
"cost_center": drawback_cost_center,
"debit_in_account_currency": self.total_duty_drawback
})
jv.append(
"accounts", {
"account": drawback_income_account,
"cost_center": drawback_cost_center,
"credit_in_account_currency": self.total_duty_drawback
})
jv.save(ignore_permissions=True)
self.db_set('duty_drawback_jv', jv.name)
jv.submit()
db.commit()
def get_warehouse(doc):
doctype = "Item Default"
filters = {
"company": self.company,
"parent": doc.item,
"parenttype": "Item",
"parentfield": "item_defaults",
}
fieldname = "default_warehouse"
return database.get_value(doctype, filters, fieldname)
def get_temporary_opening_account(company=None):
if not company:
return
accounts = frappe.get_all("Account",
filters={
'company':
company,
'account_type':
'Temporary',
'account_currency':
db.get_value("Company", company,
"default_currency")
})
if not accounts:
accounts = frappe.get_all("Account",
filters={
'company': company,
'account_type': 'Temporary',
})
if not accounts:
accounts = frappe.get_all("Account",
filters={
'company':
company,
'account_type':
'Income Account',
'account_currency':
db.get_value("Company", company,
"default_currency"),
})
if not accounts:
frappe.throw(
_("Please add a Temporary Opening account in Chart of Accounts"))
return accounts[0].name
def update_bin(args,
allow_negative_stock=False,
via_landed_cost_voucher=False):
is_stock_item = db.get_value('Item', args.get("item_code"),
'is_stock_item')
if is_stock_item:
bin_ = get_bin(args.get("item_code"), args.get("warehouse"))
bin_.update_stock_ = update_stock_.__get__(bin_, Bin)
bin_.update_stock_(args, allow_negative_stock, via_landed_cost_voucher)
return bin_
else:
msgprint(
_("Item {0} ignored since it is not a stock item").format(
args.get("item_code")))
def upadte_item_price(item, price_list, per_unit_price):
if db.exists("Item Price",{"item_code":item,"price_list":price_list}):
name = db.get_value("Item Price",{"item_code":item,"price_list":price_list},'name')
db.set_value("Item Price",name,"price_list_rate", per_unit_price)
else:
item_price = frappe.new_doc("Item Price")
item_price.price_list = price_list
item_price.item_code = item
item_price.price_list_rate = per_unit_price
item_price.save()
db.commit()
return "Item Price Updated!"
def get_ball_mill(self):
if not self.ball_mill_ref:
frappe.throw(_("Please select Ball Mill Data Sheet!"))
bm = frappe.get_doc("Ball Mill Data Sheet", self.ball_mill_ref)
self.product_name = bm.product_name
self.link_to = "Customer"
self.party = bm.customer_name
self.batch_yield = bm.total_yield
customer_name, destination = db.get_value(
"Customer", bm.customer_name, ['customer_name', 'territory'])
self.party_name = customer_name
self.destination_1 = self.destination = destination
self.set("details", [])
total_amount = 0.0
for row in bm.items:
price = get_spare_price(row.item_name,
"Standard Buying").price_list_rate
if row.batch_yield:
bomyield = frappe.db.get_value("BOM", {'item': row.item_name},
"batch_yield")
if bomyield != 0:
rate = (price * flt(bomyield)) / row.batch_yield
else:
rate = (price * 2.2) / row.batch_yield
else:
rate = price
amount = rate * row.quantity
total_amount += amount
self.append(
'details', {
'item_name': row.item_name,
'batch_yield': row.batch_yield,
'quantity': row.quantity,
'rate': rate,
'price_list_rate': price,
'amount': amount,
})
self.total_amount = total_amount
self.total_qty = bm.total_qty
self.per_unit_price = total_amount / bm.total_qty
def get_product_features(item_code):
doctype = "Item"
name = item_code
fields = ("ref_doctype", "ref_docname")
ref_doctype, ref_docname = database.get_value(
doctype, name, fields)
if not ref_doctype or not ref_docname \
or not database.exists(ref_doctype, ref_docname):
return []
doc = frappe.get_doc(ref_doctype, ref_docname)
options = doc.get_full_product_options()
return options.split(", ")
def validate_product_assembly(self):
doctype = self.meta \
.get_field("product_assembly") \
.options
docname = self.product_assembly
fieldname = "product_profile"
value = database.get_value(doctype, docname, fieldname)
errmsg = translate("Product Assembly: {} is not "
"a type of Product Profile: {}")
if value != self.product_profile:
formatted_error = errmsg.format(self.product_assembly,
self.product_profile)
frappe.throw(formatted_error)
def set_printing_sides(self):
doctype = "Product Assembly"
name = self.product_assembly
fields = ("front_colors", "pantone_colors", "back_colors",
"pantone_back_colors")
front_colors, pantone_colors, back_colors, pantone_back_colors \
= database.get_value(doctype, name, fields)
self.printing_sides = "Sin Impresión"
if cint(front_colors) > 0 \
or cint(pantone_colors) > 0:
self.printing_sides = translate("One Side")
if cint(back_colors) > 0 \
or cint(pantone_back_colors) > 0:
self.printing_sides = translate("Two Sides")
def before_submit(self):
if self.truck_part == "Battery" or self.truck_part == "Tyre":
if self.include_sr_no and self.number_of_parts != len(
self.serial_number):
throw(
_("Please set total %d serial numbers" %
self.number_of_parts))
serial_list = []
for d in self.serial_number:
serial = db.get_value("Truck Parts Inventory",
{"serial_number": d.serial_no})
if serial:
throw(_("Serial number already exists for row %d!" % d.idx))
if d.serial_no not in serial_list:
serial_list.append(d.serial_no)
else:
throw(_("Similar serial number found in row %d" % d.idx))
def validate_duplicates_production_orders(self):
if not self.project_center:
return "production order without project center"
doctype = self.doctype
filters = {
"name": ["!=", self.name],
"project_center": self.project_center
}
value = database.get_value(doctype, filters)
if not value:
return "ok"
err_msg = translate("A Production Order exists "
"against this Project Center.")
frappe.throw(err_msg.format(value))
def fwd_uti(self):
if self.forward_contract:
target_doc = frappe.get_doc("Forward Booking", self.forward_contract)
existing_row_id = db.get_value("Forward Booking Utilization",
filters={
"parent": self.forward_contract,
"payment_entry": self.name
},
fieldname="name")
if not existing_row_id:
target_doc.append(
"payment_entries", {
"date": self.posting_date,
"party_type": self.party_type,
"party": self.party,
"paid_amount": self.paid_amount,
"received_amount": self.received_amount,
"payment_entry": self.name
})
target_doc.save()
db.commit()
def validate(self):
if db.get_value(
"Vehicle Owner Contract", {"name": self.name}, "contract_status"
) in ["Cancelled", "Terminated", "Rejected"]:
frappe.throw(_("Cannot modify contracts in this status."))
def get_customer_ref_code(item_code, customer):
ref_code = db.get_value("Item Customer Detail", {'parent': item_code, 'customer_name': customer}, 'ref_code')
return ref_code if ref_code else ''
def get_expected_start_date(project_center):
doctype = "Project Center"
name = project_center
fieldname = "expected_start_date"
return database.get_value(doctype, name, fieldname)
def get_work_station(option):
doctype = "Product Feature"
name = option
fieldname = "default_work_station"
return database.get_value(doctype, name, fieldname)
def get_department(option):
doctype = "Product Feature"
name = option
fieldname = "department"
return database.get_value(doctype, name, fieldname)
def before_submit(self):
for d in self.service_detail:
if d.type == "Change from Inventory" or d.type == "Change at Garage":
old_part = get_doc("Truck Parts Inventory", d.part_no)
old_part.part_status = "Available"
old_part.truck_no = ""
old_part.warehouse = d.warehouse
old_part.save()
if d.type == "Change from Inventory":
if not d.new_part_no:
throw(
_("Please provide New Part No. in row %d" % d.idx))
update_part = get_doc("Truck Parts Inventory",
d.new_part_no)
update_part.part_status = "In Use"
update_part.truck_no = self.truck_no
update_part.save()
else:
if not d.serial_number:
throw(
_("Please provide serial number in row %d" %
d.idx))
elif not d.part_company:
throw(
_("Please provide part company in row %d" % d.idx))
elif not d.purchase_rate:
throw(
_("Please provide purchase rate in row %d" %
d.idx))
elif not d.purchase_date:
throw(
_("Please provide purchase date in row %d" %
d.idx))
elif not d.new_part_link:
inventory = new_doc("Truck Parts Inventory")
inventory.truck_part = d.service_item
inventory.part_company = d.part_company
inventory.warehouse = d.warehouse
inventory.purchase_through = "Maintenance Log"
inventory.ref_link = self.name
inventory.purchase_rate = d.purchase_rate
inventory.purchase_date = d.purchase_date
inventory.serial_number = d.serial_number
inventory.title = d.service_item + "-" + d.serial_number
inventory.part_status = "In Use"
inventory.truck_no = self.truck_no
inventory.save()
d.new_part_link = inventory.name
db.commit()
stock_entry = None
cost_center = db.get_value("Company", self.company, "cost_center")
for d in self.consumable_details:
if d.from_inventory:
if not d.warehouse:
throw(
_("Please provide warehouse in row %d of Consumable Service Table"
% d.idx))
else:
if not stock_entry:
stock_entry = new_doc("Stock Entry")
stock_entry.company = self.company
stock_entry.purpose = "Material Issue"
stock_entry.append(
"items", {
"s_warehouse": d.warehouse,
"item_code": d.item_code,
"qty": d.used_qty,
"expense_account": self.expense_account,
"cost_center": cost_center
})
else:
stock_entry.append(
"items", {
"s_warehouse": d.warehouse,
"item_code": d.item_code,
"qty": d.used_qty,
"expense_account": self.expense_account,
"cost_center": cost_center
})
if stock_entry:
stock_entry.save()
stock_entry.submit()
db.commit()
url = get_url_to_form("Stock Entry", stock_entry.name)
idx = url.find("/desk#")
stock_entry_url = url[:idx] + ":8081" + url[idx:]
link = "<b><a href='{url}'>{name}</a></b>".format(
url=stock_entry_url, name=stock_entry.name)
msgprint(_("New Stock Entry {0} created!".format(link)),
title="Success",
indicator='green')
def set_allow_printing(self):
doctype = "Product Profile"
name = self.product_profile
fieldname = "allow_printing"
self.allow_printing = database.get_value(doctype, name, fieldname)
def set_paperboard(self):
doctype = "Product Assembly"
name = self.product_assembly
fieldname = "paperboard"
self.paperboard = database.get_value(doctype, name, fieldname)
def get_gl_entries(self, warehouse_account=None, default_expense_account=None,
default_cost_center=None):
default_expense_account = self.expense_account
default_cost_center = self.cost_center
if not self.cost_center:
msgprint(_("Please enter Cost Center"), raise_exception=1)
if not warehouse_account:
warehouse_account = get_warehouse_account_map()
sle_map = self.get_stock_ledger_details()
voucher_details = self.get_voucher_details(default_expense_account, default_cost_center, sle_map)
gl_list = []
warehouse_with_no_account = []
for item_row in voucher_details:
sle_list = sle_map.get(item_row.name)
if sle_list:
for sle in sle_list:
if warehouse_account.get(sle.warehouse):
# from warehouse account
self.check_expense_account(item_row)
# If the item does not have the allow zero valuation rate flag set
# and ( valuation rate not mentioned in an incoming entry
# or incoming entry not found while delivering the item),
# try to pick valuation rate from previous sle or Item master and update in SLE
# Otherwise, throw an exception
if not sle.stock_value_difference and self.doctype != "Inventory Reconciliation" \
and not item_row.get("allow_zero_valuation_rate"):
sle = self.update_stock_ledger_entries(sle)
gl_list.append(self.get_gl_dict({
"account": warehouse_account[sle.warehouse]["account"],
"against": item_row.expense_account,
"cost_center": item_row.cost_center,
"remarks": self.get("remarks") or "Accounting Entry for Stock",
"debit": flt(sle.stock_value_difference, 2),
}, warehouse_account[sle.warehouse]["account_currency"]))
# to target warehouse / expense account
gl_list.append(self.get_gl_dict({
"account": item_row.expense_account,
"against": warehouse_account[sle.warehouse]["account"],
"cost_center": item_row.cost_center,
"remarks": self.get("remarks") or "Accounting Entry for Stock",
"credit": flt(sle.stock_value_difference, 2),
"project": item_row.get("project") or self.get("project")
}))
elif sle.warehouse not in warehouse_with_no_account:
warehouse_with_no_account.append(sle.warehouse)
if warehouse_with_no_account:
for wh in warehouse_with_no_account:
if db.get_value("Warehouse", wh, "company"):
throw(_("Warehouse {0} is not linked to any account, please "
"mention the account in the warehouse record or set "
"default inventory account in company {1}.").format(wh, self.company))
return process_gl_map(gl_list)
