def execute():
dataent.reload_doc("hr", "doctype", "department_approver")
dataent.reload_doc("hr", "doctype", "employee")
dataent.reload_doc("hr", "doctype", "department")
if dataent.db.has_column('Department', 'leave_approver'):
rename_field('Department', "leave_approver", "leave_approvers")
if dataent.db.has_column('Department', 'expense_approver'):
rename_field('Department', "expense_approver", "expense_approvers")
if not dataent.db.table_exists("Employee Leave Approver"):
return
approvers = dataent.db.sql(
"""select distinct app.leave_approver, emp.department from
`tabEmployee Leave Approver` app, `tabEmployee` emp
where app.parenttype = 'Employee'
and emp.name = app.parent
""",
as_dict=True)
for record in approvers:
if record.department:
department = dataent.get_doc("Department", record.department)
if not department:
return
if not len(department.leave_approvers):
department.append("leave_approvers", {
"approver": record.leave_approver
}).db_insert()
def execute():
#Rename Grading Structure to Grading Scale
if not dataent.db.exists("DocType", "Grading Scale"):
dataent.rename_doc("DocType",
"Grading Structure",
"Grading Scale",
force=True)
if not dataent.db.exists("DocType", "Grading Scale Interval"):
dataent.rename_doc("DocType",
"Grade Interval",
"Grading Scale Interval",
force=True)
# dataent.reload_doc("schools", "doctype", "grading_scale_interval")
dataent.reload_doc("education", "doctype", "grading_scale_interval")
if "to_score" in dataent.db.get_table_columns("Grading Scale Interval"):
rename_field("Grading Scale Interval", "to_score", "threshold")
if not dataent.db.exists("DocType", "Assessment Plan"):
dataent.rename_doc("DocType",
"Assessment",
"Assessment Plan",
force=True)
# 'Schools' module changed to the 'Education'
# dataent.reload_doc("schools", "doctype", "assessment_plan")
#Rename Assessment Results
dataent.reload_doc("education", "doctype", "assessment_plan")
if "grading_structure" in dataent.db.get_table_columns("Assessment Plan"):
rename_field("Assessment Plan", "grading_structure", "grading_scale")
# dataent.reload_doc("schools", "doctype", "assessment_result")
# dataent.reload_doc("schools", "doctype", "assessment_result_detail")
# dataent.reload_doc("schools", "doctype", "assessment_criteria")
dataent.reload_doc("education", "doctype", "assessment_result")
dataent.reload_doc("education", "doctype", "assessment_result_detail")
dataent.reload_doc("education", "doctype", "assessment_criteria")
for assessment in dataent.get_all("Assessment Plan",
fields=["name", "grading_scale"],
filters=[["docstatus", "!=", 2]]):
for stud_result in dataent.db.sql(
"select * from `tabAssessment Result` where parent= %s",
assessment.name,
as_dict=True):
if stud_result.result:
assessment_result = dataent.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()
dataent.db.sql(
"""delete from `tabAssessment Result` where parent != '' or parent is not null"""
)
def execute():
for dt in doc_rename_map:
if dataent.db.exists('DocType', dt):
rename_doc('DocType', dt, doc_rename_map[dt], force=True)
for dn in field_rename_map:
if dataent.db.exists('DocType', dn):
dataent.reload_doc(get_doctype_module(dn), "doctype", scrub(dn))
for dt, field_list in field_rename_map.items():
if dataent.db.exists('DocType', dt):
for field in field_list:
if dataent.db.has_column(dt, field[0]):
rename_field(dt, field[0], field[1])
if dataent.db.exists('DocType', 'Practitioner Service Unit Schedule'):
if dataent.db.has_column('Practitioner Service Unit Schedule',
'parentfield'):
dataent.db.sql("""
update `tabPractitioner Service Unit Schedule` set parentfield = 'practitioner_schedules'
where parentfield = 'physician_schedules' and parenttype = 'Healthcare Practitioner'
""")
if dataent.db.exists("DocType", "Healthcare Practitioner"):
dataent.reload_doc("healthcare", "doctype", "healthcare_practitioner")
dataent.reload_doc("healthcare", "doctype",
"practitioner_service_unit_schedule")
if dataent.db.has_column('Healthcare Practitioner',
'physician_schedule'):
for doc in dataent.get_all('Healthcare Practitioner'):
_doc = dataent.get_doc('Healthcare Practitioner', doc.name)
if _doc.physician_schedule:
_doc.append('practitioner_schedules',
{'schedule': _doc.physician_schedule})
_doc.save()
def execute():
doctype = 'Timesheet'
fields_dict = {'total_billing_amount': 'total_billable_amount', 'total_billing_hours': 'total_billable_hours'}
for old_fieldname, new_fieldname in fields_dict.items():
if old_fieldname in dataent.db.get_table_columns(doctype):
rename_field(doctype, old_fieldname, new_fieldname)
def execute():
# delete custom field if exists
for doctype, fieldname in (('Issue', 'issue_type'), ('Opportunity', 'opportunity_type')):
custom_field = dataent.db.get_value("Custom Field", {"fieldname": fieldname, 'dt': doctype})
if custom_field:
dataent.delete_doc("Custom Field", custom_field, ignore_permissions=True)
dataent.reload_doc('support', 'doctype', 'issue_type')
dataent.reload_doc('support', 'doctype', 'issue')
dataent.reload_doc('crm', 'doctype', 'opportunity_type')
dataent.reload_doc('crm', 'doctype', 'opportunity')
# rename enquiry_type -> opportunity_type
from dataent.model.utils.rename_field import rename_field
rename_field('Opportunity', 'enquiry_type', 'opportunity_type')
# create values if already set
for opts in (('Issue', 'issue_type', 'Issue Type'),
('Opportunity', 'opportunity_type', 'Opportunity Type')):
for d in dataent.db.sql('select distinct {0} from `tab{1}`'.format(opts[1], opts[0])):
if d[0] and not dataent.db.exists(opts[2], d[0]):
dataent.get_doc(dict(doctype = opts[2], name=d[0])).insert()
# fixtures
for name in ('Hub', _('Sales'), _('Support'), _('Maintenance')):
if not dataent.db.exists('Opportunity Type', name):
dataent.get_doc(dict(doctype = 'Opportunity Type', name=name)).insert()
def execute():
dataent.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:
dataent.reload_doc(module, 'doctype', dataent.scrub(doctype))
if dataent.db.has_column(doctype, 'subscription'):
rename_field(doctype, 'subscription', 'auto_repeat')
subscriptions = dataent.db.sql('select * from `tabSubscription`', as_dict=1)
for doc in subscriptions:
doc['doctype'] = 'Auto Repeat'
auto_repeat = dataent.get_doc(doc)
auto_repeat.db_insert()
dataent.db.sql('delete from `tabSubscription`')
dataent.db.commit()
drop_columns_from_subscription()
def execute():
for doctype in ['BOM Explosion Item', 'BOM Item', 'Work Order Item', 'Item']:
if dataent.db.has_column(doctype, 'allow_transfer_for_manufacture'):
if doctype != 'Item':
dataent.reload_doc('manufacturing', 'doctype', dataent.scrub(doctype))
else:
dataent.reload_doc('stock', 'doctype', dataent.scrub(doctype))
rename_field(doctype, "allow_transfer_for_manufacture", "include_item_in_manufacturing")
if dataent.db.has_column('BOM', 'allow_same_item_multiple_times'):
dataent.db.sql(""" UPDATE tabBOM
SET
allow_same_item_multiple_times = 0
WHERE
trim(coalesce(allow_same_item_multiple_times, '')) = '' """)
for doctype in ['BOM', 'Work Order']:
dataent.reload_doc('manufacturing', 'doctype', dataent.scrub(doctype))
if dataent.db.has_column(doctype, 'transfer_material_against_job_card'):
dataent.db.sql(""" UPDATE `tab%s`
SET transfer_material_against = CASE WHEN
transfer_material_against_job_card = 1 then 'Job Card' Else 'Work Order' END
WHERE docstatus < 2""" % (doctype))
else:
dataent.db.sql(""" UPDATE `tab%s`
SET transfer_material_against = 'Work Order'
WHERE docstatus < 2""" % (doctype))
def execute():
dataent.reload_doc("custom", "doctype", "customize_form")
dataent.reload_doc("email", "doctype", "notification")
dataent.reload_doc("desk", "doctype", "event")
dataent.reload_doc("workflow", "doctype", "workflow")
for dt, field_list in rename_map.items():
for field in field_list:
rename_field(dt, field[0], field[1])
def execute(): doc_list = ["Purchase Invoice Item", "Stock Entry Detail", "Delivery Note Item", "Purchase Receipt Item", "Sales Invoice Item"] for doctype in doc_list: dataent.reload_doctype(doctype) if "is_sample_item" in dataent.db.get_table_columns(doctype): rename_field(doctype, "is_sample_item", "allow_zero_valuation_rate")
def execute():
tables = dataent.db.sql_list("show tables")
if "tabUser" not in tables:
dataent.rename_doc("DocType", "Profile", "User", force=True)
dataent.reload_doc("website", "doctype", "blogger")
if "profile" in get_table_columns("Blogger"):
rename_field("Blogger", "profile", "user")
def execute():
""" copy data from old fields to new """
dataent.reload_doc("projects", "doctype", "project")
if dataent.db.has_column('Project', 'total_sales_cost'):
rename_field('Project', "total_sales_cost", "total_sales_amount")
if dataent.db.has_column('Project', 'total_billing_amount'):
rename_field('Project', "total_billing_amount",
"total_billable_amount")
def execute():
dataent.reload_doc("accounts", "doctype", "pricing_rule")
try:
rename_field("Pricing Rule", "price_or_discount", "rate_or_discount")
rename_field("Pricing Rule", "price", "rate")
except Exception as e:
if e.args[0] != 1054:
raise
def execute():
doc_list = [
"Work Order", "BOM", "Purchase Invoice Item", "Sales Invoice",
"Purchase Order Item", "Stock Entry", "Delivery Note", "Sales Order",
"Purchase Receipt Item", "Supplier Quotation Item"
]
for doctype in doc_list:
dataent.reload_doctype(doctype)
rename_field(doctype, "project_name", "project")
def execute():
dataent.db.sql("""
UPDATE `tabLeave Type`
SET max_days_allowed = '0'
WHERE trim(coalesce(max_days_allowed, '')) = ''
""")
dataent.db.sql_ddl(
"""ALTER table `tabLeave Type` modify max_days_allowed int(8) NOT NULL"""
)
dataent.reload_doc("hr", "doctype", "leave_type")
rename_field("Leave Type", "max_days_allowed",
"max_continuous_days_allowed")
def execute():
for dt in ("Sales Invoice Advance", "Purchase Invoice Advance"):
dataent.reload_doctype(dt)
dataent.db.sql(
"update `tab{0}` set reference_type = 'Journal Entry'".format(dt))
if dataent.get_meta(dt).has_field('journal_entry'):
rename_field(dt, "journal_entry", "reference_name")
if dataent.get_meta(dt).has_field('jv_detail_no'):
rename_field(dt, "jv_detail_no", "reference_row")
def execute():
rename_doc('DocType', 'Production Order', 'Work Order', force=True)
dataent.reload_doc('manufacturing', 'doctype', 'work_order')
rename_doc('DocType',
'Production Order Item',
'Work Order Item',
force=True)
dataent.reload_doc('manufacturing', 'doctype', 'work_order_item')
rename_doc('DocType',
'Production Order Operation',
'Work Order Operation',
force=True)
dataent.reload_doc('manufacturing', 'doctype', 'work_order_operation')
dataent.reload_doc('projects', 'doctype', 'timesheet')
dataent.reload_doc('stock', 'doctype', 'stock_entry')
rename_field("Timesheet", "production_order", "work_order")
rename_field("Stock Entry", "production_order", "work_order")
dataent.rename_doc("Report",
"Production Orders in Progress",
"Work Orders in Progress",
force=True)
dataent.rename_doc("Report",
"Completed Production Orders",
"Completed Work Orders",
force=True)
dataent.rename_doc("Report",
"Open Production Orders",
"Open Work Orders",
force=True)
dataent.rename_doc("Report",
"Issued Items Against Production Order",
"Issued Items Against Work Order",
force=True)
dataent.rename_doc("Report",
"Production Order Stock Report",
"Work Order Stock Report",
force=True)
dataent.db.sql("""update `tabDesktop Icon` \
set label='Work Order', module_name='Work Order' \
where label='Production Order'""")
dataent.db.sql("""update `tabDesktop Icon` \
set link='List/Work Order' \
where link='List/Production Order'""")
def execute():
if dataent.db.exists("DocType", "Examination"):
dataent.rename_doc("DocType", "Examination", "Assessment")
dataent.rename_doc("DocType", "Examination Result", "Assessment Result")
# 'Schools' module changed to the 'Education'
# dataent.reload_doc("schools", "doctype", "assessment")
# dataent.reload_doc("schools", "doctype", "assessment_result")
dataent.reload_doc("education", "doctype", "assessment")
dataent.reload_doc("education", "doctype", "assessment_result")
rename_field("Assessment", "exam_name", "assessment_name")
rename_field("Assessment", "exam_code", "assessment_code")
dataent.db.sql("delete from `tabPortal Menu Item` where route = '/examination'")
def execute():
if dataent.db.table_exists("Supplier Group"):
dataent.reload_doc('setup', 'doctype', 'supplier_group')
elif dataent.db.table_exists("Supplier Type"):
rename_doc("DocType", "Supplier Type", "Supplier Group", force=True)
dataent.reload_doc('setup', 'doctype', 'supplier_group')
dataent.reload_doc("accounts", "doctype", "pricing_rule")
dataent.reload_doc("accounts", "doctype", "tax_rule")
dataent.reload_doc("buying", "doctype", "buying_settings")
dataent.reload_doc("buying", "doctype", "supplier")
rename_field("Supplier Group", "supplier_type", "supplier_group_name")
rename_field("Supplier", "supplier_type", "supplier_group")
rename_field("Buying Settings", "supplier_type", "supplier_group")
rename_field("Pricing Rule", "supplier_type", "supplier_group")
rename_field("Tax Rule", "supplier_type", "supplier_group")
build_tree()
def execute():
# rename doctypes
tables = dataent.db.sql_list("show tables")
for old_dt, new_dt in [["Journal Voucher Detail", "Journal Entry Account"],
["Journal Voucher", "Journal Entry"],
[
"Budget Distribution Detail",
"Monthly Distribution Percentage"
], ["Budget Distribution", "Monthly Distribution"]]:
if "tab" + new_dt not in tables:
dataent.rename_doc("DocType", old_dt, new_dt, force=True)
# reload new child doctypes
dataent.reload_doc("manufacturing", "doctype", "work_order_operation")
dataent.reload_doc("manufacturing", "doctype", "workstation_working_hour")
dataent.reload_doc("stock", "doctype", "item_variant")
dataent.reload_doc("hr", "doctype", "salary_detail")
dataent.reload_doc("accounts", "doctype", "party_account")
dataent.reload_doc("accounts", "doctype", "fiscal_year_company")
#rename table fieldnames
for dn in rename_map:
if not dataent.db.exists("DocType", dn):
continue
dataent.reload_doc(get_doctype_module(dn), "doctype", scrub(dn))
for dt, field_list in rename_map.items():
if not dataent.db.exists("DocType", dt):
continue
for field in field_list:
rename_field(dt, field[0], field[1])
# update voucher type
for old, new in [["Bank Voucher", "Bank Entry"],
["Cash Voucher", "Cash Entry"],
["Credit Card Voucher", "Credit Card Entry"],
["Contra Voucher", "Contra Entry"],
["Write Off Voucher", "Write Off Entry"],
["Excise Voucher", "Excise Entry"]]:
dataent.db.sql(
"update `tabJournal Entry` set voucher_type=%s where voucher_type=%s",
(new, old))
def execute():
for doctypes, fields in [[selling_doctypes, selling_renamed_fields],
[buying_doctypes, buying_renamed_fields]]:
for dt in doctypes:
dataent.reload_doc(get_doctype_module(dt), "doctype", scrub(dt))
table_columns = dataent.db.get_table_columns(dt)
base_net_total = dataent.db.sql(
"select sum(ifnull({0}, 0)) from `tab{1}`".format(
fields[0][1], dt))[0][0]
if not base_net_total:
for f in fields:
if f[0] in table_columns:
rename_field(dt, f[0], f[1])
# Added new field "total_taxes_and_charges" in buying cycle, updating value
if dt in ("Supplier Quotation", "Purchase Order",
"Purchase Receipt", "Purchase Invoice"):
dataent.db.sql(
"""update `tab{0}` set total_taxes_and_charges =
round(base_total_taxes_and_charges/conversion_rate, 2)""".format(dt))
def execute():
for dt, field_list in field_rename_map.items():
if dataent.db.exists('DocType', dt):
dataent.reload_doc(get_doctype_module(dt), "doctype", scrub(dt))
for field in field_list:
if dataent.db.has_column(dt, field[0]):
rename_field(dt, field[0], field[1])
if dataent.db.exists('DocType', 'Lab Prescription'):
if dataent.db.has_column('Lab Prescription', 'parentfield'):
dataent.db.sql("""
update `tabLab Prescription` set parentfield = 'lab_test_prescription'
where parentfield = 'test_prescription'
""")
if dataent.db.exists('DocType', 'Lab Test Groups'):
if dataent.db.has_column('Lab Test Groups', 'parentfield'):
dataent.db.sql("""
update `tabLab Test Groups` set parentfield = 'lab_test_groups'
where parentfield = 'test_groups'
""")
def execute():
dataent.reload_doc("setup", "doctype", "company")
if dataent.db.has_column('Company', 'sales_target'):
rename_field("Company", "sales_target", "monthly_sales_target")
def execute():
dataent.reload_doc('projects', 'doctype', 'project')
if dataent.db.has_column('Project', 'from'):
rename_field('Project', 'from', 'from_time')
rename_field('Project', 'to', 'to_time')
def execute():
dataent.reload_doc('stock', 'doctype', 'material_request_item')
rename_field("Material Request Item", "sales_order_no", "sales_order")
dataent.reload_doc('support', 'doctype', 'maintenance_schedule_item')
rename_field("Maintenance Schedule Item", "prevdoc_docname", "sales_order")
def execute():
# 'Schools' module changed to the 'Education'
dataent.rename_doc("DocType", "Evaluation Criteria", "Assessment Criteria", force=True)
# dataent.reload_doc("schools", "doctype", "assessment_criteria")
dataent.reload_doc("education", "doctype", "assessment_criteria")
if 'evaluation_criteria' in dataent.db.get_table_columns('Assessment Criteria'):
rename_field("Assessment Criteria", "evaluation_criteria", "assessment_criteria")
dataent.rename_doc("DocType", "Assessment Evaluation Criteria", "Assessment Plan Criteria", force=True)
# dataent.reload_doc("schools", "doctype", "assessment_plan_criteria")
dataent.reload_doc("education", "doctype", "assessment_plan_criteria")
if 'evaluation_criteria' in dataent.db.get_table_columns('Assessment Plan'):
rename_field("Assessment Plan Criteria", "evaluation_criteria", "assessment_criteria")
# dataent.reload_doc("schools", "doctype", "assessment_plan")
dataent.reload_doc("education", "doctype", "assessment_plan")
rename_field("Assessment Plan", "evaluation_criterias", "assessment_criteria")
# dataent.reload_doc("schools", "doctype", "assessment_result_detail")
dataent.reload_doc("education", "doctype", "assessment_result_detail")
if 'evaluation_criteria' in dataent.db.get_table_columns('Assessment Result Detail'):
rename_field("Assessment Result Detail", "evaluation_criteria", "assessment_criteria")
dataent.rename_doc("DocType", "Course Evaluation Criteria", "Course Assessment Criteria", force=True)
# dataent.reload_doc("schools", "doctype", "course_assessment_criteria")
dataent.reload_doc("education", "doctype", "course_assessment_criteria")
if 'evaluation_criteria' in dataent.db.get_table_columns('Course Assessment Criteria'):
rename_field("Course Assessment Criteria", "evaluation_criteria", "assessment_criteria")
# dataent.reload_doc("schools", "doctype", "course")
dataent.reload_doc("education", "doctype", "course")
if 'evaluation_criteria' in dataent.db.get_table_columns('Course'):
rename_field("Course", "evaluation_criterias", "assessment_criteria")
def execute():
# Rename and reload the Land Unit and Linked Land Unit doctypes
if dataent.db.table_exists(
'Land Unit') and not dataent.db.table_exists('Location'):
rename_doc('DocType', 'Land Unit', 'Location', force=True)
dataent.reload_doc('assets', 'doctype', 'location')
if dataent.db.table_exists(
'Linked Land Unit'
) and not dataent.db.table_exists('Linked Location'):
rename_doc('DocType',
'Linked Land Unit',
'Linked Location',
force=True)
dataent.reload_doc('assets', 'doctype', 'linked_location')
if not dataent.db.table_exists('Crop Cycle'):
dataent.reload_doc('agriculture', 'doctype', 'crop_cycle')
# Rename the fields in related doctypes
if 'linked_land_unit' in dataent.db.get_table_columns('Crop Cycle'):
rename_field('Crop Cycle', 'linked_land_unit', 'linked_location')
if 'land_unit' in dataent.db.get_table_columns('Linked Location'):
rename_field('Linked Location', 'land_unit', 'location')
if not dataent.db.exists("Location", "All Land Units"):
dataent.get_doc({
"doctype": "Location",
"is_group": True,
"location_name": "All Land Units"
}).insert(ignore_permissions=True)
if dataent.db.table_exists('Land Unit'):
land_units = dataent.get_all('Land Unit', fields=['*'], order_by='lft')
for land_unit in land_units:
if not dataent.db.exists('Location',
land_unit.get('land_unit_name')):
dataent.get_doc({
'doctype':
'Location',
'location_name':
land_unit.get('land_unit_name'),
'parent_location':
land_unit.get('parent_land_unit') or "All Land Units",
'is_container':
land_unit.get('is_container'),
'is_group':
land_unit.get('is_group'),
'latitude':
land_unit.get('latitude'),
'longitude':
land_unit.get('longitude'),
'area':
land_unit.get('area'),
'location':
land_unit.get('location'),
'lft':
land_unit.get('lft'),
'rgt':
land_unit.get('rgt')
}).insert(ignore_permissions=True)
# dataent.db.sql("""update `tabDesktop Icon` set label='Location', module_name='Location' where label='Land Unit'""")
dataent.db.sql(
"""update `tabDesktop Icon` set link='List/Location' where link='List/Land Unit'"""
)
# Delete the Land Unit and Linked Land Unit doctypes
if dataent.db.table_exists('Land Unit'):
dataent.delete_doc('DocType', 'Land Unit', force=1)
if dataent.db.table_exists('Linked Land Unit'):
dataent.delete_doc('DocType', 'Linked Land Unit', force=1)
def execute():
for doctype in ("Salary Component", "Salary Detail"):
if "depends_on_lwp" in dataent.db.get_table_columns(doctype):
dataent.reload_doc("hr", "doctype", scrub(doctype))
rename_field(doctype, "depends_on_lwp", "depends_on_payment_days")
def rename_field_if_exists(doctype, old_fieldname, new_fieldname):
try:
rename_field(doctype, old_fieldname, new_fieldname)
except Exception as e:
if e.args[0] != 1054:
raise
def execute():
dataent.reload_doc('manufacturing', 'doctype', 'manufacturing_settings')
rename_field('Manufacturing Settings', 'over_production_allowance_percentage', 'overproduction_percentage_for_sales_order')
def execute():
if dataent.db.exists("DocType", "Fee Amount"):
dataent.rename_doc("DocType", "Fee Amount", "Fee Component")
for dt in ("Fees", "Fee Structure"):
dataent.reload_doctype(dt)
rename_field(dt, "amount", "components")
