def add_sales_communication(subject, content, sender, real_name, mail=None, status="Open", date=None): lead_name = webnotes.conn.get_value("Lead", {"email_id": sender}) contact_name = webnotes.conn.get_value("Contact", {"email_id": sender}) if not (lead_name or contact_name): # none, create a new Lead lead = webnotes.bean({ "doctype":"Lead", "lead_name": real_name or sender, "email_id": sender, "status": status, "source": "Email" }) lead.ignore_permissions = True lead.insert() lead_name = lead.doc.name parent_doctype = "Contact" if contact_name else "Lead" parent_name = contact_name or lead_name message = make(content=content, sender=sender, subject=subject, doctype = parent_doctype, name = parent_name, date=date, sent_or_received="Received") if mail: # save attachments to parent if from mail bean = webnotes.bean(parent_doctype, parent_name) mail.save_attachments_in_doc(bean.doc)
def test_sales_invoice_with_advance(self): from accounts.doctype.journal_voucher.test_journal_voucher \ import test_records as jv_test_records jv = webnotes.bean(copy=jv_test_records[0]) jv.insert() jv.submit() si = webnotes.bean(copy=test_records[0]) si.doclist.append({ "doctype": "Sales Invoice Advance", "parentfield": "advance_adjustment_details", "journal_voucher": jv.doc.name, "jv_detail_no": jv.doclist[1].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.doc.remark }) si.insert() si.submit() si.load_from_db() self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_invoice=%s""", si.doc.name)) self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_invoice=%s and credit=300""", si.doc.name)) self.assertEqual(si.doc.outstanding_amount, 261.8) si.cancel() self.assertTrue(not webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_invoice=%s""", si.doc.name))
def execute(): webnotes.reload_doc("utilities", "doctype", "note") webnotes.reload_doc("utilities", "doctype", "note_user") for question in webnotes.conn.sql("""select * from tabQuestion""", as_dict=True): if question.question: try: name = question.question[:180] if webnotes.conn.exists("Note", name): webnotes.delete_doc("Note", name) similar_questions = webnotes.conn.sql_list("""select name from `tabQuestion` where question like %s""", "%s%%" % name) answers = [markdown2.markdown(c) for c in webnotes.conn.sql_list(""" select answer from tabAnswer where question in (%s)""" % \ ", ".join(["%s"]*len(similar_questions)), similar_questions)] webnotes.bean({ "doctype":"Note", "title": name, "content": "<hr>".join(answers), "owner": question.owner, "creation": question.creation, "public": 1 }).insert() except NameError: pass except Exception, e: if e.args[0] != 1062: raise
def add_support_communication(subject, content, sender, docname=None, mail=None): if docname: ticket = webnotes.bean("Support Ticket", docname) ticket.doc.status = 'Open' ticket.ignore_permissions = True ticket.doc.save() else: ticket = webnotes.bean([decode_dict({ "doctype":"Support Ticket", "description": content, "subject": subject, "raised_by": sender, "content_type": mail.content_type if mail else None, "status": "Open", })]) ticket.ignore_permissions = True ticket.insert() make(content=content, sender=sender, subject = subject, doctype="Support Ticket", name=ticket.doc.name, date=mail.date if mail else today(), sent_or_received="Received") if mail: mail.save_attachments_in_doc(ticket.doc) return ticket
def get_warehouse_account(self): for d in webnotes.conn.sql("select name from tabWarehouse"): webnotes.bean("Warehouse", d[0]).save() warehouse_account = dict(webnotes.conn.sql("""select master_name, name from tabAccount where account_type = 'Warehouse' and ifnull(master_name, '') != ''""")) return warehouse_account
def create_custom_field_for_workflow_state(self): webnotes.clear_cache(doctype=self.doc.document_type) doctypeobj = webnotes.get_doctype(self.doc.document_type) if not len(doctypeobj.get({"doctype": "DocField", "fieldname": self.doc.workflow_state_field})): # create custom field webnotes.bean( [ { "doctype": "Custom Field", "dt": self.doc.document_type, "__islocal": 1, "fieldname": self.doc.workflow_state_field, "label": self.doc.workflow_state_field.replace("_", " ").title(), "hidden": 1, "fieldtype": "Link", "options": "Workflow State", # "insert_after": doctypeobj.get({"doctype":"DocField"})[-1].fieldname } ] ).save() webnotes.msgprint( "Created Custom Field '%s' in '%s'" % (self.doc.workflow_state_field, self.doc.document_type) )
def test_material_transfer_gl_entry(self): self._clear_stock() webnotes.defaults.set_global_default("auto_inventory_accounting", 1) mr = webnotes.bean(copy=test_records[0]) mr.insert() mr.submit() mtn = webnotes.bean(copy=test_records[2]) mtn.insert() mtn.submit() self.check_stock_ledger_entries("Stock Entry", mtn.doc.name, [["_Test Item", "_Test Warehouse", -45.0], ["_Test Item", "_Test Warehouse 1", 45.0]]) # no gl entry gl_entries = webnotes.conn.sql("""select * from `tabGL Entry` where voucher_type = 'Stock Entry' and voucher_no=%s""", mtn.doc.name) self.assertFalse(gl_entries) mtn.cancel() self.check_stock_ledger_entries("Stock Entry", mtn.doc.name, sorted([["_Test Item", "_Test Warehouse", 45.0], ["_Test Item", "_Test Warehouse 1", -45.0], ["_Test Item", "_Test Warehouse", -45.0], ["_Test Item", "_Test Warehouse 1", 45.0]])) # no gl entry gl_entries = webnotes.conn.sql("""select * from `tabGL Entry` where voucher_type = 'Stock Entry' and voucher_no=%s""", mtn.doc.name) self.assertFalse(gl_entries) webnotes.defaults.set_global_default("auto_inventory_accounting", 0) webnotes.conn.set_default("company", self.old_default_company)
def create_chart_of_accounts_if_not_exists(): for company in webnotes.conn.sql("select name from `tabCompany`"): if not webnotes.conn.sql("select * from `tabAccount` where company = %s", company[0]): webnotes.conn.sql("""update `tabCompany` set receivables_group = '', payables_group = '' where name = %s""", company[0]) webnotes.bean("Company", company[0]).save()
def test_purchase_invoice_with_advance(self): from accounts.doctype.journal_voucher.test_journal_voucher \ import test_records as jv_test_records jv = webnotes.bean(copy=jv_test_records[1]) jv.insert() jv.submit() pi = webnotes.bean(copy=test_records[0]) pi.doclist.append({ "doctype": "Purchase Invoice Advance", "parentfield": "advance_allocation_details", "journal_voucher": jv.doc.name, "jv_detail_no": jv.doclist[1].name, "advance_amount": 400, "allocated_amount": 300, "remarks": jv.doc.remark }) pi.run_method("calculate_taxes_and_totals") pi.insert() pi.submit() pi.load_from_db() self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s""", pi.doc.name)) self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s and debit=300""", pi.doc.name)) self.assertEqual(pi.doc.outstanding_amount, 1212.30) pi.cancel() self.assertTrue(not webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_voucher=%s""", pi.doc.name))
def create_default_warehouses(self): for whname in ("Stores", "Work In Progress", "Finished Goods"): webnotes.bean({ "doctype":"Warehouse", "warehouse_name": whname, "company": self.doc.name }).insert()
def execute(): webnotes.reload_doc("utilities", "doctype", "note") webnotes.reload_doc("utilities", "doctype", "note_user") for question in webnotes.conn.sql("""select * from tabQuestion""", as_dict=True): if question.question: try: name = question.question[:180] if webnotes.conn.exists("Note", name): webnotes.delete_doc("Note", name) note = webnotes.bean({ "doctype":"Note", "title": name, "content": "<hr>".join([markdown2.markdown(c) for c in webnotes.conn.sql_list(""" select answer from tabAnswer where question=%s""", question.name)]), "owner": question.owner, "creation": question.creation, "public": 1 }).insert() except NameError: pass webnotes.delete_doc("DocType", "Question") webnotes.delete_doc("DocType", "Answer") webnotes.bean("Style Settings").save() # update comment delete webnotes.conn.sql("""update tabDocPerm \ set cancel=1 where parent='Comment' and role='System Manager'""")
def create_default_web_page(self): if not webnotes.conn.get_value("Website Settings", None, "home_page"): import os with open(os.path.join(os.path.dirname(__file__), "sample_home_page.html"), "r") as webfile: webpage = webnotes.bean({ "doctype": "Web Page", "title": self.doc.name + " Home", "published": 1, "description": "Standard Home Page for " + self.doc.company, "main_section": webfile.read() % self.doc.fields }).insert() # update in home page in settings website_settings = webnotes.bean("Website Settings", "Website Settings") website_settings.doc.home_page = webpage.doc.name website_settings.doc.banner_html = """<h3 style='margin-bottom: 20px;'>""" + self.doc.name + "</h3>" website_settings.doc.copyright = self.doc.name website_settings.doclist.append({ "doctype": "Top Bar Item", "parentfield": "top_bar_items", "label":"Contact", "url": "contact" }) website_settings.doclist.append({ "doctype": "Top Bar Item", "parentfield": "top_bar_items", "label":"Blog", "url": "blog" }) website_settings.save() style_settings = webnotes.bean("Style Settings", "Style Settings") style_settings.doc.top_bar_background = "F2F2F2" style_settings.doc.font_size = "15px" style_settings.save()
def test_auto_material_request(self): webnotes.conn.sql("""delete from `tabMaterial Request Item`""") webnotes.conn.sql("""delete from `tabMaterial Request`""") self._clear_stock_account_balance() webnotes.conn.set_value("Stock Settings", None, "auto_indent", True) st1 = webnotes.bean(copy=test_records[0]) st1.insert() st1.submit() st2 = webnotes.bean(copy=test_records[1]) st2.insert() st2.submit() from stock.utils import reorder_item reorder_item() mr_name = webnotes.conn.sql( """select parent from `tabMaterial Request Item` where item_code='_Test Item'""" ) self.assertTrue(mr_name) webnotes.conn.set_default("company", self.old_default_company)
def test_closing_entry(self): # clear GL Entries webnotes.conn.sql("""delete from `tabGL Entry`""") from accounts.doctype.journal_voucher.test_journal_voucher import test_records as jv_records jv = webnotes.bean(copy=jv_records[2]) jv.insert() jv.submit() jv1 = webnotes.bean(copy=jv_records[0]) jv1.doclist[2].account = "_Test Account Cost for Goods Sold - _TC" jv1.doclist[2].debit = 600.0 jv1.doclist[1].credit = 600.0 jv1.insert() jv1.submit() pcv = webnotes.bean(copy=test_record) pcv.insert() pcv.submit() gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s order by account asc, debit asc""", pcv.doc.name, as_dict=1) self.assertTrue(gl_entries) expected_gl_entries = sorted([ ["_Test Account Reserves and Surplus - _TC", 200.0, 0.0], ["_Test Account Cost for Goods Sold - _TC", 0.0, 600.0], ["Sales - _TC", 400.0, 0.0] ]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_gl_entries[i][0], gle.account) self.assertEquals(expected_gl_entries[i][1], gle.debit) self.assertEquals(expected_gl_entries[i][2], gle.credit)
def update_party(fullname, company_name=None, mobile_no=None, phone=None): party = get_lead_or_customer() if party.doctype == "Lead": party.company_name = company_name party.lead_name = fullname party.mobile_no = mobile_no party.phone = phone else: party.customer_name = company_name or fullname party.customer_type == "Company" if company_name else "Individual" contact_name = webnotes.conn.get_value("Contact", {"email_id": webnotes.session.user, "customer": party.name}) contact = webnotes.bean("Contact", contact_name) contact.doc.first_name = fullname contact.doc.last_name = None contact.doc.customer_name = party.customer_name contact.doc.mobile_no = mobile_no contact.doc.phone = phone contact.ignore_permissions = True contact.save() party_bean = webnotes.bean(party.fields) party_bean.ignore_permissions = True party_bean.save() qbean = _get_cart_quotation(party) if not qbean.doc.fields.get("__islocal"): qbean.doc.customer_name = company_name or fullname qbean.run_method("set_contact_fields") qbean.ignore_permissions = True qbean.save()
def process_message(self, mail): if mail.from_email == self.email_settings.fields.get('support_email'): return thread_id = mail.get_thread_id() ticket = None new_ticket = False if thread_id and webnotes.conn.exists("Support Ticket", thread_id): ticket = webnotes.bean("Support Ticket", thread_id) ticket.doc.status = 'Open' ticket.doc.save() else: ticket = webnotes.bean([{ "doctype":"Support Ticket", "description": mail.content, "subject": mail.mail["Subject"], "raised_by": mail.from_email, "content_type": mail.content_type, "status": "Open" }]) ticket.insert() new_ticket = True mail.save_attachments_in_doc(ticket.doc) make(content=mail.content, sender=mail.from_email, subject = ticket.doc.subject, doctype="Support Ticket", name=ticket.doc.name, lead = ticket.doc.lead, contact=ticket.doc.contact, date=mail.date) if new_ticket and cint(self.email_settings.send_autoreply) and \ "mailer-daemon" not in mail.from_email.lower(): self.send_auto_reply(ticket.doc)
def process_message(self, mail): if mail.from_email == self.settings.email_id: return name = webnotes.conn.get_value("Job Applicant", {"email_id": mail.from_email}, "name") if name: applicant = webnotes.bean("Job Applicant", name) if applicant.doc.status!="Rejected": applicant.doc.status = "Open" applicant.doc.save() else: name = (mail.from_real_name and (mail.from_real_name + " - ") or "") \ + mail.from_email applicant = webnotes.bean({ "creation": mail.date, "doctype":"Job Applicant", "applicant_name": name, "email_id": mail.from_email, "status": "Open" }) applicant.insert() mail.save_attachments_in_doc(applicant.doc) make(content=mail.content, sender=mail.from_email, doctype="Job Applicant", name=applicant.doc.name)
def execute(): webnotes.reload_doc("selling", "doctype", "shopping_cart_price_list") webnotes.reload_doc("stock", "doctype", "item_price") for t in [ ("Supplier Quotation", "price_list_name", "buying_price_list"), ("Purchase Order", "price_list_name", "buying_price_list"), ("Purchase Invoice", "price_list_name", "buying_price_list"), ("Purchase Receipt", "price_list_name", "buying_price_list"), ("Quotation", "price_list_name", "selling_price_list"), ("Sales Order", "price_list_name", "selling_price_list"), ("Delivery Note", "price_list_name", "selling_price_list"), ("Sales Invoice", "price_list_name", "selling_price_list"), ("POS Setting", "price_list_name", "selling_price_list"), ("Shopping Cart Price List", "price_list", "selling_price_list"), ("Item Price", "price_list_name", "price_list"), ("BOM", "price_list", "buying_price_list"), ]: table_columns = webnotes.conn.get_table_columns(t[0]) if t[2] in table_columns and t[1] in table_columns: # already reloaded, so copy into new column and drop old column webnotes.conn.sql("""update `tab%s` set `%s`=`%s`""" % (t[0], t[2], t[1])) webnotes.conn.sql_ddl("""alter table `tab%s` drop column `%s`""" % (t[0], t[1])) elif t[1] in table_columns: webnotes.conn.sql_ddl("alter table `tab%s` change `%s` `%s` varchar(180)" % t) webnotes.reload_doc(webnotes.conn.get_value("DocType", t[0], "module"), "DocType", t[0]) webnotes.conn.sql("""update tabSingles set field='selling_price_list' where field='price_list_name' and doctype='Selling Settings'""") webnotes.reload_doc("Selling", "DocType", "Selling Settings") webnotes.bean("Selling Settings").save()
def test_planned_qty(self): set_perpetual_inventory(0) webnotes.conn.sql("delete from `tabStock Ledger Entry`") webnotes.conn.sql("""delete from `tabBin`""") webnotes.conn.sql("""delete from `tabGL Entry`""") pro_bean = webnotes.bean(copy = test_records[0]) pro_bean.insert() pro_bean.submit() from stock.doctype.stock_entry.test_stock_entry import test_records as se_test_records mr1 = webnotes.bean(copy = se_test_records[0]) mr1.insert() mr1.submit() mr2 = webnotes.bean(copy = se_test_records[0]) mr2.doclist[1].item_code = "_Test Item Home Desktop 100" mr2.insert() mr2.submit() stock_entry = make_stock_entry(pro_bean.doc.name, "Manufacture/Repack") stock_entry = webnotes.bean(stock_entry) stock_entry.doc.fg_completed_qty = 4 stock_entry.doc.posting_date = "2013-05-12" stock_entry.doc.fiscal_year = "_Test Fiscal Year 2013" stock_entry.run_method("get_items") stock_entry.submit() self.assertEqual(webnotes.conn.get_value("Production Order", pro_bean.doc.name, "produced_qty"), 4) self.assertEqual(webnotes.conn.get_value("Bin", {"item_code": "_Test FG Item", "warehouse": "_Test Warehouse 1 - _TC"}, "planned_qty"), 6) return pro_bean.doc.name
def test_monthly_budget_on_cancellation(self): from accounts.utils import BudgetError webnotes.conn.set_value("Company", "_Test Company", "monthly_bgt_flag", "Stop") self.clear_account_balance() jv = webnotes.bean(copy=test_records[0]) jv.doclist[1].account = "_Test Account Cost for Goods Sold - _TC" jv.doclist[1].cost_center = "_Test Cost Center - _TC" jv.doclist[1].credit = 30000.0 jv.doclist[2].debit = 30000.0 jv.submit() self.assertTrue(webnotes.conn.get_value("GL Entry", {"voucher_type": "Journal Voucher", "voucher_no": jv.doc.name})) jv1 = webnotes.bean(copy=test_records[0]) jv1.doclist[2].account = "_Test Account Cost for Goods Sold - _TC" jv1.doclist[2].cost_center = "_Test Cost Center - _TC" jv1.doclist[2].debit = 40000.0 jv1.doclist[1].credit = 40000.0 jv1.submit() self.assertTrue(webnotes.conn.get_value("GL Entry", {"voucher_type": "Journal Voucher", "voucher_no": jv1.doc.name})) self.assertRaises(BudgetError, jv.cancel) webnotes.conn.set_value("Company", "_Test Company", "monthly_bgt_flag", "Ignore")
def test_incorrect_mapping_of_stock_entry(self): # submit material request of type Purchase mr = webnotes.bean(copy=test_records[0]) mr.doc.material_request_type = "Transfer" mr.insert() mr.submit() # map a stock entry from stock.doctype.material_request.material_request import make_stock_entry se_doclist = make_stock_entry(mr.doc.name) se_doclist[0].update({ "posting_date": "2013-03-01", "posting_time": "00:00", "fiscal_year": "_Test Fiscal Year 2013", }) se_doclist[1].update({ "qty": 60.0, "transfer_qty": 60.0, "s_warehouse": "_Test Warehouse - _TC", "t_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) se_doclist[2].update({ "qty": 3.0, "transfer_qty": 3.0, "s_warehouse": "_Test Warehouse 1 - _TC", "incoming_rate": 1.0 }) # check for stopped status of Material Request se = webnotes.bean(copy=se_doclist) self.assertRaises(webnotes.MappingMismatchError, se.insert)
def after_install(): # reset installed apps for re-install webnotes.conn.set_global("installed_apps", '["webnotes"]') # core users / roles install_docs = [ {'doctype':'Profile', 'name':'Administrator', 'first_name':'Administrator', 'email':'admin@localhost', 'enabled':1}, {'doctype':'Profile', 'name':'Guest', 'first_name':'Guest', 'email':'guest@localhost', 'enabled':1}, {'doctype':'UserRole', 'parent': 'Administrator', 'role': 'Administrator', 'parenttype':'Profile', 'parentfield':'user_roles'}, {'doctype':'UserRole', 'parent': 'Guest', 'role': 'Guest', 'parenttype':'Profile', 'parentfield':'user_roles'}, {'doctype': "Role", "role_name": "Report Manager"} ] for d in install_docs: try: webnotes.bean(d).insert() except NameError: pass # all roles to admin webnotes.bean("Profile", "Administrator").get_controller().add_roles(*webnotes.conn.sql_list(""" select name from tabRole""")) # update admin password from webnotes.auth import _update_password _update_password("Administrator", webnotes.conf.get("admin_password")) webnotes.conn.commit()
def update_profile_name(args): if args.get("email"): args['name'] = args.get("email") webnotes.flags.mute_emails = True webnotes.bean({ "doctype":"Profile", "email": args.get("email"), "first_name": args.get("first_name"), "last_name": args.get("last_name"), "profile_type":"Employee" }).insert() webnotes.flags.mute_emails = False from webnotes.auth import _update_password _update_password(args.get("email"), args.get("password")) else: args['name'] = webnotes.session.user # Update Profile if not args.get('last_name') or args.get('last_name')=='None': args['last_name'] = None webnotes.conn.sql("""update `tabProfile` SET first_name=%(first_name)s, last_name=%(last_name)s WHERE name=%(name)s""", args) if args.get("attach_profile"): filename, filetype, content = args.get("attach_profile").split(",") fileurl = save_file(filename, content, "Profile", args.get("name"), decode=True).file_name webnotes.conn.set_value("Profile", args.get("name"), "user_image", fileurl) add_all_roles_to(args.get("name"))
def _get_cart_quotation(party=None): if not party: party = get_lead_or_customer() quotation = webnotes.conn.get_value("Quotation", {party.doctype.lower(): party.name, "order_type": "Shopping Cart", "docstatus": 0}) if quotation: qbean = webnotes.bean("Quotation", quotation) else: qbean = webnotes.bean({ "doctype": "Quotation", "naming_series": webnotes.defaults.get_user_default("shopping_cart_quotation_series") or "QTN-CART-", "quotation_to": party.doctype, "company": webnotes.defaults.get_user_default("company"), "order_type": "Shopping Cart", "status": "Draft", "docstatus": 0, "__islocal": 1, (party.doctype.lower()): party.name }) if party.doctype == "Customer": qbean.doc.contact_person = webnotes.conn.get_value("Contact", {"email_id": webnotes.session.user, "customer": party.name}) qbean.run_method("set_contact_fields") qbean.run_method("onload_post_render") apply_cart_settings(party, qbean) return qbean
def update_for_doc(doctype, doc): for filedata in doc.file_list.split("\n"): if not filedata: continue filedata = filedata.split(",") if len(filedata)==2: filename, fileid = filedata[0], filedata[1] else: continue exists = True if not (filename.startswith("http://") or filename.startswith("https://")): if not os.path.exists(webnotes.utils.get_path("public", "files", filename)): exists = False if exists: if webnotes.conn.exists("File Data", fileid): try: fd = webnotes.bean("File Data", fileid) if not (fd.doc.attached_to_doctype and fd.doc.attached_to_name): fd.doc.attached_to_doctype = doctype fd.doc.attached_to_name = doc.name fd.save() else: fd = webnotes.bean("File Data", copy=fd.doclist) fd.doc.attached_to_doctype = doctype fd.doc.attached_to_name = doc.name fd.doc.name = None fd.insert() except webnotes.DuplicateEntryError: pass else: webnotes.conn.sql("""delete from `tabFile Data` where name=%s""", fileid)
def _test_delivery_note_return_against_sales_order(self, item_code, delivered_qty, returned_qty): self._insert_material_receipt() from selling.doctype.sales_order.test_sales_order \ import test_records as sales_order_test_records actual_qty_0 = self._get_actual_qty() so = webnotes.bean(copy=sales_order_test_records[0]) so.doclist[1].item_code = item_code so.doclist[1].qty = 5.0 so.insert() so.submit() dn_doclist = webnotes.map_doclist([ ["Sales Order", "Delivery Note"], ["Sales Order Item", "Delivery Note Item"], ["Sales Taxes and Charges", "Sales Taxes and Charges"], ["Sales Team", "Sales Team"]], so.doc.name) dn = webnotes.bean(dn_doclist) dn.doc.status = "Draft" dn.doc.posting_date = so.doc.delivery_date dn.insert() dn.submit() actual_qty_1 = self._get_actual_qty() self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1) si_doclist = webnotes.map_doclist([ ["Sales Order", "Sales Invoice"], ["Sales Order Item", "Sales Invoice Item"], ["Sales Taxes and Charges", "Sales Taxes and Charges"], ["Sales Team", "Sales Team"]], so.doc.name) si = webnotes.bean(si_doclist) si.doc.posting_date = dn.doc.posting_date si.doc.debit_to = "_Test Customer - _TC" for d in si.doclist.get({"parentfield": "entries"}): d.income_account = "Sales - _TC" d.cost_center = "_Test Cost Center - _TC" si.insert() si.submit() # insert and submit stock entry for sales return se = webnotes.bean(copy=test_records[0]) se.doc.purpose = "Sales Return" se.doc.delivery_note_no = dn.doc.name se.doc.posting_date = "2013-03-10" se.doc.fiscal_year = "_Test Fiscal Year 2013" se.doclist[1].qty = se.doclist[1].transfer_qty = returned_qty se.insert() se.submit() actual_qty_2 = self._get_actual_qty() self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2) return se
def import_doc(d, doctype, overwrite, row_idx, submit=False, ignore_links=False): """import main (non child) document""" if d.get("name") and webnotes.conn.exists(doctype, d['name']): if overwrite: bean = webnotes.bean(doctype, d['name']) bean.ignore_links = ignore_links bean.doc.fields.update(d) if d.get("docstatus") == 1: bean.update_after_submit() else: bean.save() return 'Updated row (#%d) %s' % (row_idx + 1, getlink(doctype, d['name'])) else: return 'Ignored row (#%d) %s (exists)' % (row_idx + 1, getlink(doctype, d['name'])) else: bean = webnotes.bean([d]) bean.ignore_links = ignore_links bean.insert() if submit: bean.submit() return 'Inserted row (#%d) %s' % (row_idx + 1, getlink(doctype, bean.doc.fields['name']))
def test_incorrect_mapping_of_stock_entry(self): # submit material request of type Purchase mr = webnotes.bean(copy=test_records[0]) mr.doc.material_request_type = "Transfer" mr.insert() mr.submit() # map a stock entry se_doclist = webnotes.map_doclist([["Material Request", "Stock Entry"], ["Material Request Item", "Stock Entry Detail"]], mr.doc.name) se_doclist[0].fields.update({ "posting_date": "2013-03-01", "posting_time": "00:00" }) se_doclist[1].fields.update({ "qty": 60.0, "transfer_qty": 60.0, "s_warehouse": "_Test Warehouse", "t_warehouse": "_Test Warehouse 1", "incoming_rate": 1.0 }) se_doclist[2].fields.update({ "qty": 3.0, "transfer_qty": 3.0, "s_warehouse": "_Test Warehouse 1", "incoming_rate": 1.0 }) # check for stopped status of Material Request se = webnotes.bean(copy=se_doclist) self.assertRaises(webnotes.MappingMismatchError, se.insert)
def update_dob_event(self): if self.doc.status == "Active" and self.doc.date_of_birth \ and not cint(webnotes.conn.get_value("HR Settings", None, "stop_birthday_reminders")): birthday_event = webnotes.conn.sql("""select name from `tabEvent` where repeat_on='Every Year' and ref_type='Employee' and ref_name=%s""", self.doc.name) starts_on = self.doc.date_of_birth + " 00:00:00" ends_on = self.doc.date_of_birth + " 00:15:00" if birthday_event: event = webnotes.bean("Event", birthday_event[0][0]) event.doc.starts_on = starts_on event.doc.ends_on = ends_on event.save() else: webnotes.bean({ "doctype": "Event", "subject": _("Birthday") + ": " + self.doc.employee_name, "description": _("Happy Birthday!") + " " + self.doc.employee_name, "starts_on": starts_on, "ends_on": ends_on, "event_type": "Public", "all_day": 1, "send_reminder": 1, "repeat_this_event": 1, "repeat_on": "Every Year", "ref_type": "Employee", "ref_name": self.doc.name }).insert() else: webnotes.conn.sql("""delete from `tabEvent` where repeat_on='Every Year' and ref_type='Employee' and ref_name=%s""", self.doc.name)
def test_journal_voucher_with_against_jv(self): self.clear_account_balance() jv_invoice = webnotes.bean(copy=test_records[2]) jv_invoice.insert() jv_invoice.submit() self.assertTrue(not webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.doc.name)) jv_payment = webnotes.bean(copy=test_records[0]) jv_payment.doclist[1].against_jv = jv_invoice.doc.name jv_payment.insert() jv_payment.submit() self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.doc.name)) self.assertTrue(webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s and credit=400""", jv_invoice.doc.name)) # cancel jv_invoice jv_invoice.cancel() self.assertTrue(not webnotes.conn.sql("""select name from `tabJournal Voucher Detail` where against_jv=%s""", jv_invoice.doc.name))
def make_return_jv(stock_entry): se = webnotes.bean("Stock Entry", stock_entry) if not se.doc.purpose in ["Sales Return", "Purchase Return"]: return ref = get_return_doclist_and_details(se.doc.fields) if ref.doclist[0].doctype == "Delivery Note": result = make_return_jv_from_delivery_note(se, ref) elif ref.doclist[0].doctype == "Sales Invoice": result = make_return_jv_from_sales_invoice(se, ref) elif ref.doclist[0].doctype == "Purchase Receipt": result = make_return_jv_from_purchase_receipt(se, ref) # create jv doclist and fetch balance for each unique row item jv_list = [{ "__islocal": 1, "doctype": "Journal Voucher", "posting_date": se.doc.posting_date, "voucher_type": se.doc.purpose == "Sales Return" and "Credit Note" or "Debit Note", "fiscal_year": se.doc.fiscal_year, "company": se.doc.company }] from accounts.utils import get_balance_on for r in result: jv_list.append({ "__islocal": 1, "doctype": "Journal Voucher Detail", "parentfield": "entries", "account": r.get("account"), "against_invoice": r.get("against_invoice"), "against_voucher": r.get("against_voucher"), "balance": get_balance_on(r.get("account"), se.doc.posting_date) }) return jv_list
def get_website_args(): customer = webnotes.conn.get_value("Contact", {"email_id": webnotes.session.user}, "customer") bean = webnotes.bean("Sales Order", webnotes.form_dict.name) if bean.doc.customer != customer: return {"doc": {"name": "Not Allowed"}} else: return { "doc": bean.doc, "doclist": bean.doclist, "webnotes": webnotes, "utils": webnotes.utils }
def _test(i): self.assertEquals( i + 1, webnotes.conn.sql( """select count(*) from `tabSales Invoice` where recurring_id=%s and docstatus=1""", base_si.doc.recurring_id)[0][0]) next_date = add_months(base_si.doc.posting_date, no_of_months) manage_recurring_invoices(next_date=next_date, commit=False) recurred_invoices = webnotes.conn.sql( """select name from `tabSales Invoice` where recurring_id=%s and docstatus=1 order by name desc""", base_si.doc.recurring_id) self.assertEquals(i + 2, len(recurred_invoices)) new_si = webnotes.bean("Sales Invoice", recurred_invoices[0][0]) for fieldname in [ "convert_into_recurring_invoice", "recurring_type", "repeat_on_day_of_month", "notification_email_address" ]: self.assertEquals(base_si.doc.fields.get(fieldname), new_si.doc.fields.get(fieldname)) self.assertEquals(new_si.doc.posting_date, unicode(next_date)) self.assertEquals( new_si.doc.invoice_period_from_date, unicode( add_months(base_si.doc.invoice_period_from_date, no_of_months))) if first_and_last_day: self.assertEquals( new_si.doc.invoice_period_to_date, unicode( get_last_day( add_months(base_si.doc.invoice_period_to_date, no_of_months)))) else: self.assertEquals( new_si.doc.invoice_period_to_date, unicode( add_months(base_si.doc.invoice_period_to_date, no_of_months))) return new_si
def _add_calendar_event(self, opts): opts = webnotes._dict(opts) if self.doc.contact_date: event_doclist = [{ "doctype": "Event", "owner": opts.owner or self.doc.owner, "subject": opts.subject, "description": opts.description, "starts_on": self.doc.contact_date + " 10:00:00", "event_type": "Private", "ref_type": self.doc.doctype, "ref_name": self.doc.name }] if webnotes.conn.exists("Profile", self.doc.contact_by): event_doclist.append({ "doctype": "Event User", "parentfield": "event_individuals", "person": self.doc.contact_by }) webnotes.bean(event_doclist).insert()
def save_address(fields, address_fieldname=None): party = get_lead_or_customer() fields = webnotes.load_json(fields) if fields.get("name"): bean = webnotes.bean("Address", fields.get("name")) else: bean = webnotes.bean({"doctype": "Address", "__islocal": 1}) bean.doc.fields.update(fields) party_fieldname = party.doctype.lower() bean.doc.fields.update({ party_fieldname: party.name, (party_fieldname + "_name"): party.fields[party_fieldname + "_name"] }) bean.ignore_permissions = True bean.save() if address_fieldname: update_cart_address(address_fieldname, bean.doc.name) return bean.doc.name
def test_aii_gl_entries_for_serial_no_delivered(self): webnotes.defaults.set_global_default("auto_inventory_accounting", 1) sr = webnotes.bean(copy=test_records[0]) sr.doc.serial_no = "_Test Serial No 2" sr.doc.status = "Delivered" sr.insert() gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Serial No' and voucher_no=%s order by account desc""", sr.doc.name, as_dict=1) self.assertFalse(gl_entries) webnotes.defaults.set_global_default("auto_inventory_accounting", 0)
def validate_leave_approver(self): employee = webnotes.bean("Employee", self.doc.employee) leave_approvers = [l.leave_approver for l in employee.doclist.get({"parentfield": "employee_leave_approvers"})] if len(leave_approvers) and self.doc.leave_approver not in leave_approvers: msgprint(("[" + _("For Employee") + ' "' + self.doc.employee + '"] ' + _("Leave Approver can be one of") + ": " + comma_or(leave_approvers)), raise_exception=InvalidLeaveApproverError) elif self.doc.leave_approver and not webnotes.conn.sql("""select name from `tabUserRole` where parent=%s and role='Leave Approver'""", self.doc.leave_approver): msgprint(get_fullname(self.doc.leave_approver) + ": " \ + _("does not have role 'Leave Approver'"), raise_exception=InvalidLeaveApproverError)
def export_json(doctype, name, path): from webnotes.handler import json_handler if not name or name == "-": name = doctype with open(path, "w") as outfile: doclist = [d.fields for d in webnotes.bean(doctype, name).doclist] for d in doclist: if d.get("parent"): del d["parent"] del d["name"] d["__islocal"] = 1 outfile.write( json.dumps(doclist, default=json_handler, indent=1, sort_keys=True))
def save_url(file_url, dt, dn): if not (file_url.startswith("http://") or file_url.startswith("https://")): webnotes.msgprint("URL must start with 'http://' or 'https://'") return None, None f = webnotes.bean({ "doctype": "File Data", "file_url": file_url, "attached_to_doctype": dt, "attached_to_name": dn }) f.ignore_permissions = True f.insert(); return f.doc
def reset_password(user): user = webnotes.form_dict.get('user', '') if user in ["*****@*****.**", "Administrator"]: return "Not allowed" if webnotes.conn.sql("""select name from tabProfile where name=%s""", user): # Hack! webnotes.session["user"] = "******" profile = webnotes.bean("Profile", user) profile.get_controller().reset_password() return "Password reset details sent to your email." else: return "No such user (%s)" % user
def test_serial_no_transfer_in(self): se = webnotes.bean(copy=test_records[0]) se.doclist[1].item_code = "_Test Serialized Item" se.doclist[1].qty = 2 se.doclist[1].serial_no = "ABCD\nEFGH" se.doclist[1].transfer_qty = 2 se.insert() se.submit() self.assertTrue(webnotes.conn.exists("Serial No", "ABCD")) self.assertTrue(webnotes.conn.exists("Serial No", "EFGH")) se.cancel() self.assertFalse(webnotes.conn.get_value("Serial No", "ABCD", "warehouse"))
def import_doc(d, doctype, overwrite, row_idx, submit=False): """import main (non child) document""" if webnotes.conn.exists(doctype, d['name']): if overwrite: bean = webnotes.bean(doctype, d['name']) bean.doc.fields.update(d) if d.get("docstatus") == 1: bean.update_after_submit() else: bean.save() return 'Updated row (#%d) %s' % (row_idx, getlink(doctype, d['name'])) else: return 'Ignored row (#%d) %s (exists)' % (row_idx, getlink(doctype, d['name'])) else: bean = webnotes.bean([d]) bean.insert() if submit: bean.submit() return 'Inserted row (#%d) %s' % (row_idx, getlink(doctype, bean.doc.fields['name']))
def insert(doclist): if not isinstance(doclist, list): doclist = [doclist] for d in doclist: if isinstance(d, dict): d["__islocal"] = 1 else: d.fields["__islocal"] = 1 wrapper = webnotes.bean(doclist) wrapper.save() return wrapper
def create_suppliers(args): for i in xrange(1, 6): supplier = args.get("supplier_" + str(i)) if supplier: webnotes.bean({ "doctype": "Supplier", "supplier_name": supplier, "supplier_type": "Local", "company": args.get("company_name") }).insert() if args.get("supplier_contact_" + str(i)): contact = args.get("supplier_contact_" + str(i)).split(" ") webnotes.bean({ "doctype": "Contact", "supplier": supplier, "first_name": contact[0], "last_name": len(contact) > 1 and contact[1] or "" }).insert()
def test_serial_warehouse_error(self): self._clear_stock_account_balance() make_serialized_item() se = webnotes.bean(copy=test_records[0]) se.doc.purpose = "Material Transfer" se.doclist[1].item_code = "_Test Serialized Item With Series" se.doclist[1].qty = 1 se.doclist[1].transfer_qty = 1 se.doclist[1].serial_no = "ABCD00001" se.doclist[1].s_warehouse = "_Test Warehouse 1 - _TC" se.doclist[1].t_warehouse = "_Test Warehouse - _TC" se.insert() self.assertRaises(SerialNoWarehouseError, se.submit)
def test_make_sales_order(self): from selling.doctype.quotation.quotation import make_sales_order quotation = webnotes.bean(copy=test_records[0]) quotation.insert() self.assertRaises(webnotes.ValidationError, make_sales_order, quotation.doc.name) quotation.submit() sales_order = make_sales_order(quotation.doc.name) self.assertEquals(sales_order[0]["doctype"], "Sales Order") self.assertEquals(len(sales_order), 2) self.assertEquals(sales_order[1]["doctype"], "Sales Order Item") self.assertEquals(sales_order[1]["prevdoc_docname"], quotation.doc.name) self.assertEquals(sales_order[0]["customer"], "_Test Customer") sales_order[0]["delivery_date"] = "2014-01-01" sales_order[0]["naming_series"] = "_T-Quotation-" webnotes.bean(sales_order).insert()
def make_return_jv_from_delivery_note(se, ref): invoices_against_delivery = get_invoice_list("Sales Invoice Item", "delivery_note", ref.doclist[0].name) if not invoices_against_delivery: sales_orders_against_delivery = [d.against_sales_order for d in ref.doclist if d.against_sales_order] if sales_orders_against_delivery: invoices_against_delivery = get_invoice_list("Sales Invoice Item", "sales_order", sales_orders_against_delivery) if not invoices_against_delivery: return [] packing_item_parent_map = dict([[d.item_code, d.parent_item] for d in ref.doclist.get( {"parentfield": ref.parentfields[1]})]) parent = {} children = [] for se_item in se.doclist.get({"parentfield": "mtn_details"}): for sales_invoice in invoices_against_delivery: si = webnotes.bean("Sales Invoice", sales_invoice) if se_item.item_code in packing_item_parent_map: ref_item = si.doclist.get({"item_code": packing_item_parent_map[se_item.item_code]}) else: ref_item = si.doclist.get({"item_code": se_item.item_code}) if not ref_item: continue ref_item = ref_item[0] account = get_sales_account_from_item(si.doclist, ref_item) if account not in children: children.append(account) if not parent: parent = {"account": si.doc.debit_to} break if len(invoices_against_delivery) == 1: parent["against_invoice"] = invoices_against_delivery[0] result = [parent] + [{"account": account} for account in children] return result
def test_overlapping_conditions(self): for range_a, range_b in [ ((50, 150), (0, 100)), ((50, 150), (100, 200)), ((50, 150), (75, 125)), ((50, 150), (25, 175)), ((50, 150), (50, 150)), ]: shipping_rule = webnotes.bean(copy=test_records[0]) shipping_rule.doclist[1].from_value = range_a[0] shipping_rule.doclist[1].to_value = range_a[1] shipping_rule.doclist[2].from_value = range_b[0] shipping_rule.doclist[2].to_value = range_b[1] self.assertRaises(OverlappingConditionError, shipping_rule.insert)
def on_submit(self): if not getlist(self.doclist, 'maintenance_schedule_detail'): msgprint("Please click on 'Generate Schedule' to get schedule") raise Exception self.check_serial_no_added() self.validate_serial_no_warranty() self.validate_schedule() email_map ={} for d in getlist(self.doclist, 'item_maintenance_detail'): if d.serial_no: self.update_amc_date(d.serial_no, d.end_date) if d.incharge_name not in email_map: email_map[d.incharge_name] = webnotes.bean("Sales Person", d.incharge_name).run_method("get_email_id") scheduled_date =webnotes.conn.sql("select scheduled_date from `tabMaintenance Schedule Detail` \ where incharge_name='%s' and item_code='%s' and parent='%s' " %(d.incharge_name, \ d.item_code, self.doc.name), as_dict=1) for key in scheduled_date: if email_map[d.incharge_name]: description = "Reference: %s, Item Code: %s and Customer: %s" % \ (self.doc.name, d.item_code, self.doc.customer) webnotes.bean({ "doctype": "Event", "owner": email_map[d.incharge_name] or self.doc.owner, "subject": description, "description": description, "starts_on": key["scheduled_date"] + " 10:00:00", "event_type": "Private", "ref_type": self.doc.doctype, "ref_name": self.doc.name }).insert() webnotes.conn.set(self.doc, 'status', 'Submitted')
def execute(): webnotes.reload_doc("selling", "doctype", "shopping_cart_price_list") webnotes.reload_doc("setup", "doctype", "item_price") for t in [ ("Supplier Quotation", "price_list_name", "buying_price_list"), ("Purchase Order", "price_list_name", "buying_price_list"), ("Purchase Invoice", "price_list_name", "buying_price_list"), ("Purchase Receipt", "price_list_name", "buying_price_list"), ("Quotation", "price_list_name", "selling_price_list"), ("Sales Order", "price_list_name", "selling_price_list"), ("Delivery Note", "price_list_name", "selling_price_list"), ("Sales Invoice", "price_list_name", "selling_price_list"), ("POS Setting", "price_list_name", "selling_price_list"), ("Shopping Cart Price List", "price_list", "selling_price_list"), ("Item Price", "price_list_name", "price_list"), ("BOM", "price_list", "buying_price_list"), ]: table_columns = webnotes.conn.get_table_columns(t[0]) if t[2] in table_columns and t[1] in table_columns: # already reloaded, so copy into new column and drop old column webnotes.conn.sql("""update `tab%s` set `%s`=`%s`""" % (t[0], t[2], t[1])) webnotes.conn.sql_ddl("""alter table `tab%s` drop column `%s`""" % (t[0], t[1])) elif t[1] in table_columns: webnotes.conn.sql_ddl( "alter table `tab%s` change `%s` `%s` varchar(180)" % t) webnotes.reload_doc(webnotes.conn.get_value("DocType", t[0], "module"), "DocType", t[0]) webnotes.conn.sql("""update tabSingles set field='selling_price_list' where field='price_list_name' and doctype='Selling Settings'""") webnotes.reload_doc("Selling", "DocType", "Selling Settings") webnotes.bean("Selling Settings").save()
def test_sales_invoice_calculation_export_currency(self): si = webnotes.bean(copy=test_records[2]) si.doc.currency = "USD" si.doc.conversion_rate = 50 si.doclist[1].export_rate = 1 si.doclist[1].ref_rate = 1 si.doclist[2].export_rate = 3 si.doclist[2].ref_rate = 3 si.insert() expected_values = { "keys": ["ref_rate", "adj_rate", "export_rate", "export_amount", "base_ref_rate", "basic_rate", "amount"], "_Test Item Home Desktop 100": [1, 0, 1, 10, 50, 50, 500], "_Test Item Home Desktop 200": [3, 0, 3, 15, 150, 150, 750], } # check if children are saved self.assertEquals(len(si.doclist.get({"parentfield": "entries"})), len(expected_values)-1) # check if item values are calculated for d in si.doclist.get({"parentfield": "entries"}): for i, k in enumerate(expected_values["keys"]): self.assertEquals(d.fields.get(k), expected_values[d.item_code][i]) # check net total self.assertEquals(si.doc.net_total, 1250) self.assertEquals(si.doc.net_total_export, 25) # check tax calculation expected_values = { "keys": ["tax_amount", "total"], "_Test Account Shipping Charges - _TC": [100, 1350], "_Test Account Customs Duty - _TC": [125, 1475], "_Test Account Excise Duty - _TC": [140, 1615], "_Test Account Education Cess - _TC": [2.8, 1617.8], "_Test Account S&H Education Cess - _TC": [1.4, 1619.2], "_Test Account CST - _TC": [32.38, 1651.58], "_Test Account VAT - _TC": [156.25, 1807.83], "_Test Account Discount - _TC": [-180.78, 1627.05] } for d in si.doclist.get({"parentfield": "other_charges"}): for i, k in enumerate(expected_values["keys"]): self.assertEquals(d.fields.get(k), expected_values[d.account_head][i]) self.assertEquals(si.doc.grand_total, 1627.05) self.assertEquals(si.doc.grand_total_export, 32.54)
def test_material_issue_gl_entry(self): self._clear_stock_account_balance() set_perpetual_inventory() self._insert_material_receipt() mi = webnotes.bean(copy=test_records[1]) mi.insert() mi.submit() self.check_stock_ledger_entries( "Stock Entry", mi.doc.name, [["_Test Item", "_Test Warehouse - _TC", -40.0]]) stock_in_hand_account = webnotes.conn.get_value( "Account", { "account_type": "Warehouse", "master_name": mi.doclist[1].s_warehouse }) self.check_gl_entries( "Stock Entry", mi.doc.name, sorted([[stock_in_hand_account, 0.0, 4000.0], ["Stock Adjustment - _TC", 4000.0, 0.0]])) mi.cancel() self.assertFalse( webnotes.conn.sql( """select * from `tabStock Ledger Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mi.doc.name)) self.assertFalse( webnotes.conn.sql( """select * from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s""", mi.doc.name)) self.assertEquals( webnotes.conn.get_value( "Bin", { "warehouse": mi.doclist[1].s_warehouse, "item_code": mi.doclist[1].item_code }, "actual_qty"), 50) self.assertEquals( webnotes.conn.get_value( "Bin", { "warehouse": mi.doclist[1].s_warehouse, "item_code": mi.doclist[1].item_code }, "stock_value"), 5000)
def add_comment(args=None): """ args = { 'comment': '', 'comment_by': '', 'comment_by_fullname': '', 'comment_doctype': '', 'comment_docname': '', 'page_name': '', } """ if not args: args = webnotes.local.form_dict args['doctype'] = "Comment" page_name = args.get("page_name") if "page_name" in args: del args["page_name"] if "cmd" in args: del args["cmd"] comment = webnotes.bean(args) comment.ignore_permissions = True comment.insert() # since comments are embedded in the page, clear the web cache webnotes.webutils.clear_cache(page_name) # notify commentors commentors = [d[0] for d in webnotes.conn.sql("""select comment_by from tabComment where comment_doctype=%s and comment_docname=%s and ifnull(unsubscribed, 0)=0""", (comment.doc.comment_doctype, comment.doc.comment_docname))] owner = webnotes.conn.get_value(comment.doc.comment_doctype, comment.doc.comment_docname, "owner") from webnotes.utils.email_lib.bulk import send send(recipients=list(set(commentors + [owner])), doctype='Comment', email_field='comment_by', subject='New Comment on %s: %s' % (comment.doc.comment_doctype, comment.doc.title or comment.doc.comment_docname), message='%(comment)s<p>By %(comment_by_fullname)s</p>' % args, ref_doctype=comment.doc.comment_doctype, ref_docname=comment.doc.comment_docname) template = webnotes.get_template("lib/website/templates/includes/comment.html") return template.render({"comment": comment.doc.fields})
def make_return_jv_from_purchase_receipt(se, ref): invoice_against_receipt = get_invoice_list("Purchase Invoice Item", "purchase_receipt", ref.doclist[0].name) if not invoice_against_receipt: purchase_orders_against_receipt = [ d.prevdoc_docname for d in ref.doclist.get({"prevdoc_doctype": "Purchase Order"}) if d.prevdoc_docname ] if purchase_orders_against_receipt: invoice_against_receipt = get_invoice_list( "Purchase Invoice Item", "purchase_order", purchase_orders_against_receipt) if not invoice_against_receipt: return [] parent = {} children = [] for se_item in se.doclist.get({"parentfield": "mtn_details"}): for purchase_invoice in invoice_against_receipt: pi = webnotes.bean("Purchase Invoice", purchase_invoice) ref_item = pi.doclist.get({"item_code": se_item.item_code}) if not ref_item: continue ref_item = ref_item[0] account = ref_item.expense_head if account not in children: children.append(account) if not parent: parent = {"account": pi.doc.credit_to} break if len(invoice_against_receipt) == 1: parent["against_voucher"] = invoice_against_receipt[0] result = [parent] + [{"account": account} for account in children] return result
def test_make_sales_invoice(self): from selling.doctype.sales_order.sales_order import make_sales_invoice so = webnotes.bean(copy=test_records[0]).insert() self.assertRaises(webnotes.ValidationError, make_sales_invoice, so.doc.name) sales_order = webnotes.bean("Sales Order", so.doc.name) sales_order.submit() si = make_sales_invoice(so.doc.name) self.assertEquals(si[0]["doctype"], "Sales Invoice") self.assertEquals(len(si), len(sales_order.doclist)) self.assertEquals( len([d for d in si if d["doctype"] == "Sales Invoice Item"]), 1) si = webnotes.bean(si) si.insert() si.submit() si1 = make_sales_invoice(so.doc.name) self.assertEquals( len([d for d in si1 if d["doctype"] == "Sales Invoice Item"]), 0)
def create_dn_against_so(self, so, delivered_qty=0): from stock.doctype.delivery_note.test_delivery_note import test_records as dn_test_records from stock.doctype.delivery_note.test_delivery_note import _insert_purchase_receipt _insert_purchase_receipt(so.doclist[1].item_code) dn = webnotes.bean(webnotes.copy_doclist(dn_test_records[0])) dn.doclist[1].item_code = so.doclist[1].item_code dn.doclist[1].against_sales_order = so.doc.name dn.doclist[1].prevdoc_detail_docname = so.doclist[1].name if delivered_qty: dn.doclist[1].qty = delivered_qty dn.insert() dn.submit() return dn
def test_closing_entry(self): # clear GL Entries webnotes.conn.sql("""delete from `tabGL Entry`""") from accounts.doctype.journal_voucher.test_journal_voucher import test_records as jv_records jv = webnotes.bean(copy=jv_records[2]) jv.insert() jv.submit() jv1 = webnotes.bean(copy=jv_records[0]) jv1.doclist[2].account = "_Test Account Cost for Goods Sold - _TC" jv1.doclist[2].debit = 600.0 jv1.doclist[1].credit = 600.0 jv1.insert() jv1.submit() pcv = webnotes.bean(copy=test_record) pcv.insert() pcv.submit() gl_entries = webnotes.conn.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s order by account asc, debit asc""", pcv.doc.name, as_dict=1) self.assertTrue(gl_entries) expected_gl_entries = sorted( [["_Test Account Reserves and Surplus - _TC", 200.0, 0.0], ["_Test Account Cost for Goods Sold - _TC", 0.0, 600.0], ["Sales - _TC", 400.0, 0.0]]) for i, gle in enumerate(gl_entries): self.assertEquals(expected_gl_entries[i][0], gle.account) self.assertEquals(expected_gl_entries[i][1], gle.debit) self.assertEquals(expected_gl_entries[i][2], gle.credit)
def add_support_communication(subject, content, sender, docname=None, mail=None): if docname: ticket = webnotes.bean("Support Ticket", docname) ticket.doc.status = 'Open' ticket.ignore_permissions = True ticket.doc.save() else: ticket = webnotes.bean([ decode_dict({ "doctype": "Support Ticket", "description": content, "subject": subject, "raised_by": sender, "content_type": mail.content_type if mail else None, "status": "Open", }) ]) ticket.ignore_permissions = True ticket.insert() make(content=content, sender=sender, subject=subject, doctype="Support Ticket", name=ticket.doc.name, date=mail.date if mail else today(), sent_or_received="Received") if mail: mail.save_attachments_in_doc(ticket.doc) return ticket
def get_transaction_context(doctype, name): customer = webnotes.conn.get_value("Contact", {"email_id": webnotes.session.user}, "customer") bean = webnotes.bean(doctype, name) if bean.doc.customer != customer: return {"doc": {"name": "Not Allowed"}} else: return { "doc": bean.doc, "doclist": bean.doclist, "webnotes": webnotes, "utils": webnotes.utils }
def update_parent_account(self): if not self.doc.__islocal and ( self.doc.create_account_under != webnotes.conn.get_value( "Warehouse", self.doc.name, "create_account_under")): warehouse_account = webnotes.conn.get_value( "Account", { "account_type": "Warehouse", "company": self.doc.company, "master_name": self.doc.name }, ["name", "parent_account"]) if warehouse_account and warehouse_account[ 1] != self.doc.create_account_under: acc_bean = webnotes.bean("Account", warehouse_account[0]) acc_bean.doc.parent_account = self.doc.create_account_under acc_bean.save()