def work():
dataent.set_user(dataent.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 = dataent.get_doc(make_sales_invoice(so))
si.posting_date = dataent.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
dataent.db.commit()
except dataent.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 = dataent.get_doc(make_purchase_invoice(pr))
pi.posting_date = dataent.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
dataent.db.commit()
except dataent.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 = dataent.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 = dataent.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = dataent.flags.current_date
payment_entry.submit()
make_pos_invoice()
def make_purchase_receipt():
if random.random() < 0.6:
from epaas.buying.doctype.purchase_order.purchase_order import make_purchase_receipt
report = "Purchase Order Items To Be Received"
po_list =list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="'Total'"]))[:random.randint(1, 10)]
for po in po_list:
pr = dataent.get_doc(make_purchase_receipt(po))
if pr.is_subcontracted=="Yes":
pr.supplier_warehouse = "Supplier - WPL"
pr.posting_date = dataent.flags.current_date
pr.insert()
try:
pr.submit()
except NegativeStockError:
print('Negative stock for {0}'.format(po))
pass
dataent.db.commit()
def make_delivery_note():
# make purchase requests
# make delivery notes (if possible)
if random.random() < 0.6:
from epaas.selling.doctype.sales_order.sales_order import make_delivery_note
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="'Total'"]))[:random.randint(1, 3)]:
dn = dataent.get_doc(make_delivery_note(so))
dn.posting_date = dataent.flags.current_date
for d in dn.get("items"):
if not d.expense_account:
d.expense_account = ("Cost of Goods Sold - {0}".format(
dataent.get_cached_value('Company', dn.company, 'abbr')))
try:
dn.insert()
dn.submit()
dataent.db.commit()
except (NegativeStockError, SerialNoRequiredError, SerialNoQtyError, UnableToSelectBatchError):
dataent.db.rollback()
def make_payment_entries(ref_doctype, report):
outstanding_invoices = list(set([r[3] for r in query_report.run(report,
{"report_date": dataent.flags.current_date })["result"] if r[2]==ref_doctype]))
# make Payment Entry
for inv in outstanding_invoices[:random.randint(1, 2)]:
pe = get_payment_entry(ref_doctype, inv)
pe.posting_date = dataent.flags.current_date
pe.reference_no = random_string(6)
pe.reference_date = dataent.flags.current_date
pe.insert()
pe.submit()
dataent.db.commit()
outstanding_invoices.remove(inv)
# make payment via JV
for inv in outstanding_invoices[:1]:
jv = dataent.get_doc(get_payment_entry_against_invoice(ref_doctype, inv))
jv.posting_date = dataent.flags.current_date
jv.cheque_no = random_string(6)
jv.cheque_date = dataent.flags.current_date
jv.insert()
jv.submit()
dataent.db.commit()
def work():
dataent.set_user(dataent.db.get_global('demo_purchase_user'))
if random.random() < 0.6:
report = "Items To Be Requested"
for row in query_report.run(report)["result"][:random.randint(1, 5)]:
item_code, qty = row[0], abs(row[-1])
mr = make_material_request(item_code, qty)
if random.random() < 0.6:
for mr in dataent.get_all('Material Request',
filters={
'material_request_type': 'Purchase',
'status': 'Open'
},
limit=random.randint(1, 6)):
if not dataent.get_all('Request for Quotation',
filters={'material_request': mr.name},
limit=1):
rfq = make_request_for_quotation(mr.name)
rfq.transaction_date = dataent.flags.current_date
add_suppliers(rfq)
rfq.save()
rfq.submit()
# Make suppier quotation from RFQ against each supplier.
if random.random() < 0.6:
for rfq in dataent.get_all('Request for Quotation',
filters={'status': 'Open'},
limit=random.randint(1, 6)):
if not dataent.get_all('Supplier Quotation',
filters={'request_for_quotation': rfq.name},
limit=1):
rfq = dataent.get_doc('Request for Quotation', rfq.name)
for supplier in rfq.suppliers:
supplier_quotation = make_quotation_from_rfq(
rfq.name, supplier.supplier)
supplier_quotation.save()
supplier_quotation.submit()
# get supplier details
supplier = get_random("Supplier")
company_currency = dataent.get_cached_value('Company',
epaas.get_default_company(),
"default_currency")
party_account_currency = get_party_account_currency(
"Supplier", supplier, epaas.get_default_company())
if company_currency == party_account_currency:
exchange_rate = 1
else:
exchange_rate = get_exchange_rate(party_account_currency,
company_currency,
args="for_buying")
# make supplier quotations
if random.random() < 0.5:
from epaas.stock.doctype.material_request.material_request import make_supplier_quotation
report = "Material Requests for which Supplier Quotations are not created"
for row in query_report.run(report)["result"][:random.randint(1, 3)]:
if row[0] != "'Total'":
sq = dataent.get_doc(make_supplier_quotation(row[0]))
sq.transaction_date = dataent.flags.current_date
sq.supplier = supplier
sq.currency = party_account_currency or company_currency
sq.conversion_rate = exchange_rate
sq.insert()
sq.submit()
dataent.db.commit()
# make purchase orders
if random.random() < 0.5:
from epaas.stock.doctype.material_request.material_request import make_purchase_order
report = "Requested Items To Be Ordered"
for row in query_report.run(
report)["result"][:how_many("Purchase Order")]:
if row[0] != "'Total'":
try:
po = dataent.get_doc(make_purchase_order(row[0]))
po.supplier = supplier
po.currency = party_account_currency or company_currency
po.conversion_rate = exchange_rate
po.transaction_date = dataent.flags.current_date
po.insert()
po.submit()
except Exception:
pass
else:
dataent.db.commit()
if random.random() < 0.5:
make_subcontract()
def work():
if random.random() < 0.3: return
dataent.set_user(dataent.db.get_global('demo_manufacturing_user'))
if not dataent.get_all('Sales Order'): return
from epaas.projects.doctype.timesheet.timesheet import OverlapError
ppt = dataent.new_doc("Production Plan")
ppt.company = epaas.get_default_company()
# ppt.use_multi_level_bom = 1 #refactored
ppt.get_items_from = "Sales Order"
# ppt.purchase_request_for_warehouse = "Stores - WPL" # refactored
ppt.run_method("get_open_sales_orders")
if not ppt.get("sales_orders"): return
ppt.run_method("get_items")
ppt.run_method("raise_material_requests")
ppt.save()
ppt.submit()
ppt.run_method("raise_work_orders")
dataent.db.commit()
# submit work orders
for pro in dataent.db.get_values("Work Order", {"docstatus": 0}, "name"):
b = dataent.get_doc("Work Order", pro[0])
b.wip_warehouse = "Work in Progress - WPL"
b.submit()
dataent.db.commit()
# submit material requests
for pro in dataent.db.get_values("Material Request", {"docstatus": 0},
"name"):
b = dataent.get_doc("Material Request", pro[0])
b.submit()
dataent.db.commit()
# stores -> wip
if random.random() < 0.4:
for pro in query_report.run("Open Work Orders")[
"result"][:how_many("Stock Entry for WIP")]:
make_stock_entry_from_pro(pro[0],
"Material Transfer for Manufacture")
# wip -> fg
if random.random() < 0.4:
for pro in query_report.run("Work Orders in Progress")[
"result"][:how_many("Stock Entry for FG")]:
make_stock_entry_from_pro(pro[0], "Manufacture")
for bom in dataent.get_all('BOM',
fields=['item'],
filters={'with_operations': 1}):
pro_order = make_wo_order_test_record(
item=bom.item,
qty=2,
source_warehouse="Stores - WPL",
wip_warehouse="Work in Progress - WPL",
fg_warehouse="Stores - WPL",
company=epaas.get_default_company(),
stock_uom=dataent.db.get_value('Item', bom.item, 'stock_uom'),
planned_start_date=dataent.flags.current_date)
# submit job card
if random.random() < 0.4:
submit_job_cards()