def create_payment_entry(self, submit=True):
"""create entry"""
frappe.flags.ignore_account_permission = True
ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
if self.reference_doctype in ["Sales Invoice", "POS Invoice"]:
party_account = ref_doc.debit_to
elif self.reference_doctype == "Purchase Invoice":
party_account = ref_doc.credit_to
else:
party_account = get_party_account("Customer", ref_doc.get("customer"), ref_doc.company)
party_account_currency = ref_doc.get("party_account_currency") or get_account_currency(
party_account
)
bank_amount = self.grand_total
if (
party_account_currency == ref_doc.company_currency and party_account_currency != self.currency
):
party_amount = ref_doc.base_grand_total
else:
party_amount = self.grand_total
payment_entry = get_payment_entry(
self.reference_doctype,
self.reference_name,
party_amount=party_amount,
bank_account=self.payment_account,
bank_amount=bank_amount,
)
payment_entry.update(
{
"reference_no": self.name,
"reference_date": nowdate(),
"remarks": "Payment Entry against {0} {1} via Payment Request {2}".format(
self.reference_doctype, self.reference_name, self.name
),
}
)
if payment_entry.difference_amount:
company_details = get_company_defaults(ref_doc.company)
payment_entry.append(
"deductions",
{
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount,
},
)
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
return payment_entry
def create_payment_entry(self, submit=True):
"""create entry"""
frappe.flags.ignore_account_permission = True
ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
if self.reference_doctype == "Sales Invoice":
party_account = ref_doc.debit_to
elif self.reference_doctype == "Purchase Invoice":
party_account = ref_doc.credit_to
else:
party_account = get_party_account("Customer", ref_doc.get("customer"), ref_doc.company)
party_account_currency = ref_doc.get("party_account_currency") or get_account_currency(party_account)
bank_amount = self.grand_total
if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
party_amount = ref_doc.base_grand_total
else:
party_amount = self.grand_total
payment_entry = get_payment_entry(self.reference_doctype, self.reference_name,
party_amount=party_amount, bank_account=self.payment_account, bank_amount=bank_amount)
payment_entry.update({
"reference_no": self.name,
"reference_date": nowdate(),
"remarks": "Payment Entry against {0} {1} via Payment Request {2}".format(self.reference_doctype,
self.reference_name, self.name)
})
if payment_entry.difference_amount:
company_details = get_company_defaults(ref_doc.company)
payment_entry.append("deductions", {
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount
})
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
return payment_entry
def return_custom_payment_entry(doc,
submit=False,
party_amount=0.0,
bank_amount=0.0,
payment_request_doc=None): #CONTEXT=INVOICE
payment_entry = get_payment_entry(
doc.doctype,
doc.name,
party_amount=party_amount,
bank_account=payment_request_doc.payment_account,
bank_amount=bank_amount)
print(f"at the custom method")
payment_entry.update({
"reference_no":
doc.name,
"reference_date":
nowdate(),
"remarks":
"Payment Entry against {0} {1} via Payment Request {2}".format(
doc.doctype, doc.name, payment_request_doc.name)
})
if payment_entry.difference_amount:
company_details = get_company_defaults(doc.company)
payment_entry.append(
"deductions", {
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount
})
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
return payment_entry
def make_sales_invoice(self):
si_doc = frappe.new_doc('Sales Invoice')
si_doc.company = self.company
si_doc.currency = frappe.db.get_value("Company", self.company,
"default_currency")
si_doc.customer = self.customer_name
si_doc.posting_date = nowdate()
si_doc.due_date = nowdate()
si_doc.update_stock = 1
si_doc.x_sales_entry = self.name
for d in self.sales_item:
si_doc.append(
"items", {
"item_code": d.item_code,
"qty": (d.available_qty - d.qty),
"rate": d.rate,
"cost_center": self.cost_center,
"warehouse": self.warehouse
})
si_doc.set_missing_values()
si_doc.flags.ignore_mandatory = True
si_doc.insert(ignore_permissions=True)
si_doc.submit()
if frappe.db.exists("Sales Invoice", {"name": si_doc.name}):
apply_adjustment = False
adj_to_be_applied = False
company = si_doc.company
frappe.flags.ignore_account_permission = True
company_details = get_company_defaults(company)
party_account = si_doc.debit_to
party_account_currency = si_doc.get(
"party_account_currency") or get_account_currency(
party_account)
bank_amount = si_doc.grand_total
if party_account_currency == si_doc.company_currency and party_account_currency != si_doc.currency:
party_amount = si_doc.base_grand_total
else:
party_amount = si_doc.grand_total
if self.difference_amount >= 0:
diff_amount = self.difference_amount
else:
apply_adjustment = True
adj_to_be_applied = True
diff_amount = -1 * self.difference_amount
for d in self.payment_entry:
mode_of_payment = d.mode_of_payment
if apply_adjustment:
if d.amount > diff_amount:
amount = d.amount - diff_amount
apply_adjustment = False
else:
amount = d.amount
else:
amount = d.amount
account = frappe.db.sql(
"""select default_account
from `tabMode of Payment Account`
where company = %s and parent = %s""", (company, mode_of_payment))
if account:
payment_account = account[0][0]
else:
frappe.throw(_("Please set up account in mode of payment"))
payment_entry = get_payment_entry("Sales Invoice",
si_doc.name,
party_amount=party_amount,
bank_account=payment_account,
bank_amount=amount)
payment_entry.update({
"reference_no":
self.name,
"reference_date":
nowdate(),
"remarks":
"Payment Entry against {0} {1} via Sales Enty {2}".format(
"Sales Invoice", si_doc.name, self.name),
"mode_of_payment":
mode_of_payment,
"base_paid_amount":
amount,
"base_received_amount":
amount,
"base_total_allocated_amount":
amount,
"paid_amount":
amount,
"received_amount":
amount,
"total_allocated_amount":
amount,
"allocate_payment_amount":
0,
"difference_amount":
0
})
payment_entry.set("references", [])
payment_entry.append(
"references", {
"__islocal": 1,
"allocated_amount": amount,
"docstatus": 0,
"doctype": "Payment Entry Reference",
"due_date": nowdate(),
"exchange_rate": 1.0,
"idx": 1,
"outstanding_amount": si_doc.outstanding_amount,
"parentfield": "references",
"parenttype": "Payment Entry",
"reference_doctype": "Sales Invoice",
"reference_name": si_doc.name,
"total_amount": si_doc.outstanding_amount
})
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
if apply_adjustment:
frappe.throw(
_("Difference Amount cannot be adjusted as Payment Amount per Mode of Payment is less than amount to be adjusted"
))
if diff_amount > 0:
jv = frappe.new_doc("Journal Entry")
jv.posting_date = nowdate()
jv.company = si_doc.company
jv.user_remark = "Write Off Journal Entry against {0} {1} via Sales Entry {2}".format(
"Sales Invoice", si_doc.name, self.name)
if adj_to_be_applied:
jv.set("accounts", [{
"party_type": "Customer",
"party": si_doc.customer,
"account": si_doc.debit_to,
"cost_center": self.cost_center,
"credit_in_account_currency": diff_amount,
"debit_in_account_currency": 0,
"exchange_rate": 1,
"is_advance": "Yes"
}, {
"account": company_details.write_off_account,
"cost_center": self.cost_center,
"debit_in_account_currency": diff_amount,
"credit_in_account_currency": 0,
"exchange_rate": 1
}])
adj_to_be_applied = False
else:
jv.set("accounts", [{
"party_type": "Customer",
"party": si_doc.customer,
"account": si_doc.debit_to,
"reference_type": "Sales Invoice",
"reference_name": si_doc.name,
"cost_center": self.cost_center,
"credit_in_account_currency": diff_amount,
"debit_in_account_currency": 0,
"exchange_rate": 1
}, {
"account": company_details.write_off_account,
"cost_center": self.cost_center,
"debit_in_account_currency": diff_amount,
"credit_in_account_currency": 0,
"exchange_rate": 1
}])
jv.insert(ignore_permissions=True)
jv.submit()
def create_payment_entry(self, submit=True):
"""Generate a payment entry against a quotation or sales order"""
frappe.flags.ignore_account_permission = True
ref_doc = frappe.get_doc(self.reference_doctype, self.reference_name)
#select debit_to or credit_to account depending on sales order or purchase order
if self.reference_doctype == "Sales Invoice":
party_account = ref_doc.debit_to
elif self.reference_doctype == "Purchase Invoice":
party_account = ref_doc.credit_to
else:
party_account = get_party_account("Customer",
ref_doc.get("customer"),
ref_doc.company)
party_account_currency = ref_doc.get(
"party_account_currency") or get_account_currency(party_account)
#get payment amount from the payment request document
bank_amount = self.grand_total
#If the currency of the customer matches with the currency of the quotation but not of the payment request
if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
party_amount = ref_doc.base_grand_total
else:
party_amount = self.grand_total
#create a sales order if the payment request has been made against a quotation from a shopping cart
if self.reference_doctype == "Quotation" and (
hasattr(ref_doc, "order_type")
and getattr(ref_doc, "order_type") == "Shopping Cart"):
#we save with ignore_permissions and submit the quotation
ref_doc.save(ignore_permissions=True)
ref_doc.submit()
frappe.db.commit()
#convert the quotation to a sales order
from erpnext.selling.doctype.quotation.quotation import _make_sales_order
sales_order = frappe.get_doc(
_make_sales_order(self.reference_name,
ignore_permissions=True))
sales_order.payment_schedule = []
sales_order.flags.ignore_permissions = True
sales_order.insert()
sales_order.submit()
#emptying out the cart
if hasattr(frappe.local, "cookie_manager"):
frappe.local.cookie_manager.delete_cookie("cart_count")
#make a payment entry against the newly created sales order
payment_entry = get_payment_entry(
"Sales Order",
sales_order.name,
party_amount=party_amount,
bank_account=self.payment_account,
bank_amount=bank_amount)
else:
#reference document is the sales order in the payment request that was passed
payment_entry = get_payment_entry(
self.reference_doctype,
self.reference_name,
party_amount=party_amount,
bank_account=self.payment_account,
bank_amount=bank_amount)
#updating details about the payment request in the payment entry
payment_entry.update({
"reference_no":
self.name,
"reference_date":
nowdate(),
"remarks":
"Payment Entry against {0} {1} via Payment Request {2}".format(
self.reference_doctype, self.reference_name, self.name)
})
if payment_entry.difference_amount:
company_details = get_company_defaults(ref_doc.company)
payment_entry.append(
"deductions", {
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount
})
#submit the payment entry and return the document
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
#creating a sales invoice once the payment entry is submitted
if submit and self.reference_doctype == "Quotation":
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
si = make_sales_invoice(sales_order.name, ignore_permissions=True)
si.allocate_advances_automatically = True
si = si.insert(ignore_permissions=True)
si.submit()
return payment_entry
def create_payment_entry(self,paid, submit=True):
bank_account = frappe.db.get_value("MRS Settings", None, "bank_account")
isum= 0
order_items= self.get_items()
for i in order_items:
isum += i['amount']
if not paid:
to_pay_amount= isum
else:
to_pay_amount= paid
if self.prepaid: to_pay_amount= paid + self.prepaid
"""create entry"""
frappe.flags.ignore_account_permission = True
ref_doc = frappe.get_doc("Sales Invoice", self.invoice)
party_account = ref_doc.debit_to
party_account_currency = ref_doc.get("party_account_currency") or get_account_currency(party_account)
bank_amount = to_pay_amount
#if party_account_currency == ref_doc.company_currency and party_account_currency != self.currency:
# party_amount = ref_doc.base_grand_total
#else:
party_amount = to_pay_amount
payment_entry = get_payment_entry("Sales Invoice", self.invoice,
party_amount=party_amount, bank_account=bank_account, bank_amount=bank_amount)
payment_entry.update({
"reference_no": self.name,
"reference_date": nowdate(),
"maintenance_order":self.name,
"remarks": "Payment Entry against {0} {1} via Payment Request {2}".format("Sales Invoice",
self.invoice, self.name)
})
if payment_entry.difference_amount:
company_details = get_company_defaults(ref_doc.company)
payment_entry.append("deductions", {
"account": company_details.exchange_gain_loss_account,
"cost_center": company_details.cost_center,
"amount": payment_entry.difference_amount
})
if submit:
payment_entry.insert(ignore_permissions=True)
payment_entry.submit()
payment_schedule = frappe.get_doc('Payment Schedule',{'parent':self.invoice} )
payment_schedule.invoice_portion=100
payment_schedule.flags.ignore_validate_update_after_submit = True
payment_schedule.save(ignore_permissions = True)
frappe.db.commit()
for i in order_items:
frappe.db.sql('update `tabDelivery Note Item` set billed_amt=%s where parent=%s',(i['amount'],self.delivery_note))
frappe.db.sql('update `tabDelivery Note` set per_billed=%s, status="Completed" where name=%s',(100,self.delivery_note))
frappe.msgprint(_("Payment Entry {0} created as paid".format(payment_entry.name)), alert=True)
return payment_entry
