def test_payment_entry(self):
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
mute_email=1, submit_doc=1)
jv = pr.set_as_paid()
so_inr = frappe.get_doc("Sales Order", so_inr.name)
self.assertEquals(so_inr.advance_paid, jv.total_debit)
conversion_rate = get_exchange_rate("USD", "INR")
si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
currency="USD", conversion_rate=conversion_rate)
pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
mute_email=1, return_doc=1, payment_gateway="_Test Gateway - USD")
jv = pr.set_as_paid()
payment_gateway_details = get_gateway_details({"payment_gateway": "_Test Gateway - USD"})
self.assertEquals(jv.accounts[0].account, "_Test Receivable USD - _TC")
self.assertEquals(jv.accounts[1].account, payment_gateway_details.payment_account)
def test_payment_request_linkings(self):
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(
dt="Sales Order",
dn=so_inr.name,
recipient_id="*****@*****.**",
payment_gateway_account="_Test Gateway - INR")
self.assertEqual(pr.reference_doctype, "Sales Order")
self.assertEqual(pr.reference_name, so_inr.name)
self.assertEqual(pr.currency, "INR")
conversion_rate = get_exchange_rate("USD", "INR")
si_usd = create_sales_invoice(currency="USD",
conversion_rate=conversion_rate)
pr = make_payment_request(
dt="Sales Invoice",
dn=si_usd.name,
recipient_id="*****@*****.**",
payment_gateway_account="_Test Gateway - USD")
self.assertEqual(pr.reference_doctype, "Sales Invoice")
self.assertEqual(pr.reference_name, si_usd.name)
self.assertEqual(pr.currency, "USD")
def test_payment_entry(self):
frappe.db.set_value("Company", "_Test Company",
"exchange_gain_loss_account",
"_Test Exchange Gain/Loss - _TC")
frappe.db.set_value("Company", "_Test Company", "write_off_account",
"_Test Write Off - _TC")
frappe.db.set_value("Company", "_Test Company", "cost_center",
"_Test Cost Center - _TC")
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(
dt="Sales Order",
dn=so_inr.name,
recipient_id="*****@*****.**",
mute_email=1,
payment_gateway_account="_Test Gateway - INR",
submit_doc=1,
return_doc=1)
pe = pr.set_as_paid()
so_inr = frappe.get_doc("Sales Order", so_inr.name)
self.assertEqual(so_inr.advance_paid, 1000)
si_usd = create_sales_invoice(customer="_Test Customer USD",
debit_to="_Test Receivable USD - _TC",
currency="USD",
conversion_rate=50)
pr = make_payment_request(
dt="Sales Invoice",
dn=si_usd.name,
recipient_id="*****@*****.**",
mute_email=1,
payment_gateway_account="_Test Gateway - USD",
submit_doc=1,
return_doc=1)
pe = pr.set_as_paid()
expected_gle = dict(
(d[0], d)
for d in [["_Test Receivable USD - _TC", 0, 5000, si_usd.name],
[pr.payment_account, 6290.0, 0, None],
["_Test Exchange Gain/Loss - _TC", 0, 1290, None]])
gl_entries = frappe.db.sql(
"""select account, debit, credit, against_voucher
from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
order by account asc""",
pe.name,
as_dict=1)
self.assertTrue(gl_entries)
for i, gle in enumerate(gl_entries):
self.assertEqual(expected_gle[gle.account][0], gle.account)
self.assertEqual(expected_gle[gle.account][1], gle.debit)
self.assertEqual(expected_gle[gle.account][2], gle.credit)
self.assertEqual(expected_gle[gle.account][3], gle.against_voucher)
def test_payment_entry(self):
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(dt="Sales Order",
dn=so_inr.name,
recipient_id="*****@*****.**",
mute_email=1,
submit_doc=1)
jv = pr.set_as_paid()
so_inr = frappe.get_doc("Sales Order", so_inr.name)
self.assertEquals(so_inr.advance_paid, jv.total_debit)
conversion_rate = get_exchange_rate("USD", "INR")
si_usd = create_sales_invoice(customer="_Test Customer USD",
debit_to="_Test Receivable USD - _TC",
currency="USD",
conversion_rate=conversion_rate)
pr = make_payment_request(dt="Sales Invoice",
dn=si_usd.name,
recipient_id="*****@*****.**",
mute_email=1,
return_doc=1,
payment_gateway="_Test Gateway - USD")
jv = pr.set_as_paid()
payment_gateway_details = get_gateway_details(
{"payment_gateway": "_Test Gateway - USD"})
self.assertEquals(jv.accounts[0].account, "_Test Receivable USD - _TC")
self.assertEquals(jv.accounts[1].account,
payment_gateway_details.payment_account)
def test_payment_request_linkings(self): SO_INR = make_sales_order(currency="INR") pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Order") self.assertEquals(pr.reference_name, SO_INR.name) self.assertEquals(pr.currency, "INR") SI_USD = create_sales_invoice(currency="USD", conversion_rate=50) pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**") self.assertEquals(pr.reference_doctype, "Sales Invoice") self.assertEquals(pr.reference_name, SI_USD.name) self.assertEquals(pr.currency, "USD")
def test_payment_request_linkings(self):
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**")
self.assertEquals(pr.reference_doctype, "Sales Order")
self.assertEquals(pr.reference_name, so_inr.name)
self.assertEquals(pr.currency, "INR")
conversion_rate = get_exchange_rate("USD", "INR")
si_usd = create_sales_invoice(currency="USD", conversion_rate=conversion_rate)
pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**")
self.assertEquals(pr.reference_doctype, "Sales Invoice")
self.assertEquals(pr.reference_name, si_usd.name)
self.assertEquals(pr.currency, "USD")
def create_payment_request(self):
for pay in self.payments:
if pay.type == "Phone":
if pay.amount <= 0:
frappe.throw(
_("Payment amount cannot be less than or equal to 0"))
if not self.contact_mobile:
frappe.throw(_("Please enter the phone number first"))
payment_gateway = frappe.db.get_value(
"Payment Gateway Account", {
"payment_account": pay.account,
})
record = {
"payment_gateway": payment_gateway,
"dt": "POS Invoice",
"dn": self.name,
"payment_request_type": "Inward",
"party_type": "Customer",
"party": self.customer,
"mode_of_payment": pay.mode_of_payment,
"recipient_id": self.contact_mobile,
"submit_doc": True
}
return make_payment_request(**record)
def work(domain="Manufacturing"):
frappe.set_user(frappe.db.get_global("demo_sales_user_2"))
for i in range(random.randint(1, 7)):
if random.random() < 0.5:
make_opportunity(domain)
for i in range(random.randint(1, 3)):
if random.random() < 0.5:
make_quotation(domain)
try:
lost_reason = frappe.get_doc({
"doctype": "Opportunity Lost Reason",
"lost_reason": "Did not ask"
})
lost_reason.save(ignore_permissions=True)
except frappe.exceptions.DuplicateEntryError:
pass
# lost quotations / inquiries
if random.random() < 0.3:
for i in range(random.randint(1, 3)):
quotation = get_random("Quotation", doc=True)
if quotation and quotation.status == "Submitted":
quotation.declare_order_lost([{"lost_reason": "Did not ask"}])
for i in range(random.randint(1, 3)):
opportunity = get_random("Opportunity", doc=True)
if opportunity and opportunity.status in ("Open", "Replied"):
opportunity.declare_enquiry_lost([{
"lost_reason": "Did not ask"
}])
for i in range(random.randint(1, 3)):
if random.random() < 0.6:
make_sales_order()
if random.random() < 0.5:
# make payment request against Sales Order
sales_order_name = get_random("Sales Order", filters={"docstatus": 1})
try:
if sales_order_name:
so = frappe.get_doc("Sales Order", sales_order_name)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(
dt="Sales Order",
dn=so.name,
recipient_id=so.contact_email,
submit_doc=True,
mute_email=True,
use_dummy_message=True,
)
payment_entry = frappe.get_doc(
make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
except Exception:
pass
def check_gateway_payments():
from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
gocardless_gateways = [
x.name for x in frappe.get_all(
"Payment Gateway",
filters={"gateway_settings": "GoCardless Settings"})
]
gocardless_subscription = frappe.get_all("Subscription",
filters={
"status":
"Active",
"payment_gateway":
["in", gocardless_gateways]
})
for subscription in gocardless_subscription:
doc = frappe.get_doc("Subscription", subscription)
if doc.is_payable():
pr = make_payment_request(
**{
"dt": doc.doctype,
"dn": doc.name,
"party_type": "Customer",
"party": doc.customer,
"submit_doc": True,
"mute_email": True,
"payment_gateway": doc.payment_gateway,
"currency": doc.currency
})
if pr.get("payment_gateway_account") and float(
pr.get("grand_total")) > 0:
doc = frappe.get_doc("Payment Request", pr.get("name"))
doc.run_method("process_payment_immediately")
def test_status(self): si_usd = create_sales_invoice( customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", currency="USD", conversion_rate=50, ) pr = make_payment_request( dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**", mute_email=1, payment_gateway_account="_Test Gateway - USD", submit_doc=1, return_doc=1, ) pe = pr.create_payment_entry() pr.load_from_db() self.assertEqual(pr.status, "Paid") pe.cancel() pr.load_from_db() self.assertEqual(pr.status, "Requested")
def raise_payment_request(doc, state):
purchase_order = doc.get("items")[0].purchase_order
if not frappe.db.exists({
"doctype": "Payment Request",
"reference_name": purchase_order,
"checked": False
}):
#dn = doc.get("name")
'''if frappe.db.count('Payment Request', {'reference_name': dn}) > 0:
return
else:'''
try:
args = {}
args["dt"] = "Purchase Order"
args["dn"] = purchase_order
args["loyalty_points"] = ""
args["party_type"] = "Supplier"
args["party"] = doc.get("supplier")
args["payment_request_type"] = "Outward"
args["transaction_date"] = date.today
args["return_doc"] = True
args["submit_doc"] = False
args["order_type"] = "Purchase Order"
if args:
from erpnext.accounts.doctype.payment_request.payment_request import make_payment_request
payment_request_doc = make_payment_request(**args)
#########################################################
#SET PURCHASE ORDER AMOUNT
po = frappe.get_doc(
payment_request_doc.get("reference_doctype"),
payment_request_doc.get("reference_name"))
total_po_amount = po.get("total") or 0.0
payment_request_doc.set("order_amount", total_po_amount)
#APPEND INVOICES/CREDIT NOTES IN TABLE
payment_request_doc = append_invoice_to_request(
payment_request_doc, doc)
########################################################
#INSERT DOCUMENT
payment_request_doc.insert(ignore_permissions=True)
#doc.db_set("sent_to_pv", True)
frappe.msgprint(
"Payment request {0} has been created successfully. ".
format(payment_request_doc.get("name")))
except Exception as e:
frappe.msgprint("Operation could not be completed because of {0}"\
.format(e))
else:
docname = frappe.db.get_value("Payment Request", {
"reference_name": purchase_order,
"checked": False
}, "name")
payment_request_doc = frappe.get_doc("Payment Request", docname)
payment_request_doc = append_invoice_to_request(
payment_request_doc, doc)
payment_request_doc.save(ignore_permissions=True)
doc.db_set("sent_to_pv", True)
return
def test_payment_entry(self):
SO_INR = make_sales_order(currency="INR")
pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**",
mute_email=1, submit_doc=1)
jv = pr.set_as_paid()
SO_INR = frappe.get_doc("Sales Order", SO_INR.name)
self.assertEquals(SO_INR.advance_paid, jv.total_debit)
SI_USD = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
currency="USD", conversion_rate=50)
pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**",
mute_email=1, return_doc=1, payemnt_gateway="_Test Gateway - USD")
self.assertRaises(frappe.ValidationError, pr.save)
def on_submit(self):
self.make_gl_entries()
if self.send_payment_request and self.student_email:
pr = make_payment_request(dt="Fees", dn=self.name, recipient_id=self.student_email,
submit_doc=True, use_dummy_message=True)
frappe.msgprint(_("Payment request {0} created").format(getlink("Payment Request", pr.name)))
def on_submit(self):
self.make_gl_entries()
if self.send_payment_request and self.student_email:
pr = make_payment_request(dt="Fees", dn=self.name, recipient_id=self.student_email,
submit_doc=True, use_dummy_message=True)
frappe.msgprint(_("Payment request {0} created").format(getlink("Payment Request", pr.name)))
def work():
frappe.set_user(frappe.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0] != "Total"]))[:random.randint(1, 5)]:
try:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = frappe.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(
frappe.get_cached_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0] != "Total"]))[:random.randint(1, 5)]:
try:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = frappe.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.4:
# make payment request against sales invoice
sales_invoice_name = get_random(
"Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = frappe.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(
make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
make_pos_invoice()
def test_multiple_payment_entries_against_sales_order(self): # Make Sales Order, grand_total = 1000 so = make_sales_order() # Payment Request amount = 200 pr1 = make_payment_request(dt="Sales Order", dn=so.name, recipient_id="*****@*****.**", return_doc=1) pr1.grand_total = 200 pr1.submit() # Make a 2nd Payment Request pr2 = make_payment_request(dt="Sales Order", dn=so.name, recipient_id="*****@*****.**", return_doc=1) self.assertEqual(pr2.grand_total, 800) # Try to make Payment Request more than SO amount, should give validation pr2.grand_total = 900 self.assertRaises(frappe.ValidationError, pr2.save)
def test_payment_entry(self):
frappe.db.set_value("Company", "_Test Company",
"exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC")
frappe.db.set_value("Company", "_Test Company",
"write_off_account", "_Test Write Off - _TC")
frappe.db.set_value("Company", "_Test Company",
"cost_center", "_Test Cost Center - _TC")
so_inr = make_sales_order(currency="INR")
pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
mute_email=1, submit_doc=1)
pe = pr.set_as_paid()
so_inr = frappe.get_doc("Sales Order", so_inr.name)
self.assertEquals(so_inr.advance_paid, 1000)
si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
currency="USD", conversion_rate=50)
pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
mute_email=1, payment_gateway="_Test Gateway - USD", submit_doc=1)
pe = pr.set_as_paid()
expected_gle = dict((d[0], d) for d in [
["_Test Receivable USD - _TC", 0, 5000, si_usd.name],
[pr.payment_account, 6000.0, 0, None],
["_Test Exchange Gain/Loss - _TC", 0, 1000, None]
])
gl_entries = frappe.db.sql("""select account, debit, credit, against_voucher
from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
order by account asc""", pe.name, as_dict=1)
self.assertTrue(gl_entries)
for i, gle in enumerate(gl_entries):
self.assertEquals(expected_gle[gle.account][0], gle.account)
self.assertEquals(expected_gle[gle.account][1], gle.debit)
self.assertEquals(expected_gle[gle.account][2], gle.credit)
self.assertEquals(expected_gle[gle.account][3], gle.against_voucher)
def work():
frappe.set_user(frappe.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
si = frappe.get_doc(make_sales_invoice(so))
si.posting_date = frappe.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(frappe.db.get_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
pi = frappe.get_doc(make_purchase_invoice(pr))
pi.posting_date = frappe.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
frappe.db.commit()
except frappe.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.1:
#make payment request against sales invoice
sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = frappe.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
make_pos_invoice()
def make_sales_order(sale_factor):
qty_factor = random.randint(1,(random.randint(1, sale_factor)))
no_of_items_sold= random.randint(1, 10)
customer = random.choice(CUSTOMERS)
sales_order_items = []
for item in xrange(no_of_items_sold):
sales_order_items.append({
"item_code": random.choice(ITEMS),
"qty": random.randint(1, qty_factor),
"warehouse": WAREHOUSE
})
sales_order = frappe.get_doc({
"doctype": "Sales Order",
"creation": frappe.flags.current_date,
"customer": customer,
"transaction_date": frappe.flags.current_date,
"order_type": "Shopping Cart",
"items": sales_order_items
})
taxes = get_default_taxes_and_charges("Sales Taxes and Charges Template", company=COMPANY)
if taxes.get('taxes'):
sales_order.update(taxes)
sales_order.save()
sales_order.submit()
so = sales_order
for item in so.items:
if item.projected_qty<10:
reorder_stock(item.item_code)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(dt="Sales Order", dn=so.name, recipient_id=so.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
si = frappe.get_doc(make_sales_invoice(so.name))
si.set_posting_time=True
si.posting_date = frappe.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(frappe.db.get_value('Company', si.company, 'abbr'))
si.set_missing_values()
make_payment_entries_for_pos_invoice(si)
si.insert()
si.submit()
dn = make_delivery_note(so.name)
dn.set_posting_time=True
dn.posting_date = frappe.flags.current_date
dn.insert()
dn.submit()
def work(domain="Manufacturing"):
frappe.set_user(frappe.db.get_global('demo_sales_user_2'))
for i in range(random.randint(1, 7)):
if random.random() < 0.5:
make_opportunity(domain)
for i in range(random.randint(1, 3)):
if random.random() < 0.5:
make_quotation(domain)
# lost quotations / inquiries
if random.random() < 0.3:
for i in range(random.randint(1, 3)):
quotation = get_random('Quotation', doc=True)
if quotation and quotation.status == 'Submitted':
quotation.declare_order_lost('Did not ask')
for i in range(random.randint(1, 3)):
opportunity = get_random('Opportunity', doc=True)
if opportunity and opportunity.status in ('Open', 'Replied'):
opportunity.declare_enquiry_lost('Did not ask')
for i in range(random.randint(1, 3)):
if random.random() < 0.6:
make_sales_order()
if random.random() < 0.5:
#make payment request against Sales Order
sales_order_name = get_random("Sales Order", filters={"docstatus": 1})
try:
if sales_order_name:
so = frappe.get_doc("Sales Order", sales_order_name)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(
dt="Sales Order",
dn=so.name,
recipient_id=so.contact_email,
submit_doc=True,
mute_email=True,
use_dummy_message=True)
payment_entry = frappe.get_doc(
make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
except Exception:
pass
def get_new_payment_request(self, mop):
payment_gateway_account = frappe.db.get_value(
"Payment Gateway Account", {
"payment_account": mop.account,
}, ["name"])
args = {
"dt": "POS Invoice",
"dn": self.name,
"recipient_id": self.contact_mobile,
"mode_of_payment": mop.mode_of_payment,
"payment_gateway_account": payment_gateway_account,
"payment_request_type": "Inward",
"party_type": "Customer",
"party": self.customer,
"return_doc": True
}
return make_payment_request(**args)
def work():
frappe.set_user(frappe.db.get_global("demo_sales_user_2"))
if random.random() < 0.5:
for i in xrange(random.randint(1, 7)):
make_opportunity()
if random.random() < 0.5:
for i in xrange(random.randint(1, 3)):
make_quotation()
# lost quotations / inquiries
if random.random() < 0.3:
for i in xrange(random.randint(1, 3)):
quotation = get_random("Quotation", doc=True)
if quotation and quotation.status == "Submitted":
quotation.declare_order_lost("Did not ask")
for i in xrange(random.randint(1, 3)):
opportunity = get_random("Opportunity", doc=True)
if opportunity and opportunity.status in ("Open", "Replied"):
opportunity.declare_enquiry_lost("Did not ask")
if random.random() < 0.3:
for i in xrange(random.randint(1, 3)):
make_sales_order()
if random.random() < 0.1:
# make payment request against Sales Order
sales_order_name = get_random("Sales Order", filters={"docstatus": 1})
if sales_order_name:
so = frappe.get_doc("Sales Order", sales_order_name)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(
dt="Sales Order",
dn=so.name,
recipient_id=so.contact_email,
submit_doc=True,
mute_email=True,
use_dummy_message=True,
)
payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
def work(domain="Manufacturing"):
frappe.set_user(frappe.db.get_global('demo_sales_user_2'))
for i in range(random.randint(1,7)):
if random.random() < 0.5:
make_opportunity(domain)
for i in range(random.randint(1,3)):
if random.random() < 0.5:
make_quotation(domain)
# lost quotations / inquiries
if random.random() < 0.3:
for i in range(random.randint(1,3)):
quotation = get_random('Quotation', doc=True)
if quotation and quotation.status == 'Submitted':
quotation.declare_order_lost('Did not ask')
for i in range(random.randint(1,3)):
opportunity = get_random('Opportunity', doc=True)
if opportunity and opportunity.status in ('Open', 'Replied'):
opportunity.declare_enquiry_lost('Did not ask')
for i in range(random.randint(1,3)):
if random.random() < 0.6:
make_sales_order()
if random.random() < 0.5:
#make payment request against Sales Order
sales_order_name = get_random("Sales Order", filters={"docstatus": 1})
try:
if sales_order_name:
so = frappe.get_doc("Sales Order", sales_order_name)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(dt="Sales Order", dn=so.name, recipient_id=so.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = frappe.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
except Exception:
pass
def register(args):
try:
args = json.loads(args)
users, currency, billing_cycle, coupon, email = args['users'], args['currency'], args['billing_cycle'],args['coupon'],args['email']
price_list = frappe.get_value("Price List", {"currency": currency, "selling": 1, "enabled": 1})
billing_cycle_price = frappe.get_value("Item Price",{"item_code": billing_cycle, "currency":currency, "selling": 1},"price_list_rate")
# add_on_price = 0 if add_ons == "0" else frappe.get_value("Item Price",{"item_code": add_ons, "currency":currency, "selling": 1},"price_list_rate")
total_cost = (billing_cycle_price * cint(users))
discount = 0
if coupon:
total_cost, discount = apply_code(coupon, total_cost, currency)
customer, customer_email = frappe.get_value("Customer", {"email": email }, ["name", "email"])
frappe.db.set_value("Customer", customer, "users", users)
frappe.db.commit()
sales_order = make_sales_order(customer,currency, price_list, discount, users, billing_cycle, coupon)
si = make_sales_invoice(sales_order.name,ignore_permissions=True)
si.insert(ignore_permissions=True)
si.submit()
update_coupon_usage(coupon)
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, submit_doc=True, mute_email=True, payment_gateway= payment_gateway_account[currency])
payment_details = get_payment_details(payment_request ,si, customer,customer_email, currency)
controller = get_payment_gateway_controller(payment_gateway[currency])
url = controller.get_payment_url(**payment_details)
return url
except Exception as e:
print(e)
print(frappe.get_traceback())
def run():
frappe.set_user("*****@*****.**")
frappe.set_user_lang("fr")
for i in range(random.randint(1, 7)):
if random.random() < 0.5:
make_opportunity()
for i in range(random.randint(1, 7)):
if random.random() < 0.5:
make_quotation()
try:
lost_reason = frappe.get_doc({
"doctype": "Opportunity Lost Reason",
"lost_reason": _("Did not ask")
})
lost_reason.save(ignore_permissions=True)
except frappe.exceptions.DuplicateEntryError:
pass
# lost quotations / inquiries
if random.random() < 0.3:
for i in range(random.randint(1, 3)):
quotation = get_random('Quotation', doc=True)
if quotation and quotation.status == 'Submitted':
quotation.declare_order_lost([{
'lost_reason': _('Did not ask')
}])
for i in range(random.randint(1, 3)):
opportunity = get_random('Opportunity', doc=True)
if opportunity and opportunity.status in ('Open', 'Replied'):
opportunity.declare_enquiry_lost([{
'lost_reason':
_('Did not ask')
}])
for i in range(random.randint(1, 7)):
if random.random() < 0.6:
make_sales_order()
if random.random() < 0.5:
#make payment request against Sales Order
sales_order_name = get_random("Sales Order", filters={"docstatus": 1})
try:
if sales_order_name:
so = frappe.get_doc("Sales Order", sales_order_name)
if flt(so.per_billed) != 100:
payment_request = make_payment_request(
dt="Sales Order",
dn=so.name,
recipient_id=so.contact_email,
submit_doc=True,
mute_email=True,
use_dummy_message=True)
payment_entry = frappe.get_doc(
make_payment_entry(payment_request.name))
payment_entry.posting_date = frappe.flags.current_date
payment_entry.submit()
except Exception:
pass
def checkout(form):
log("Are we still using this method?\n{0}".format(get_trace()))
result = {
"success": False,
"msg": "Not Implemented",
"errors": {}
}
try:
form = json.loads(form)
except:
result["msg"] = "Invalid data"
return result
billing = form.get("billing", {})
shipping = form.get("shipping", {})
session_user = frappe.get_user()
customer = None
user = frappe.get_doc("User", session_user.name)
form["user"] = {
"email": user.email
}
result['form'] = form # set form back to browser to update any ids as neccessary
gateway = None
try:
quotation = cart.get_cart_quotation()
quote = quotation["doc"]
gateway = embed.get_gateway_module(billing.get("gateway", None))
customer = frappe.get_doc("Customer", quote.customer)
except:
result["success"] = False
result["msg"] = "Internal Error"
result["exception"] = traceback.format_exc()
try:
if gateway:
bill_address = None
bill_address_insert = False
ship_address = None
ship_address_insert = False
# lets extract billing address if one was entered
if not billing['fields'].get('bill_address_id', False):
bill_address = {
k: billing['fields'].get(k, None) \
for k in ["bill_%s" % j for j in ADDRESS_FIELDS]
}
bill_address = _create_customer_address(bill_address, customer, 'bill_')
bill_address.flags.ignore_permissions = True
bill_address_insert = True
else:
bill_address = frappe.get_doc('Address', billing['fields']['bill_address_id'])
if not shipping['fields'].get('ship_address_id', False):
ship_address = {
k: shipping['fields'].get(k, None) \
for k in ["ship_%s" % j for j in ADDRESS_FIELDS]
}
ship_address = _create_customer_address(ship_address, customer, 'ship_')
ship_address.flags.ignore_permissions = True
ship_address_insert = True
else:
ship_address = frappe.get_doc('Address', shipping['fields']['ship_address_id'])
# setup transaction
transaction = create_transaction(quote.grand_total, quote.currency)
transaction.email = user.email
stored_payment = None
if form.get("stored_payment", False):
stored_payment = None # update with new doctype
try:
success, msg = gateway.process(transaction, form, stored_payment, bill_address, ship_address)
if success:
result["success"] = True
# on success insert new addresses
if bill_address_insert:
bill_address.insert()
billing['fields']['bill_address_id'] = bill_address.name
if ship_address_insert:
# regenerate title since erpnext uses
# title to generate id(name) in case
# billing address uses same title
ship_address.address_title = get_doctype_next_series('Address', "%s-%s" % (shipping['fields']['ship_address_title'], 'Shipping'))
ship_address.insert()
shipping['fields']['ship_address_id'] = ship_address.name
# apply addresses to quotation
quote.shipping_address_name = ship_address.name
quote.shipping_address = get_address_display(ship_address.as_dict())
quote.customer_address = bill_address.name
quote.address_display = get_address_display(bill_address.as_dict())
quote.flags.ignore_permissions = True
quote.save()
# now we'll submit quotation, create sales order,
# create payment request and fullfill it
so_name = cart.place_order() # submit quotation and create so
result["so_name"] = so_name
# lets now create a payment request and fullfill it immediately
preq = payment_request.make_payment_request(dt="Sales Order", dn=so_name, submit_doc=1, return_doc=1)
if preq:
gdoc = gateway.get_gateway()
adoc = gateway.get_bank_account()
gadoc = gateway.get_account()
preq.payment_gateway = gdoc.name
preq.payment_account = adoc.name
preq.payment_gateway_account = gadoc.name
preq.flags.ignore_validate_update_after_submit = 1
preq.flags.ignore_permissions = True
preq.save()
payment_entry = preq.run_method("set_as_paid")
transaction.log(json.dumps(sanitize_checkout_form(form), indent=4))
transaction.reference_doctype = "Payment Request"
transaction.reference_docname = preq.name
transaction.gateway = gdoc.name
transaction.save()
# find invoice
inv_item = frappe.get_list("Sales Invoice Item", fields=["parent"], filters={"sales_order": so_name})[0]
result["inv_name"] = inv_item.get("parent")
frappe.session['awc_success_inv_name'] = inv_item.get("parent")
frappe.session['awc_success_so_name'] = so_name
frappe.session['awc_success_email'] = user.email
else:
result["success"] = False
result["msg"] = msg
except:
transaction.log(json.dumps(sanitize_checkout_form(form), indent=4))
transaction.status = "Failed"
transaction.log(traceback.format_exc() + "\n---\n")
transaction.save()
result["success"] = False
result["msg"] = 'Internal Error'
result["exception"] = traceback.format_exc()
raise
except:
result["success"] = False
if not result.get('msg'):
result['msg'] = 'Internal Error'
if not result.get('exception'):
result['exception'] = traceback.format_exc()
return result
