def execute(): frappe.reload_doc('custom', 'doctype', 'custom_field', force=True) try: frappe.db.sql('update `tabCustom Field` set in_standard_filter = in_filter_dash') except Exception, e: if e.args[0]!=1054: raise e
def execute(): # convert milestones to tasks frappe.reload_doctype("Project") frappe.reload_doc("projects", "doctype", "project_task") frappe.reload_doctype("Task") frappe.reload_doc("projects", "doctype", "task_depends_on") for m in frappe.get_all("Project Milestone", "*"): if (m.milestone and m.milestone_date and frappe.db.exists("Project", m.parent)): task = frappe.get_doc({ "doctype": "Task", "subject": m.milestone, "expected_start_date": m.milestone_date, "status": "Open" if m.status=="Pending" else "Closed", "project": m.parent, }) task.flags.ignore_mandatory = True task.insert(ignore_permissions=True) # remove project milestone frappe.delete_doc("DocType", "Project Milestone") # remove calendar events for milestone for e in frappe.get_all("Event", ["name"], {"ref_type": "Project"}): frappe.delete_doc("Event", e.name)
def execute(): """ rename feedback request documents, update the feedback request and save the rating and communication reference in Feedback Request document """ frappe.reload_doc("core", "doctype", "feedback_request") feedback_requests = frappe.get_all("Feedback Request") for request in feedback_requests: communication, rating = frappe.db.get_value("Communication", { "feedback_request": request.get("name") }, ["name", "rating"]) or [None, 0] if communication: frappe.db.sql("""update `tabFeedback Request` set reference_communication='{communication}', rating={rating} where name='{feedback_request}'""".format( communication=communication, rating=rating or 0, feedback_request=request.get("name") )) if "Feedback" not in request.get("name"): # rename the feedback request doc reference_name, creation = frappe.db.get_value("Feedback Request", request.get("name"), ["name", "creation"]) oldname = request.get("name") newname = "Feedback for {doctype} {docname} on {datetime}".format( doctype="Feedback Request", docname=reference_name, datetime=creation ) frappe.rename_doc("Feedback Request", oldname, newname, ignore_permissions=True) if communication: frappe.db.set_value("Communication", communication, "feedback_request", newname)
def execute(): frappe.reload_doc("education", "doctype", "student_attendance") frappe.db.sql(''' update `tabStudent Attendance` set docstatus=0 where docstatus=1''')
def execute(): ''' Fields to move from the item to item defaults child table [ default_warehouse, buying_cost_center, expense_account, selling_cost_center, income_account ] ''' if not frappe.db.has_column('Item', 'default_warehouse'): return frappe.reload_doc('stock', 'doctype', 'item_default') frappe.reload_doc('stock', 'doctype', 'item') if frappe.db.a_row_exists('Item Default'): return companies = frappe.get_all("Company") if len(companies) == 1: try: frappe.db.sql(''' INSERT INTO `tabItem Default` (name, parent, parenttype, parentfield, idx, company, default_warehouse, buying_cost_center, selling_cost_center, expense_account, income_account, default_supplier) SELECT SUBSTRING(SHA2(name,224), 1, 10) as name, name as parent, 'Item' as parenttype, 'item_defaults' as parentfield, 1 as idx, %s as company, default_warehouse, buying_cost_center, selling_cost_center, expense_account, income_account, default_supplier FROM `tabItem`; ''', companies[0].name) except: pass else: item_details = frappe.get_all("Item", fields=["name", "default_warehouse", "buying_cost_center", "expense_account", "selling_cost_center", "income_account"], limit=100) for item in item_details: item_defaults = [] def insert_into_item_defaults(doc_field_name, doc_field_value, company): for d in item_defaults: if d.get("company") == company: d[doc_field_name] = doc_field_value return item_defaults.append({ "company": company, doc_field_name: doc_field_value }) for d in [ ["default_warehouse", "Warehouse"], ["expense_account", "Account"], ["income_account", "Account"], ["buying_cost_center", "Cost Center"], ["selling_cost_center", "Cost Center"] ]: if item.get(d[0]): company = frappe.get_value(d[1], item.get(d[0]), "company", cache=True) insert_into_item_defaults(d[0], item.get(d[0]), company) doc = frappe.get_doc("Item", item.name) doc.extend("item_defaults", item_defaults) for child_doc in doc.item_defaults: child_doc.db_insert()
def execute(): if frappe.db.table_exists("Offer Letter") and not frappe.db.table_exists("Job Offer"): frappe.rename_doc("DocType", "Offer Letter", "Job Offer", force=True) frappe.rename_doc("DocType", "Offer Letter Term", "Job Offer Term", force=True) frappe.reload_doc("hr", "doctype", "job_offer") frappe.reload_doc("hr", "doctype", "job_offer_term") frappe.delete_doc("Print Format", "Offer Letter")
def execute(): frappe.reload_doc("email", "doctype", "email_template") if not frappe.db.exists("Email Template", _('Leave Approval Notification')): base_path = frappe.get_app_path("erpnext", "hr", "doctype") response = frappe.read_file(os.path.join(base_path, "leave_application/leave_application_email_template.html")) frappe.get_doc({ 'doctype': 'Email Template', 'name': _("Leave Approval Notification"), 'response': response, 'subject': _("Leave Approval Notification"), 'owner': frappe.session.user, }).insert(ignore_permissions=True) if not frappe.db.exists("Email Template", _('Leave Status Notification')): base_path = frappe.get_app_path("erpnext", "hr", "doctype") response = frappe.read_file(os.path.join(base_path, "leave_application/leave_application_email_template.html")) frappe.get_doc({ 'doctype': 'Email Template', 'name': _("Leave Status Notification"), 'response': response, 'subject': _("Leave Status Notification"), 'owner': frappe.session.user, }).insert(ignore_permissions=True)
def execute(): frappe.reload_doc('website', 'doctype', 'style_settings') style_settings = frappe.get_doc("Style Settings", "Style Settings") if not style_settings.apply_style: style_settings.update(default_properties) style_settings.apply_style = 1 style_settings.save()
def execute(): frappe.reload_doc("erpnext_integrations", "doctype","woocommerce_settings") doc = frappe.get_doc("Woocommerce Settings") if cint(doc.enable_sync): doc.creation_user = doc.modified_by doc.save(ignore_permissions=True)
def execute(): """ Patch Reference: 1. check whether warehouse is associated to company or not 2. if warehouse is associated with company a. create warehouse group for company b. set warehouse group as parent to other warehouses and set is_group as 0 3. if warehouses is not associated with company a. get distinct companies from stock ledger entries b. if sle have only company, i. set default company to all warehouse ii. repeat 2.a and 2.b c. if have multiple companies, i. create group warehouse without company ii. repeat 2.b """ frappe.reload_doc("stock", "doctype", "warehouse") if check_is_warehouse_associated_with_company(): for company in frappe.get_all("Company", fields=["name", "abbr"]): make_warehouse_nestedset(company) else: sle_against_companies = frappe.db.sql_list("""select distinct company from `tabStock Ledger Entry`""") if len(sle_against_companies) == 1: company = frappe.get_cached_value('Company', sle_against_companies[0], fieldname=["name", "abbr"], as_dict=1) set_company_to_warehouse(company.name) make_warehouse_nestedset(company) elif len(sle_against_companies) > 1: make_warehouse_nestedset()
def execute(): # 'Schools' module changed to the 'Education' # frappe.reload_doc('schools', 'doctype', 'Student Admission Program') # frappe.reload_doc('schools', 'doctype', 'student_admission') frappe.reload_doc('education', 'doctype', 'Student Admission Program') frappe.reload_doc('education', 'doctype', 'student_admission') if "program" not in frappe.db.get_table_columns("Student Admission"): return student_admissions = frappe.get_all("Student Admission", fields=["name", "application_fee", \ "naming_series_for_student_applicant", "program", "introduction", "eligibility"]) for student_admission in student_admissions: doc = frappe.get_doc("Student Admission", student_admission.name) doc.append("program_details", { "program": student_admission.get("program"), "application_fee": student_admission.get("application_fee"), "applicant_naming_series": student_admission.get("naming_series_for_student_applicant"), }) if student_admission.eligibility and student_admission.introduction: doc.introduction = student_admission.introduction + "<br><div>" + \ student_admission.eligibility + "</div>" doc.flags.ignore_validate = True doc.flags.ignore_mandatory = True doc.save()
def execute(): frappe.reload_doc('projects', 'doctype', 'timesheet') if not frappe.db.table_exists("Time Log"): return for data in frappe.db.sql("select * from `tabTime Log` where docstatus < 2", as_dict=1): if data.task: company = frappe.db.get_value("Task", data.task, "company") elif data.production_order: company = frappe.db.get_value("Prodction Order", data.production_order, "company") else: company = frappe.db.get_single_value('Global Defaults', 'default_company') time_sheet = make_timesheet(data.production_order) args = get_timelog_data(data) add_timesheet_detail(time_sheet, args) time_sheet.employee = data.employee time_sheet.note = data.note time_sheet.company = company time_sheet.set_status() time_sheet.set_dates() time_sheet.update_cost() time_sheet.calculate_total_amounts() time_sheet.flags.ignore_validate = True time_sheet.save(ignore_permissions=True) # To ignore validate_mandatory_fields function if data.docstatus == 1: time_sheet.db_set("docstatus", 1) for d in time_sheet.get("time_logs"): d.db_set("docstatus", 1) time_sheet.update_production_order(time_sheet.name) time_sheet.update_task_and_project()
def execute(): """ Set the Serial Numbers in Sales Invoice Item from Delivery Note Item """ frappe.reload_doc("stock", "doctype", "serial_no") frappe.db.sql(""" update `tabSales Invoice Item` sii inner join `tabDelivery Note Item` dni on sii.dn_detail=dni.name and sii.qty=dni.qty set sii.serial_no=dni.serial_no where sii.parent IN (select si.name from `tabSales Invoice` si where si.update_stock=0 and si.docstatus=1)""") items = frappe.db.sql(""" select sii.parent, sii.serial_no from `tabSales Invoice Item` sii left join `tabSales Invoice` si on sii.parent=si.name where si.docstatus=1 and si.update_stock=0""", as_dict=True) for item in items: sales_invoice = item.get("parent", None) serial_nos = item.get("serial_no", "") if not sales_invoice or not serial_nos: continue serial_nos = ["'%s'"%frappe.db.escape(no) for no in serial_nos.split("\n")] frappe.db.sql(""" UPDATE `tabSerial No` SET sales_invoice='{sales_invoice}' WHERE name in ({serial_nos}) """.format( sales_invoice=frappe.db.escape(sales_invoice), serial_nos=",".join(serial_nos) ) )
def execute(): frappe.reload_doc("accounts", "doctype", "account") frappe.db.sql(""" update tabAccount set account_type = "Stock" where account_type = "Warehouse" """) frappe.db.commit()
def execute(): rename_doc('DocType', 'Production Order', 'Work Order', force=True) frappe.reload_doc('manufacturing', 'doctype', 'work_order') rename_doc('DocType', 'Production Order Item', 'Work Order Item', force=True) frappe.reload_doc('manufacturing', 'doctype', 'work_order_item') rename_doc('DocType', 'Production Order Operation', 'Work Order Operation', force=True) frappe.reload_doc('manufacturing', 'doctype', 'work_order_operation') frappe.reload_doc('projects', 'doctype', 'timesheet') frappe.reload_doc('stock', 'doctype', 'stock_entry') rename_field("Timesheet", "production_order", "work_order") rename_field("Stock Entry", "production_order", "work_order") frappe.rename_doc("Report", "Production Orders in Progress", "Work Orders in Progress", force=True) frappe.rename_doc("Report", "Completed Production Orders", "Completed Work Orders", force=True) frappe.rename_doc("Report", "Open Production Orders", "Open Work Orders", force=True) frappe.rename_doc("Report", "Issued Items Against Production Order", "Issued Items Against Work Order", force=True) frappe.rename_doc("Report", "Production Order Stock Report", "Work Order Stock Report", force=True) frappe.db.sql("""update `tabDesktop Icon` \ set label='Work Order', module_name='Work Order' \ where label='Production Order'""") frappe.db.sql("""update `tabDesktop Icon` \ set link='List/Work Order' \ where link='List/Production Order'""")
def execute(): frappe.reload_doc("accounts", "doctype", "account") account_table_columns = frappe.db.get_table_columns("Account") if "debit_or_credit" in account_table_columns and "is_pl_account" in account_table_columns: frappe.db.sql("""UPDATE tabAccount SET root_type = CASE WHEN (debit_or_credit='Debit' and is_pl_account = 'No') THEN 'Asset' WHEN (debit_or_credit='Credit' and is_pl_account = 'No') THEN 'Liability' WHEN (debit_or_credit='Debit' and is_pl_account = 'Yes') THEN 'Expense' WHEN (debit_or_credit='Credit' and is_pl_account = 'Yes') THEN 'Income' END WHERE ifnull(parent_account, '') = '' """) else: for key, root_type in (("asset", "Asset"), ("liabilities", "Liability"), ("expense", "Expense"), ("income", "Income")): frappe.db.sql("""update tabAccount set root_type=%s where name like %s and ifnull(parent_account, '')=''""", (root_type, "%" + key + "%")) for root in frappe.db.sql("""SELECT name, lft, rgt, root_type FROM `tabAccount` WHERE ifnull(parent_account, '')=''""", as_dict=True): if root.root_type: frappe.db.sql("""UPDATE tabAccount SET root_type=%s WHERE lft>%s and rgt<%s""", (root.root_type, root.lft, root.rgt)) else: print b"Root type not found for {0}".format(root.name.encode("utf-8"))
def execute(): frappe.reload_doc('setup', 'doctype', 'party_type') party_types = {'Customer': 'Receivable', 'Supplier': 'Payable', 'Employee': 'Payable', 'Member': 'Receivable', 'Shareholder': 'Payable', 'Student': 'Receivable'} for party_type, account_type in party_types.items(): frappe.db.set_value('Party Type', party_type, 'account_type', account_type)
def execute(): frappe.reload_doc("accounts", "doctype", "pricing_rule") frappe.db.auto_commit_on_many_writes = True for d in frappe.db.sql("""select * from `tabCustomer Discount` where ifnull(parent, '') != '' and docstatus < 2""", as_dict=1): if not d.item_group: item_group = frappe.db.sql("""select name from `tabItem Group` where ifnull(parent_item_group, '') = ''""")[0][0] else: item_group = d.item_group frappe.get_doc({ "doctype": "Pricing Rule", "apply_on": "Item Group", "item_group": item_group, "applicable_for": "Customer", "customer": d.parent, "price_or_discount": "Discount", "discount_percentage": d.discount }).insert() frappe.db.auto_commit_on_many_writes = False frappe.delete_doc("DocType", "Customer Discount")
def execute(): frappe.reload_doc("accounts", "doctype", "pricing_rule") frappe.db.sql("""update `tabPricing Rule` set selling=1 where ifnull(applicable_for, '') in ('', 'Customer', 'Customer Group', 'Territory', 'Sales Partner', 'Campaign')""") frappe.db.sql("""update `tabPricing Rule` set buying=1 where ifnull(applicable_for, '') in ('', 'Supplier', 'Supplier Type')""")
def execute(): frappe.reload_doc("accounts", "doctype", "tax_rule") customers = frappe.db.sql("""select name, default_taxes_and_charges from tabCustomer where ifnull(default_taxes_and_charges, '') != '' """, as_dict=1) for d in customers: if not frappe.db.sql("select name from `tabTax Rule` where customer=%s", d.name): tr = frappe.new_doc("Tax Rule") tr.tax_type = "Sales" tr.customer = d.name tr.sales_tax_template = d.default_taxes_and_charges tr.save() suppliers = frappe.db.sql("""select name, default_taxes_and_charges from tabSupplier where ifnull(default_taxes_and_charges, '') != '' """, as_dict=1) for d in suppliers: if not frappe.db.sql("select name from `tabTax Rule` where supplier=%s", d.name): tr = frappe.new_doc("Tax Rule") tr.tax_type = "Purchase" tr.supplier = d.name tr.purchase_tax_template = d.default_taxes_and_charges tr.save()
def execute(): frappe.reload_doc("accounts", "doctype", "journal_entry") frappe.db.sql( """ update `tabJournal Entry` set total_amount_currency = %s where ifnull(multi_currency, 0) = 0 and (pay_to_recd_from is not null or pay_to_recd_from != "") """, get_default_currency(), ) for je in frappe.db.sql( """ select name from `tabJournal Entry` where multi_currency = 1 and (pay_to_recd_from is not null or pay_to_recd_from != "")""", as_dict=1, ): doc = frappe.get_doc("Journal Entry", je.name) for d in doc.get("accounts"): if d.party_type and d.party: total_amount_currency = d.account_currency elif frappe.db.get_value("Account", d.account, "account_type") in ["Bank", "Cash"]: total_amount_currency = d.account_currency frappe.db.set_value( "Journal Entry", je.name, "total_amount_currency", total_amount_currency, update_modified=False )
def execute(): frappe.reload_doc("Core", "DocType", "User") for user in frappe.db.get_all('User'): user = frappe.get_doc('User', user.name) user.set_full_name() user.db_set('full_name', user.full_name, update_modified = False)
def execute(): frappe.reload_doc('desk', 'doctype', 'auto_repeat') doctypes_to_rename = { 'accounts': ['Journal Entry', 'Payment Entry', 'Purchase Invoice', 'Sales Invoice'], 'buying': ['Purchase Order', 'Supplier Quotation'], 'selling': ['Quotation', 'Sales Order'], 'stock': ['Delivery Note', 'Purchase Receipt'] } for module, doctypes in doctypes_to_rename.items(): for doctype in doctypes: frappe.reload_doc(module, 'doctype', frappe.scrub(doctype)) if frappe.db.has_column(doctype, 'subscription'): rename_field(doctype, 'subscription', 'auto_repeat') subscriptions = frappe.db.sql('select * from `tabSubscription`', as_dict=1) for doc in subscriptions: doc['doctype'] = 'Auto Repeat' auto_repeat = frappe.get_doc(doc) auto_repeat.db_insert() frappe.db.sql('delete from `tabSubscription`') frappe.db.commit() drop_columns_from_subscription()
def execute(): #Rename Grading Structure to Grading Scale frappe.rename_doc("DocType", "Grading Structure", "Grading Scale", force=True) frappe.rename_doc("DocType", "Grade Interval", "Grading Scale Interval", force=True) frappe.reload_doc("schools", "doctype", "grading_scale_interval") rename_field("Grading Scale Interval", "to_score", "threshold") frappe.rename_doc("DocType", "Assessment", "Assessment Plan", force=True) #Rename Assessment Results frappe.reload_doc("schools", "doctype", "assessment_plan") rename_field("Assessment Plan", "grading_structure", "grading_scale") frappe.reload_doc("schools", "doctype", "assessment_result") frappe.reload_doc("schools", "doctype", "assessment_result_detail") frappe.reload_doc("schools", "doctype", "assessment_criteria") for assessment in frappe.get_all("Assessment Plan", fields=["name", "grading_scale"], filters = [["docstatus", "!=", 2 ]]): print assessment for stud_result in frappe.db.sql("select * from `tabAssessment Result` where parent= %s", assessment.name, as_dict=True): if stud_result.result: assessment_result = frappe.new_doc("Assessment Result") assessment_result.student = stud_result.student assessment_result.student_name = stud_result.student_name assessment_result.assessment_plan = assessment.name assessment_result.grading_scale = assessment.grading_scale assessment_result.total_score = stud_result.result assessment_result.flags.ignore_validate = True assessment_result.flags.ignore_mandatory = True assessment_result.save() frappe.db.sql("""delete from `tabAssessment Result` where parent != '' or parent is not null""")
def execute(): frappe.reload_doc('stock', 'doctype', 'item') language = frappe.get_single("System Settings").language if language and language.startswith('en'): return frappe.local.lang = language all_domains = frappe.get_hooks("domains") for domain in all_domains: translated_domain = _(domain, lang=language) if frappe.db.exists("Domain", translated_domain): #if domain already exists merged translated_domain and domain merge = False if frappe.db.exists("Domain", domain): merge=True frappe.rename_doc("Domain", translated_domain, domain, ignore_permissions=True, merge=merge) domain_settings = frappe.get_single("Domain Settings") active_domains = [d.domain for d in domain_settings.active_domains] try: for domain in active_domains: domain = frappe.get_doc("Domain", domain) domain.setup_domain() if int(frappe.db.get_single_value('System Settings', 'setup_complete')): domain.setup_sidebar_items() domain.setup_desktop_icons() domain.set_default_portal_role() except frappe.LinkValidationError: pass
def execute(): frappe.reload_doc('accounts', 'doctype', 'sales_invoice') frappe.reload_doc('accounts', 'doctype', 'purchase_invoice') frappe.db.sql(""" update `tabPurchase Invoice` set status = (Case When outstanding_amount = 0 and docstatus = 1 and is_return = 0 then 'Paid' when due_date < CURDATE() and outstanding_amount > 0 and docstatus =1 then 'Overdue' when due_date >= CURDATE() and outstanding_amount > 0 and docstatus =1 then 'Unpaid' when outstanding_amount < 0 and docstatus =1 then 'Debit Note Issued' when is_return = 1 and docstatus =1 then 'Return' when docstatus = 2 then 'Cancelled' else 'Draft' End)""") frappe.db.sql(""" update `tabSales Invoice` set status = (Case When outstanding_amount = 0 and docstatus = 1 and is_return = 0 then 'Paid' when due_date < CURDATE() and outstanding_amount > 0 and docstatus =1 then 'Overdue' when due_date >= CURDATE() and outstanding_amount > 0 and docstatus =1 then 'Unpaid' when outstanding_amount < 0 and docstatus =1 then 'Credit Note Issued' when is_return = 1 and docstatus =1 then 'Return' when docstatus = 2 then 'Cancelled' else 'Draft' End)""")
def execute(): if frappe.db.exists('DocType', 'View log'): # for mac users direct renaming would not work since mysql for mac saves table name in lower case # so while renaming `tabView log` to `tabView Log` we get "Table 'tabView Log' already exists" error # more info https://stackoverflow.com/a/44753093/5955589 , # https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_lower_case_table_names # here we are creating a temp table to store view log data frappe.db.sql("CREATE TABLE `ViewLogTemp` AS SELECT * FROM `tabView log`") # deleting old View log table frappe.db.sql("DROP table `tabView log`") frappe.delete_doc('DocType', 'View log') # reloading view log doctype to create `tabView Log` table frappe.reload_doc('core', 'doctype', 'view_log') # Move the data to newly created `tabView Log` table frappe.db.sql("INSERT INTO `tabView Log` SELECT * FROM `ViewLogTemp`") frappe.db.commit() # Delete temporary table frappe.db.sql("DROP table `ViewLogTemp`") else: frappe.reload_doc('core', 'doctype', 'view_log')
def execute(): frappe.reload_doc("email", "doctype", "email_group_member") if "newsletter_list" in frappe.db.get_table_columns("Email Group Member"): frappe.db.sql( """update `tabEmail Group Member` set email_group = newsletter_list where email_group is null or email_group = ''""" )
def execute(): ''' Enable translatable in these fields - Customer Name - Supplier Name - Contact Name - Item Name/ Description - Address ''' frappe.reload_doc('core', 'doctype', 'docfield') frappe.reload_doc('custom', 'doctype', 'custom_field') enable_for_fields = [ ['Customer', 'customer_name'], ['Supplier', 'supplier_name'], ['Contact', 'first_name'], ['Contact', 'last_name'], ['Item', 'item_name'], ['Item', 'description'], ['Address', 'address_line1'], ['Address', 'address_line2'], ] for f in enable_for_fields: frappe.get_doc({ 'doctype': 'Property Setter', 'doc_type': f[0], 'doctype_or_field': 'DocField', 'field_name': f[1], 'property': 'translatable', 'propery_type': 'Check', 'value': 1 }).db_insert()
def execute(): if frappe.db.table_exists("POS Profile User"): frappe.reload_doc('accounts', 'doctype', 'pos_profile_user') frappe.db.sql(""" update `tabPOS Profile User`, (select `tabPOS Profile User`.name from `tabPOS Profile User`, `tabPOS Profile` where `tabPOS Profile`.name = `tabPOS Profile User`.parent group by `tabPOS Profile User`.user, `tabPOS Profile`.company) as pfu set `tabPOS Profile User`.default = 1 where `tabPOS Profile User`.name = pfu.name""") else: doctype = 'POS Profile' frappe.reload_doc('accounts', 'doctype', doctype) frappe.reload_doc('accounts', 'doctype', 'pos_profile_user') frappe.reload_doc('accounts', 'doctype', 'pos_item_group') frappe.reload_doc('accounts', 'doctype', 'pos_customer_group') for doc in frappe.get_all(doctype): _doc = frappe.get_doc(doctype, doc.name) user = frappe.db.get_value(doctype, doc.name, 'user') if not user: continue _doc.append('applicable_for_users', { 'user': user, 'default': 1 }) _doc.pos_profile_name = user + ' - ' + _doc.company _doc.flags.ignore_validate = True _doc.flags.ignore_mandatory = True _doc.save()
def execute(): frappe.reload_doc('crm', 'doctype', 'sales_stage') frappe.local.lang = frappe.db.get_default("lang") or 'en' add_sale_stages()
def execute(): frappe.reload_doc('accounts', 'Print Format', 'POS Invoice')
def execute(): # Create a penalty account for loan types frappe.reload_doc('loan_management', 'doctype', 'loan_type') frappe.reload_doc('loan_management', 'doctype', 'loan') frappe.reload_doc('loan_management', 'doctype', 'repayment_schedule') frappe.reload_doc('loan_management', 'doctype', 'process_loan_interest_accrual') frappe.reload_doc('loan_management', 'doctype', 'loan_repayment') frappe.reload_doc('loan_management', 'doctype', 'loan_repayment_detail') frappe.reload_doc('loan_management', 'doctype', 'loan_interest_accrual') frappe.reload_doc('accounts', 'doctype', 'gl_entry') frappe.reload_doc('accounts', 'doctype', 'journal_entry_account') updated_loan_types = [] loans_to_close = [] # Update old loan status as closed if frappe.db.has_column('Repayment Schedule', 'paid'): loans_list = frappe.db.sql("""SELECT distinct parent from `tabRepayment Schedule` where paid = 0 and docstatus = 1""", as_dict=1) loans_to_close = [d.parent for d in loans_list] if loans_to_close: frappe.db.sql("UPDATE `tabLoan` set status = 'Closed' where name not in (%s)" % (', '.join(['%s'] * len(loans_to_close))), tuple(loans_to_close)) loans = frappe.get_all('Loan', fields=['name', 'loan_type', 'company', 'status', 'mode_of_payment', 'applicant_type', 'applicant', 'loan_account', 'payment_account', 'interest_income_account'], filters={'docstatus': 1, 'status': ('!=', 'Closed')}) for loan in loans: # Update details in Loan Types and Loan loan_type_company = frappe.db.get_value('Loan Type', loan.loan_type, 'company') loan_type = loan.loan_type group_income_account = frappe.get_value('Account', {'company': loan.company, 'is_group': 1, 'root_type': 'Income', 'account_name': _('Indirect Income')}) if not group_income_account: group_income_account = frappe.get_value('Account', {'company': loan.company, 'is_group': 1, 'root_type': 'Income'}) penalty_account = create_account(company=loan.company, account_type='Income Account', account_name='Penalty Account', parent_account=group_income_account) # Same loan type used for multiple companies if loan_type_company and loan_type_company != loan.company: # get loan type for appropriate company loan_type_name = frappe.get_value('Loan Type', {'company': loan.company, 'mode_of_payment': loan.mode_of_payment, 'loan_account': loan.loan_account, 'payment_account': loan.payment_account, 'interest_income_account': loan.interest_income_account, 'penalty_income_account': loan.penalty_income_account}, 'name') if not loan_type_name: loan_type_name = create_loan_type(loan, loan_type_name, penalty_account) # update loan type in loan frappe.db.sql("UPDATE `tabLoan` set loan_type = %s where name = %s", (loan_type_name, loan.name)) loan_type = loan_type_name if loan_type_name not in updated_loan_types: updated_loan_types.append(loan_type_name) elif not loan_type_company: loan_type_doc = frappe.get_doc('Loan Type', loan.loan_type) loan_type_doc.is_term_loan = 1 loan_type_doc.company = loan.company loan_type_doc.mode_of_payment = loan.mode_of_payment loan_type_doc.payment_account = loan.payment_account loan_type_doc.loan_account = loan.loan_account loan_type_doc.interest_income_account = loan.interest_income_account loan_type_doc.penalty_income_account = penalty_account loan_type_doc.submit() updated_loan_types.append(loan.loan_type) loan_type = loan.loan_type if loan_type in updated_loan_types: if loan.status == 'Fully Disbursed': status = 'Disbursed' elif loan.status == 'Repaid/Closed': status = 'Closed' else: status = loan.status frappe.db.set_value('Loan', loan.name, { 'is_term_loan': 1, 'penalty_income_account': penalty_account, 'status': status }) process_loan_interest_accrual_for_term_loans(posting_date=nowdate(), loan_type=loan_type, loan=loan.name) if frappe.db.has_column('Repayment Schedule', 'paid'): total_principal, total_interest = frappe.db.get_value('Repayment Schedule', {'paid': 1, 'parent': loan.name}, ['sum(principal_amount) as total_principal', 'sum(interest_amount) as total_interest']) accrued_entries = get_accrued_interest_entries(loan.name) for entry in accrued_entries: interest_paid = 0 principal_paid = 0 if flt(total_interest) > flt(entry.interest_amount): interest_paid = flt(entry.interest_amount) else: interest_paid = flt(total_interest) if flt(total_principal) > flt(entry.payable_principal_amount): principal_paid = flt(entry.payable_principal_amount) else: principal_paid = flt(total_principal) frappe.db.sql(""" UPDATE `tabLoan Interest Accrual` SET paid_principal_amount = `paid_principal_amount` + %s, paid_interest_amount = `paid_interest_amount` + %s WHERE name = %s""", (principal_paid, interest_paid, entry.name)) total_principal = flt(total_principal) - principal_paid total_interest = flt(total_interest) - interest_paid
def execute(): frappe.reload_doc('accounts', 'doctype', 'sales_invoice') frappe.db.sql( """update `tabSales Invoice` set from_date = invoice_period_from_date, to_date = invoice_period_to_date, is_recurring = convert_into_recurring_invoice""" )
def execute(): frappe.reload_doc('assets', 'doctype', 'asset_finance_book') frappe.reload_doc('assets', 'doctype', 'depreciation_schedule') frappe.reload_doc('assets', 'doctype', 'asset_category') frappe.reload_doc('assets', 'doctype', 'asset') frappe.reload_doc('assets', 'doctype', 'asset_movement') frappe.reload_doc('assets', 'doctype', 'asset_category_account') if frappe.db.has_column("Asset", "warehouse"): frappe.db.sql(""" update `tabAsset` ast, `tabWarehouse` wh set ast.location = wh.warehouse_name where ast.warehouse = wh.name""") for d in frappe.get_all('Asset'): doc = frappe.get_doc('Asset', d.name) if doc.calculate_depreciation: fb = doc.append('finance_books', { 'depreciation_method': doc.depreciation_method, 'total_number_of_depreciations': doc.total_number_of_depreciations, 'frequency_of_depreciation': doc.frequency_of_depreciation, 'depreciation_start_date': doc.next_depreciation_date, 'expected_value_after_useful_life': doc.expected_value_after_useful_life, 'value_after_depreciation': doc.value_after_depreciation }) fb.db_update() frappe.db.sql(""" update `tabDepreciation Schedule` ds, `tabAsset` ast set ds.depreciation_method = ast.depreciation_method, ds.finance_book_id = 1 where ds.parent = ast.name """) for category in frappe.get_all('Asset Category'): asset_category_doc = frappe.get_doc("Asset Category", category) row = asset_category_doc.append('finance_books', { 'depreciation_method': asset_category_doc.depreciation_method, 'total_number_of_depreciations': asset_category_doc.total_number_of_depreciations, 'frequency_of_depreciation': asset_category_doc.frequency_of_depreciation }) row.db_update()
def execute(): contact_details = frappe.db.sql(""" SELECT `name`, `email_id`, `phone`, `mobile_no`, `modified_by`, `creation`, `modified` FROM `tabContact` """, as_dict=True) frappe.reload_doc("contacts", "doctype", "contact_email") frappe.reload_doc("contacts", "doctype", "contact_phone") frappe.reload_doc("contacts", "doctype", "contact") email_values = [] phone_values = [] for count, contact_detail in enumerate(contact_details): phone_counter = 1 is_primary = 1 if contact_detail.email_id: email_values.append( (1, frappe.generate_hash(contact_detail.email_id, 10), contact_detail.email_id, 'email_ids', 'Contact', contact_detail.name, 1, contact_detail.creation, contact_detail.modified, contact_detail.modified_by)) if contact_detail.phone: is_primary_phone = 1 if phone_counter == 1 else 0 phone_values.append( (phone_counter, frappe.generate_hash(contact_detail.email_id, 10), contact_detail.phone, 'phone_nos', 'Contact', contact_detail.name, is_primary_phone, 0, contact_detail.creation, contact_detail.modified, contact_detail.modified_by)) phone_counter += 1 is_primary += 1 if contact_detail.mobile_no: is_primary_mobile_no = 1 if phone_counter == 1 else 0 phone_values.append( (phone_counter, frappe.generate_hash(contact_detail.email_id, 10), contact_detail.mobile_no, 'phone_nos', 'Contact', contact_detail.name, 0, is_primary_mobile_no, contact_detail.creation, contact_detail.modified, contact_detail.modified_by)) if email_values and (count % 10000 == 0 or count == len(contact_details) - 1): frappe.db.sql( """ INSERT INTO `tabContact Email` (`idx`, `name`, `email_id`, `parentfield`, `parenttype`, `parent`, `is_primary`, `creation`, `modified`, `modified_by`) VALUES {} """.format(", ".join(['%s'] * len(email_values))), tuple(email_values)) email_values = [] if phone_values and (count % 10000 == 0 or count == len(contact_details) - 1): frappe.db.sql( """ INSERT INTO `tabContact Phone` (`idx`, `name`, `phone`, `parentfield`, `parenttype`, `parent`, `is_primary_phone`, `is_primary_mobile_no`, `creation`, `modified`, `modified_by`) VALUES {} """.format(", ".join(['%s'] * len(phone_values))), tuple(phone_values)) phone_values = [] frappe.db.add_index("Contact Phone", ["phone"]) frappe.db.add_index("Contact Email", ["email_id"])
def add_print_formats(): frappe.reload_doc("regional", "print_format", "gst_tax_invoice")
def execute(): frappe.reload_doc('selling', 'doctype', 'quotation') frappe.reload_doc('selling', 'doctype', 'quotation_item') frappe.reload_doc('selling', 'doctype', 'sales_order') frappe.reload_doc('selling', 'doctype', 'sales_order_item') frappe.reload_doc('stock', 'doctype', 'delivery_note') frappe.reload_doc('stock', 'doctype', 'delivery_note_item') frappe.reload_doc('accounts', 'doctype', 'sales_invoice') frappe.reload_doc('accounts', 'doctype', 'sales_invoice_item') frappe.reload_doc('buying', 'doctype', 'supplier_quotation') frappe.reload_doc('buying', 'doctype', 'supplier_quotation_item') frappe.reload_doc('buying', 'doctype', 'purchase_order') frappe.reload_doc('buying', 'doctype', 'purchase_order_item') frappe.reload_doc('stock', 'doctype', 'purchase_receipt') frappe.reload_doc('stock', 'doctype', 'purchase_receipt_item') frappe.reload_doc('accounts', 'doctype', 'purchase_invoice') frappe.reload_doc('accounts', 'doctype', 'purchase_invoice_item') frappe.reload_doc('accounts', 'doctype', 'sales_taxes_and_charges') frappe.reload_doc('accounts', 'doctype', 'purchase_taxes_and_charges') doctypes = [ 'Sales Order', 'Delivery Note', 'Sales Invoice', 'Purchase Order', 'Purchase Receipt', 'Purchase Invoice', 'Quotation', 'Supplier Quotation' ] new_transaction_fields = [ 'total_before_discount', 'tax_exclusive_total_before_discount', 'total_discount', 'tax_exclusive_total_discount', 'taxable_total', 'net_total', 'total_after_taxes', 'total_discount_after_taxes', ] new_transaction_fields += ['base_' + f for f in new_transaction_fields] new_transaction_fields = set(new_transaction_fields) new_item_fields = [ 'tax_exclusive_price_list_rate', 'tax_exclusive_rate', 'tax_exclusive_amount', 'tax_exclusive_discount_amount', 'tax_exclusive_rate_with_margin', 'amount_before_discount', 'tax_exclusive_amount_before_discount', 'total_discount', 'tax_exclusive_total_discount', 'taxable_rate', 'taxable_amount', 'net_rate', 'net_amount', 'item_taxes_and_charges', 'tax_inclusive_amount', 'tax_inclusive_rate', ] new_item_fields += ['base_' + f for f in new_item_fields] new_item_fields = set(new_item_fields) # Calculate and update database for dt in doctypes: docnames = frappe.get_all(dt) for dn in docnames: dn = dn.name doc = frappe.get_doc(dt, dn) calculate_taxes_and_totals(doc) values_to_update = [doc.get(f) for f in new_transaction_fields] update_dict = dict(zip(new_transaction_fields, values_to_update)) frappe.db.set_value(dt, doc.name, update_dict, None, update_modified=False) for item in doc.items: item_fields = set([f.fieldname for f in item.meta.fields]) fields_to_update = list( new_item_fields.intersection(item_fields)) values_to_update = [item.get(f) for f in fields_to_update] update_dict = dict(zip(fields_to_update, values_to_update)) frappe.db.set_value(dt + " Item", item.name, update_dict, None, update_modified=False) for tax in doc.taxes: frappe.db.set_value(tax.doctype, tax.name, "displayed_total", tax.displayed_total, update_modified=False)
def execute(): frappe.reload_doc("Healthcare", "doctype", "Inpatient Record") if frappe.db.has_column("Inpatient Record", "discharge_date"): rename_field("Inpatient Record", "discharge_date", "discharge_datetime")
def execute(): # Update the title of all BOM. frappe.reload_doc('manufacturing', 'doctype', 'bom') frappe.db.sql("""UPDATE `tabBOM` set title=item_name""")
def sync_jobs(hooks: Dict = None): frappe.reload_doc("core", "doctype", "scheduled_job_type") scheduler_events = hooks or frappe.get_hooks("scheduler_events") all_events = insert_events(scheduler_events) clear_events(all_events)
def execute(): frappe.reload_doc('printing', 'doctype', 'print_style') frappe.reload_doc('printing', 'doctype', 'print_settings') create_print_zero_amount_taxes_custom_field()
def before_install(): frappe.reload_doc("core", "doctype", "docfield") frappe.reload_doc("core", "doctype", "docperm") frappe.reload_doc("core", "doctype", "doctype")
def execute(): company = frappe.get_all('Company', filters={'country': 'India'}) if not company: return frappe.reload_doc("custom", "doctype", "custom_field") frappe.reload_doc("regional", "doctype", "e_invoice_settings") custom_fields = { 'Sales Invoice': [ dict( fieldname='irn', label='IRN', fieldtype='Data', read_only=1, insert_after='customer', no_copy=1, print_hide=1, depends_on= 'eval:in_list(["Registered Regular", "SEZ", "Overseas", "Deemed Export"], doc.gst_category) && doc.irn_cancelled === 0' ), dict(fieldname='ack_no', label='Ack. No.', fieldtype='Data', read_only=1, hidden=1, insert_after='irn', no_copy=1, print_hide=1), dict(fieldname='ack_date', label='Ack. Date', fieldtype='Data', read_only=1, hidden=1, insert_after='ack_no', no_copy=1, print_hide=1), dict(fieldname='irn_cancelled', label='IRN Cancelled', fieldtype='Check', no_copy=1, print_hide=1, depends_on='eval:(doc.irn_cancelled === 1)', read_only=1, allow_on_submit=1, insert_after='customer'), dict(fieldname='eway_bill_cancelled', label='E-Way Bill Cancelled', fieldtype='Check', no_copy=1, print_hide=1, depends_on='eval:(doc.eway_bill_cancelled === 1)', read_only=1, allow_on_submit=1, insert_after='customer'), dict(fieldname='signed_einvoice', fieldtype='Code', options='JSON', hidden=1, no_copy=1, print_hide=1, read_only=1), dict(fieldname='signed_qr_code', fieldtype='Code', options='JSON', hidden=1, no_copy=1, print_hide=1, read_only=1), dict(fieldname='qrcode_image', label='QRCode', fieldtype='Attach Image', hidden=1, no_copy=1, print_hide=1, read_only=1) ] } create_custom_fields(custom_fields, update=True) add_permissions() add_print_formats() einvoice_cond = 'in_list(["Registered Regular", "SEZ", "Overseas", "Deemed Export"], doc.gst_category)' t = { 'mode_of_transport': [{ 'default': None }], 'distance': [{ 'mandatory_depends_on': f'eval:{einvoice_cond} && doc.transporter' }], 'gst_vehicle_type': [{ 'mandatory_depends_on': f'eval:{einvoice_cond} && doc.mode_of_transport == "Road"' }], 'lr_date': [{ 'mandatory_depends_on': f'eval:{einvoice_cond} && in_list(["Air", "Ship", "Rail"], doc.mode_of_transport)' }], 'lr_no': [{ 'mandatory_depends_on': f'eval:{einvoice_cond} && in_list(["Air", "Ship", "Rail"], doc.mode_of_transport)' }], 'vehicle_no': [{ 'mandatory_depends_on': f'eval:{einvoice_cond} && doc.mode_of_transport == "Road"' }], 'ewaybill': [{ 'read_only_depends_on': 'eval:doc.irn && doc.ewaybill' }, { 'depends_on': 'eval:((doc.docstatus === 1 || doc.ewaybill) && doc.eway_bill_cancelled === 0)' }] } for field, conditions in t.items(): for c in conditions: [(prop, value)] = c.items() frappe.db.set_value('Custom Field', {'fieldname': field}, prop, value)
def add_print_formats(): frappe.reload_doc("regional", "print_format", "gst_tax_invoice") frappe.reload_doc("accounts", "print_format", "gst_pos_invoice") frappe.db.sql(""" update `tabPrint Format` set disabled = 0 where name in('GST POS Invoice', 'GST Tax Invoice') """)
def execute(): frappe.reload_doc("buying", "doctype", "supplier_quotation") frappe.db.sql("""UPDATE `tabSupplier Quotation` SET valid_till = DATE_ADD(transaction_date , INTERVAL 1 MONTH) WHERE docstatus < 2""")
def add_print_formats(): frappe.reload_doc("regional", "print_format", "irs_1099_form") frappe.db.sql(""" update `tabPrint Format` set disabled = 0 where name in('IRS 1099 Form') """)
def execute(): if frappe.db.exists('DocType', 'Issue'): frappe.reload_doc("support", "doctype", "issue") rename_status()
def execute(): if not frappe.db.has_column('Work Order', 'has_batch_no'): return frappe.reload_doc('manufacturing', 'doctype', 'manufacturing_settings') if cint( frappe.db.get_single_value( 'Manufacturing Settings', 'make_serial_no_batch_from_work_order')): return frappe.reload_doc('manufacturing', 'doctype', 'work_order') filters = { 'docstatus': 1, 'produced_qty': ('>', 0), 'creation': ('>=', '2021-06-29 00:00:00'), 'has_batch_no': 1 } fields = ['name', 'production_item'] work_orders = [ d.name for d in frappe.get_all('Work Order', filters=filters, fields=fields) ] if not work_orders: return repost_stock_entries = [] stock_entries = frappe.db.sql_list( ''' SELECT se.name FROM `tabStock Entry` se WHERE se.purpose = 'Manufacture' and se.docstatus < 2 and se.work_order in %s and not exists( select name from `tabStock Entry Detail` sed where sed.parent = se.name and sed.is_finished_item = 1 ) ORDER BY se.posting_date, se.posting_time ''', (work_orders, )) if stock_entries: print('Length of stock entries', len(stock_entries)) for stock_entry in stock_entries: doc = frappe.get_doc('Stock Entry', stock_entry) doc.set_work_order_details() doc.load_items_from_bom() doc.calculate_rate_and_amount() set_expense_account(doc) doc.make_batches('t_warehouse') if doc.docstatus == 0: doc.save() else: repost_stock_entry(doc) repost_stock_entries.append(doc) for repost_doc in repost_stock_entries: repost_future_sle_and_gle(repost_doc)
def execute(): frappe.reload_doc('stock', 'doctype', 'delivery_note_item', force=True) frappe.reload_doc('stock', 'doctype', 'purchase_receipt_item', force=True) def map_rows(doc_row, return_doc_row, detail_field, doctype): """Map rows after identifying similar ones.""" frappe.db.sql(""" UPDATE `tab{doctype} Item` set {detail_field} = '{doc_row_name}' where name = '{return_doc_row_name}'""" \ .format(doctype=doctype, detail_field=detail_field, doc_row_name=doc_row.get('name'), return_doc_row_name=return_doc_row.get('name'))) #nosec def row_is_mappable(doc_row, return_doc_row, detail_field): """Checks if two rows are similar enough to be mapped.""" if doc_row.item_code == return_doc_row.item_code and not return_doc_row.get( detail_field): if doc_row.get('batch_no') and return_doc_row.get( 'batch_no' ) and doc_row.batch_no == return_doc_row.batch_no: return True elif doc_row.get('serial_no') and return_doc_row.get('serial_no'): doc_sn = doc_row.serial_no.split('\n') return_doc_sn = return_doc_row.serial_no.split('\n') if set(doc_sn) & set(return_doc_sn): # if two rows have serial nos in common, map them return True elif doc_row.rate == return_doc_row.rate: return True else: return False def make_return_document_map(doctype, return_document_map): """Returns a map of documents and it's return documents. Format => { 'document' : ['return_document_1','return_document_2'] }""" return_against_documents = frappe.db.sql(""" SELECT return_against as document, name as return_document FROM `tab{doctype}` WHERE is_return = 1 and docstatus = 1""".format(doctype=doctype), as_dict=1) #nosec for entry in return_against_documents: return_document_map[entry.document].append(entry.return_document) return return_document_map def set_document_detail_in_return_document(doctype): """Map each row of the original document in the return document.""" mapped = [] return_document_map = defaultdict(list) detail_field = "purchase_receipt_item" if doctype == "Purchase Receipt" else "dn_detail" child_doc = frappe.scrub("{0} Item".format(doctype)) frappe.reload_doc("stock", "doctype", child_doc) return_document_map = make_return_document_map(doctype, return_document_map) count = 0 #iterate through original documents and its return documents for docname in return_document_map: doc_items = frappe.get_cached_doc(doctype, docname).get("items") for return_doc in return_document_map[docname]: return_doc_items = frappe.get_cached_doc( doctype, return_doc).get("items") #iterate through return document items and original document items for mapping for return_item in return_doc_items: for doc_item in doc_items: if row_is_mappable(doc_item, return_item, detail_field) and doc_item.get( 'name') not in mapped: map_rows(doc_item, return_item, detail_field, doctype) mapped.append(doc_item.get('name')) break else: continue # commit after every 100 sql updates count += 1 if count % 100 == 0: frappe.db.commit() set_document_detail_in_return_document("Purchase Receipt") set_document_detail_in_return_document("Delivery Note") frappe.db.commit()
def execute(): frappe.reload_doc("accounts", "doctype", frappe.scrub("Cash Flow Mapping")) frappe.reload_doc("accounts", "doctype", frappe.scrub("Cash Flow Mapper")) frappe.reload_doc("accounts", "doctype", frappe.scrub("Cash Flow Mapping Template Details")) create_default_cash_flow_mapper_templates()
def add_print_formats(): frappe.reload_doc("regional", "print_format", "detailed_tax_invoice") frappe.reload_doc("regional", "print_format", "simplified_tax_invoice") frappe.db.sql(""" update `tabPrint Format` set disabled = 0 where name in('Simplified Tax Invoice', 'Detailed Tax Invoice') """)
def execute(): frappe.reload_doc('crm', 'doctype', 'lead') frappe.reload_doc('crm', 'doctype', 'opportunity') add_crm_to_user_desktop_items()
def execute(): for dt in ["Quotation", "Sales Order", "Delivery Note", "Sales Invoice"]: frappe.reload_doc(get_doctype_module(dt), "doctype", scrub(dt)) frappe.db.sql( """update `tab{0}` set base_discount_amount=discount_amount, discount_amount=discount_amount/conversion_rate""".format(dt))
def execute(): if frappe.db.exists('DocType', 'Issue'): issues = frappe.db.get_all('Issue', fields=[ 'name', 'response_by_variance', 'resolution_by_variance', 'mins_to_first_response' ], order_by='creation desc') frappe.reload_doc('support', 'doctype', 'issue') # rename fields rename_map = { 'agreement_fulfilled': 'agreement_status', 'mins_to_first_response': 'first_response_time' } for old, new in rename_map.items(): rename_field('Issue', old, new) # change fieldtype to duration count = 0 for entry in issues: response_by_variance = convert_to_seconds( entry.response_by_variance, 'Hours') resolution_by_variance = convert_to_seconds( entry.resolution_by_variance, 'Hours') mins_to_first_response = convert_to_seconds( entry.mins_to_first_response, 'Minutes') frappe.db.set_value( 'Issue', entry.name, { 'response_by_variance': response_by_variance, 'resolution_by_variance': resolution_by_variance, 'first_response_time': mins_to_first_response }) # commit after every 100 updates count += 1 if count % 100 == 0: frappe.db.commit() if frappe.db.exists('DocType', 'Opportunity'): opportunities = frappe.db.get_all( 'Opportunity', fields=['name', 'mins_to_first_response'], order_by='creation desc') frappe.reload_doc('crm', 'doctype', 'opportunity') rename_field('Opportunity', 'mins_to_first_response', 'first_response_time') # change fieldtype to duration count = 0 for entry in opportunities: mins_to_first_response = convert_to_seconds( entry.mins_to_first_response, 'Minutes') frappe.db.set_value('Opportunity', entry.name, 'first_response_time', mins_to_first_response) # commit after every 100 updates count += 1 if count % 100 == 0: frappe.db.commit() # renamed reports from "Minutes to First Response for Issues" to "First Response Time for Issues". Same for Opportunity for report in [ 'Minutes to First Response for Issues', 'Minutes to First Response for Opportunity' ]: if frappe.db.exists('Report', report): frappe.delete_doc('Report', report)
def execute(): frappe.reload_doc("assets", "doctype", "Location") for dt in ("Account", "Cost Center", "File", "Employee", "Location", "Task", "Customer Group", "Sales Person", "Territory"): frappe.reload_doctype(dt) frappe.get_doc("DocType", dt).run_module_method("on_doctype_update")
def add_print_formats(): frappe.reload_doc("regional", "print_format", "irs_1099_form") frappe.db.set_value("Print Format", "IRS 1099 Form", "disabled", 0)
def execute(): for dn in field_rename_map: if frappe.db.exists('DocType', dn): if dn == 'Healthcare Settings': frappe.reload_doctype('Healthcare Settings') else: frappe.reload_doc(get_doctype_module(dn), "doctype", scrub(dn)) for dt, field_list in field_rename_map.items(): if frappe.db.exists('DocType', dt): for field in field_list: if dt == 'Healthcare Settings': rename_field(dt, field[0], field[1]) elif frappe.db.has_column(dt, field[0]): rename_field(dt, field[0], field[1]) # first name mandatory in Patient if frappe.db.exists('DocType', 'Patient'): patients = frappe.db.sql("select name, patient_name from `tabPatient`", as_dict=1) frappe.reload_doc('healthcare', 'doctype', 'patient') for entry in patients: name = entry.patient_name.split(' ') frappe.db.set_value('Patient', entry.name, 'first_name', name[0]) # mark Healthcare Practitioner status as Disabled if frappe.db.exists('DocType', 'Healthcare Practitioner'): practitioners = frappe.db.sql( "select name from `tabHealthcare Practitioner` where 'active'= 0", as_dict=1) practitioners_lst = [p.name for p in practitioners] frappe.reload_doc('healthcare', 'doctype', 'healthcare_practitioner') if practitioners_lst: frappe.db.sql( "update `tabHealthcare Practitioner` set status = 'Disabled' where name IN %(practitioners)s" "", {"practitioners": practitioners_lst}) # set Clinical Procedure status if frappe.db.exists('DocType', 'Clinical Procedure'): frappe.reload_doc('healthcare', 'doctype', 'clinical_procedure') frappe.db.sql(""" UPDATE `tabClinical Procedure` SET docstatus = (CASE WHEN status = 'Cancelled' THEN 2 WHEN status = 'Draft' THEN 0 ELSE 1 END) """) # set complaints and diagnosis in table multiselect in Patient Encounter if frappe.db.exists('DocType', 'Patient Encounter'): field_list = [['visit_department', 'medical_department'], ['type', 'appointment_type']] encounter_details = frappe.db.sql( """select symptoms, diagnosis, name from `tabPatient Encounter`""", as_dict=True) frappe.reload_doc('healthcare', 'doctype', 'patient_encounter') frappe.reload_doc('healthcare', 'doctype', 'patient_encounter_symptom') frappe.reload_doc('healthcare', 'doctype', 'patient_encounter_diagnosis') for field in field_list: if frappe.db.has_column(dt, field[0]): rename_field(dt, field[0], field[1]) for entry in encounter_details: doc = frappe.get_doc('Patient Encounter', entry.name) symptoms = entry.symptoms.split('\n') if entry.symptoms else [] for symptom in symptoms: if not frappe.db.exists('Complaint', symptom): frappe.get_doc({ 'doctype': 'Complaint', 'complaints': symptom }).insert() row = doc.append('symptoms', {'complaint': symptom}) row.db_update() diagnosis = entry.diagnosis.split('\n') if entry.diagnosis else [] for d in diagnosis: if not frappe.db.exists('Diagnosis', d): frappe.get_doc({ 'doctype': 'Diagnosis', 'diagnosis': d }).insert() row = doc.append('diagnosis', {'diagnosis': d}) row.db_update() doc.db_update() if frappe.db.exists('DocType', 'Fee Validity'): # update fee validity status frappe.db.sql(""" UPDATE `tabFee Validity` SET status = (CASE WHEN visited >= max_visits THEN 'Completed' ELSE 'Pending' END) """)
def execute(): company = frappe.get_all('Company', filters={'country': 'India'}, fields=['name']) if not company: return frappe.reload_doc("regional", "doctype", "gst_settings") frappe.reload_doc("accounts", "doctype", "gst_account") journal_entry_types = frappe.get_meta("Journal Entry").get_options( "voucher_type").split("\n") + ['Reversal Of ITC'] make_property_setter('Journal Entry', 'voucher_type', 'options', '\n'.join(journal_entry_types), '') custom_fields = { 'Journal Entry': [ dict( fieldname='reversal_type', label='Reversal Type', fieldtype='Select', insert_after='voucher_type', print_hide=1, options="As per rules 42 & 43 of CGST Rules\nOthers", depends_on="eval:doc.voucher_type=='Reversal Of ITC'", mandatory_depends_on="eval:doc.voucher_type=='Reversal Of ITC'" ), dict( fieldname='company_address', label='Company Address', fieldtype='Link', options='Address', insert_after='reversal_type', print_hide=1, depends_on="eval:doc.voucher_type=='Reversal Of ITC'", mandatory_depends_on="eval:doc.voucher_type=='Reversal Of ITC'" ), dict( fieldname='company_gstin', label='Company GSTIN', fieldtype='Data', read_only=1, insert_after='company_address', print_hide=1, fetch_from='company_address.gstin', depends_on="eval:doc.voucher_type=='Reversal Of ITC'", mandatory_depends_on="eval:doc.voucher_type=='Reversal Of ITC'" ) ], 'Purchase Invoice': [ dict( fieldname='eligibility_for_itc', label='Eligibility For ITC', fieldtype='Select', insert_after='reason_for_issuing_document', print_hide=1, options= 'Input Service Distributor\nImport Of Service\nImport Of Capital Goods\nITC on Reverse Charge\nIneligible As Per Section 17(5)\nIneligible Others\nAll Other ITC', default="All Other ITC") ], 'Purchase Invoice Item': [ dict(fieldname='taxable_value', label='Taxable Value', fieldtype='Currency', insert_after='base_net_amount', hidden=1, options="Company:company:default_currency", print_hide=1) ] } create_custom_fields(custom_fields, update=True) # Patch ITC Availed fields from Data to Currency # Patch Availed ITC for current fiscal_year gst_accounts = get_gst_accounts(only_non_reverse_charge=1) frappe.db.sql(""" UPDATE `tabCustom Field` SET fieldtype='Currency', options='Company:company:default_currency' WHERE dt = 'Purchase Invoice' and fieldname in ('itc_integrated_tax', 'itc_state_tax', 'itc_central_tax', 'itc_cess_amount') """) frappe.db.sql("""UPDATE `tabPurchase Invoice` set itc_integrated_tax = '0' WHERE trim(coalesce(itc_integrated_tax, '')) = '' """) frappe.db.sql("""UPDATE `tabPurchase Invoice` set itc_state_tax = '0' WHERE trim(coalesce(itc_state_tax, '')) = '' """) frappe.db.sql("""UPDATE `tabPurchase Invoice` set itc_central_tax = '0' WHERE trim(coalesce(itc_central_tax, '')) = '' """) frappe.db.sql("""UPDATE `tabPurchase Invoice` set itc_cess_amount = '0' WHERE trim(coalesce(itc_cess_amount, '')) = '' """) # Get purchase invoices invoices = frappe.get_all( 'Purchase Invoice', { 'posting_date': ('>=', '2021-04-01'), 'eligibility_for_itc': ('!=', 'Ineligible') }, ['name']) amount_map = {} if invoices: invoice_list = set([d.name for d in invoices]) # Get GST applied amounts = frappe.db.sql(""" SELECT parent, account_head, sum(base_tax_amount_after_discount_amount) as amount FROM `tabPurchase Taxes and Charges` where parent in %s GROUP BY parent, account_head """, (invoice_list), as_dict=1) for d in amounts: amount_map.setdefault( d.parent, { 'itc_integrated_tax': 0, 'itc_state_tax': 0, 'itc_central_tax': 0, 'itc_cess_amount': 0 }) if d.account_head in gst_accounts.get('igst_account'): amount_map[d.parent]['itc_integrated_tax'] += d.amount if d.account_head in gst_accounts.get('cgst_account'): amount_map[d.parent]['itc_central_tax'] += d.amount if d.account_head in gst_accounts.get('sgst_account'): amount_map[d.parent]['itc_state_tax'] += d.amount if d.account_head in gst_accounts.get('cess_account'): amount_map[d.parent]['itc_cess_amount'] += d.amount for invoice, values in amount_map.items(): frappe.db.set_value( 'Purchase Invoice', invoice, { 'itc_integrated_tax': values.get('itc_integrated_tax'), 'itc_central_tax': values.get('itc_central_tax'), 'itc_state_tax': values['itc_state_tax'], 'itc_cess_amount': values['itc_cess_amount'], })
def execute(): frappe.reload_doc("core", "doctype", "success_action") create_default_success_action()