def validate(self):
for key in [
"item_naming_by", "item_group", "stock_uom",
"allow_negative_stock", "default_warehouse"
]:
frappe.db.set_default(key, self.get(key, ""))
from erpnext.setup.doctype.naming_series.naming_series import set_by_naming_series
set_by_naming_series("Item",
"item_code",
self.get("item_naming_by") == "Naming Series",
hide_name_field=True)
stock_frozen_limit = 356
submitted_stock_frozen = self.stock_frozen_upto_days
if submitted_stock_frozen > stock_frozen_limit:
self.stock_frozen_upto_days = stock_frozen_limit
frappe.msgprint(
_("`Freeze Stocks Older Than` should be smaller than %d days.")
% stock_frozen_limit)
# show/hide barcode field
frappe.make_property_setter({
'fieldname':
'barcode',
'property':
'hidden',
'value':
0 if self.show_barcode_field else 1
})
def create_property_setter(self):
if not self.insert_after: return
dt_meta = frappe.get_meta(self.dt)
if not dt_meta.get_field(self.insert_after):
frappe.throw(
_("Insert After field '{0}' mentioned in Custom Field '{1}', does not exist"
).format(dt_meta.get_label(self.insert_after), self.label),
frappe.DoesNotExistError)
frappe.db.sql(
"""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s
AND property = 'previous_field'""", (self.dt, self.fieldname))
frappe.make_property_setter(
{
"doctype": self.dt,
"fieldname": self.fieldname,
"property": "previous_field",
"value": self.insert_after
},
validate_fields_for_doctype=False)
def execute():
for doctype in frappe.get_all("DocType", filters={"issingle": 0}):
doctype = doctype.name
if not frappe.db.table_exists(doctype):
continue
for column in frappe.db.sql("desc `tab{doctype}`".format(doctype=doctype), as_dict=True):
fieldname = column["Field"]
column_type = column["Type"]
if not column_type.startswith("varchar"):
continue
max_length = frappe.db.sql("""select max(char_length(`{fieldname}`)) from `tab{doctype}`"""\
.format(fieldname=fieldname, doctype=doctype))
max_length = max_length[0][0] if max_length else None
if max_length and 140 < max_length <= 255:
print(
"setting length of '{fieldname}' in '{doctype}' as {length}".format(
fieldname=fieldname, doctype=doctype, length=max_length)
)
# create property setter for length
frappe.make_property_setter({
"doctype": doctype,
"fieldname": fieldname,
"property": "length",
"value": max_length,
"property_type": "Int"
})
frappe.clear_cache(doctype=doctype)
def make_property_setter(self,
prop,
value,
property_type,
fieldname=None,
apply_on=None,
row_name=None):
delete_property_setter(self.doc_type, prop, fieldname)
property_value = self.get_existing_property_value(prop, fieldname)
if property_value == value:
return
if not apply_on:
apply_on = "DocField" if fieldname else "DocType"
# create a new property setter
frappe.make_property_setter({
"doctype": self.doc_type,
"doctype_or_field": apply_on,
"fieldname": fieldname,
"row_name": row_name,
"property": prop,
"value": value,
"property_type": property_type
})
def setup_domain(domain):
if not domain in domains:
return
from frappe.desk.doctype.desktop_icon.desktop_icon import set_desktop_icons
data = frappe._dict(domains[domain])
if data.remove_roles:
for role in data.remove_roles:
frappe.db.sql('delete from tabUserRole where role=%s', role)
if data.desktop_icons:
set_desktop_icons(data.desktop_icons)
if data.properties:
for args in data.properties:
frappe.make_property_setter(args)
if data.set_value:
for args in data.set_value:
doc = frappe.get_doc(args[0], args[1] or args[0])
doc.set(args[2], args[3])
doc.save()
frappe.clear_cache()
def setup_domain(domain):
domains = get_domains()
if not domain in domains:
return
from frappe.desk.doctype.desktop_icon.desktop_icon import set_desktop_icons
data = frappe._dict(domains[domain])
if data.remove_roles:
for role in data.remove_roles:
frappe.db.sql('delete from tabUserRole where role=%s', role)
if data.desktop_icons:
set_desktop_icons(data.desktop_icons)
if data.properties:
for args in data.properties:
frappe.make_property_setter(args)
if data.set_value:
for args in data.set_value:
doc = frappe.get_doc(args[0], args[1] or args[0])
doc.set(args[2], args[3])
doc.save()
frappe.clear_cache()
def make_property_setter(self,
property,
value,
property_type,
fieldname=None):
self.delete_existing_property_setter(property, fieldname)
property_value = self.get_existing_property_value(property, fieldname)
if property_value == value:
return
# create a new property setter
frappe.make_property_setter({
"doctype":
self.doc_type,
"doctype_or_field":
"DocField" if fieldname else "DocType",
"fieldname":
fieldname,
"property":
property,
"value":
value,
"property_type":
property_type
})
def make_property_setters():
property_setter_list = [
{
"doctype": "Employee",
"fieldname": "bank_ac_no",
"property": "permlevel",
"value": 7,
"property_type": "Int",
},
{
"doctype_or_docfield": "DocField",
"doctype": "Bank Transaction",
"fieldname": "transaction_id",
"property": "hidden",
"value": 1,
"property_type": "Check",
},
{
"doctype_or_docfield": "DocField",
"doctype": "Bank Transaction",
"fieldname": "transaction_id",
"property": "print_hide",
"value": 1,
"property_type": "Check",
},
]
for property_setter in property_setter_list:
frappe.make_property_setter(property_setter)
frappe.db.commit()
def make_property_setter(self,
property,
value,
property_type,
fieldname=None):
self.delete_existing_property_setter(property, fieldname)
property_value = self.get_existing_property_value(property, fieldname)
if property_value == value:
return
# create a new property setter
# ignore validation becuase it will be done at end
frappe.make_property_setter(
{
"doctype": self.doc_type,
"doctype_or_field": "DocField" if fieldname else "DocType",
"fieldname": fieldname,
"property": property,
"value": value,
"property_type": property_type
},
ignore_validate=True)
self.transfer_to_doc()
def set_property_setter_for_idx(self):
dt_meta = frappe.get_meta(self.dt)
self.validate_insert_after(dt_meta)
_idx = []
existing_property_setter = frappe.db.get_value("Property Setter",
{"doc_type": self.dt, "property": "_idx"}, ["name", "value"], as_dict=1)
# if no existsing property setter, build based on meta
if not existing_property_setter:
for df in sorted(dt_meta.get("fields"), key=lambda x: x.idx):
if df.fieldname != self.fieldname:
_idx.append(df.fieldname)
else:
_idx = json.loads(existing_property_setter.value)
# Delete existing property setter if field is not there
if self.fieldname not in _idx:
frappe.delete_doc("Property Setter", existing_property_setter.name)
existing_property_setter = None
# Create new peroperty setter if order changed
if _idx and not existing_property_setter:
field_idx = (_idx.index(self.insert_after) + 1) if (self.insert_after in _idx) else len(_idx)
_idx.insert(field_idx, self.fieldname)
frappe.make_property_setter({
"doctype":self.dt,
"doctype_or_field": "DocType",
"property": "_idx",
"value": json.dumps(_idx),
"property_type": "Text"
}, validate_fields_for_doctype=False)
def set_hidden_property_setter(doctype, fieldname):
frappe.make_property_setter({
'doctype': doctype,
'fieldname': fieldname,
'property': 'hidden',
'value': '1'
})
def set_readonly_property_setter(doctype, fieldname):
frappe.make_property_setter({
'doctype': doctype,
'fieldname': fieldname,
'property': 'read_only',
'value': '1'
})
def execute():
for doctype in frappe.get_all("DocType", filters={"issingle": 0}):
doctype = doctype.name
for column in frappe.db.sql(
"desc `tab{doctype}`".format(doctype=doctype), as_dict=True):
fieldname = column["Field"]
column_type = column["Type"]
if not column_type.startswith("varchar"):
continue
max_length = frappe.db.sql("""select max(char_length(`{fieldname}`)) from `tab{doctype}`"""\
.format(fieldname=fieldname, doctype=doctype))
max_length = max_length[0][0] if max_length else None
if max_length and 140 < max_length <= 255:
print "setting length of '{fieldname}' in '{doctype}' as {length}".format(
fieldname=fieldname, doctype=doctype, length=max_length)
# create property setter for length
frappe.make_property_setter({
"doctype": doctype,
"fieldname": fieldname,
"property": "length",
"value": max_length,
"property_type": "Int"
})
frappe.clear_cache(doctype=doctype)
def validate(self):
for key in [
"item_naming_by", "item_group", "stock_uom",
"allow_negative_stock", "default_warehouse",
"set_qty_in_transactions_based_on_serial_no_input"
]:
frappe.db.set_default(key, self.get(key, ""))
from erpnext.setup.doctype.naming_series.naming_series import set_by_naming_series
set_by_naming_series("Item",
"item_code",
self.get("item_naming_by") == "Naming Series",
hide_name_field=True)
stock_frozen_limit = 356
submitted_stock_frozen = self.stock_frozen_upto_days or 0
if submitted_stock_frozen > stock_frozen_limit:
self.stock_frozen_upto_days = stock_frozen_limit
frappe.msgprint(
_("`Freeze Stocks Older Than` should be smaller than %d days.")
% stock_frozen_limit)
# show/hide barcode field
for name in ["barcode", "barcodes", "scan_barcode"]:
frappe.make_property_setter(
{
'fieldname': name,
'property': 'hidden',
'value': 0 if self.show_barcode_field else 1
},
validate_fields_for_doctype=False)
self.validate_warehouses()
self.cant_change_valuation_method()
self.validate_clean_description_html()
def set_in_list_view_property(doctype, field, value):
if not field or field.fieldname == "status_field":
return
property_setter = frappe.db.get_value(
"Property Setter", {
"doc_type": doctype,
"field_name": field.fieldname,
"property": "in_list_view"
})
if property_setter:
doc = frappe.get_doc("Property Setter", property_setter)
doc.value = value
doc.save()
else:
frappe.make_property_setter(
{
"doctype": doctype,
"doctype_or_field": "DocField",
"fieldname": field.fieldname,
"property": "in_list_view",
"value": value,
"property_type": "Check"
},
ignore_validate=True)
def make_property_setters():
frappe.make_property_setter({
'doctype': 'Employee',
'fieldname': 'bank_ac_no',
'property': 'permlevel',
'value': 7,
'property_type': 'Int'
})
frappe.db.commit()
def make_demo_user():
roles = [
"Accounts Manager", "Analytics", "Expense Approver", "Accounts User",
"Leave Approver", "Blogger", "Customer", "Sales Manager", "Employee",
"HR Manager", "HR User", "Maintenance Manager", "Maintenance User",
"Stock Manager", "Item Manager", "Stock User", "Manufacturing Manager",
"Manufacturing User", "Projects User", "Purchase Manager",
"Purchase Master Manager", "Purchase User", "Quality Manager",
"Report Manager", "Sales Master Manager", "Sales User", "Supplier",
"Support Team", "Newsletter Manager"
]
def add_roles(doc):
for role in roles:
if not frappe.db.exists("Role", role):
role_doc = frappe.get_doc({
"doctype": "Role",
"role_name": role
})
role_doc.save()
doc.append("user_roles", {"doctype": "UserRole", "role": role})
# make demo user
if frappe.db.exists("User", "*****@*****.**"):
frappe.delete_doc("User", "*****@*****.**")
# add User Type property setter
user_types = frappe.get_meta("User").get_field("user_type").options
frappe.make_property_setter({
"doctype_or_field": "DocField",
"doctype": "User",
"fieldname": "user_type",
"property": "options",
"value": (user_types or "") + "\nERPNext Demo",
"property_type": "Text"
})
p = frappe.new_doc("User")
p.email = "*****@*****.**"
p.first_name = "Demo"
p.last_name = "User"
p.enabled = 1
p.user_type = "ERPNext Demo"
p.insert()
add_roles(p)
p.save()
update_password("*****@*****.**", "demo")
# only read for newsletter
frappe.db.sql("""update `tabDocPerm` set `write`=0, `create`=0, `cancel`=0
where parent='Newsletter'""")
frappe.db.sql("""update `tabDocPerm` set `write`=0, `create`=0, `cancel`=0
where parent='User' and role='All'""")
frappe.db.commit()
def execute():
frappe.db.sql(
"""delete from `tabProperty Setter` where property='previous_field'""")
all_custom_fields = frappe._dict()
for d in frappe.db.sql(
"""select name, dt, fieldname, insert_after from `tabCustom Field`
where insert_after is not null and insert_after != ''""",
as_dict=1):
all_custom_fields.setdefault(d.dt, frappe._dict()).setdefault(
d.fieldname, d.insert_after)
for dt, custom_fields in all_custom_fields.items():
_idx = []
existing_ps = frappe.db.get_value("Property Setter", {
"doc_type": dt,
"property": "_idx"
}, ["name", "value", "creation"],
as_dict=1)
# if no existsing property setter, build based on meta
if not existing_ps:
_idx = get_sorted_fields(dt, custom_fields)
else:
_idx = json.loads(existing_ps.value)
idx_needs_to_be_fixed = False
for fieldname, insert_after in custom_fields.items():
# Delete existing property setter if field is not there
if fieldname not in _idx:
idx_needs_to_be_fixed = True
break
else:
previous_field = _idx[_idx.index(fieldname) - 1]
if previous_field != insert_after and cstr(
existing_ps.creation) >= "2015-12-28":
idx_needs_to_be_fixed = True
break
if idx_needs_to_be_fixed:
frappe.delete_doc("Property Setter", existing_ps.name)
_idx = get_sorted_fields(dt, custom_fields)
if _idx:
frappe.make_property_setter(
{
"doctype": dt,
"doctype_or_field": "DocType",
"property": "_idx",
"value": json.dumps(_idx),
"property_type": "Text"
},
validate_fields_for_doctype=False)
def after_install():
"""Add Mandrill under Email Account Service options"""
meta = frappe.get_meta("Email Account")
options = filter(None, meta.get_field("service").options.split("\n"))
options.append("Mandrill")
options = [""] + sorted(list(set(options)))
frappe.make_property_setter({
"doctype": "Email Account",
"fieldname": "service",
"property": "options",
"value": "\n".join(options),
"property_type": "Text"
})
def make_default(name):
frappe.has_permission("Print Format", "write")
print_format = frappe.get_doc("Print Format", name)
frappe.make_property_setter({
'doctype_or_field': "DocType",
'doctype': print_format.doc_type,
'property': "default_print_format",
'value': name,
})
frappe.msgprint(frappe._("Done"))
def after_install():
"""Add Mandrill under Email Account Service options"""
meta = frappe.get_meta("Email Account")
options = filter(None, meta.get_field("service").options.split("\n"))
options.append("Mandrill")
options = [""] + sorted(list(set(options)))
frappe.make_property_setter({
"doctype": "Email Account",
"fieldname": "service",
"property": "options",
"value": "\n".join(options),
"property_type": "Text"
})
def make_default(name):
frappe.has_permission("Print Format", "write")
print_format = frappe.get_doc("Print Format", name)
frappe.make_property_setter({
'doctype_or_field': "DocType",
'doctype': print_format.doc_type,
'property': "default_print_format",
'value': name,
})
frappe.msgprint(frappe._("Done"))
def make_demo_user():
from frappe.auth import _update_password
roles = ["Accounts Manager", "Analytics", "Expense Approver", "Accounts User",
"Leave Approver", "Blogger", "Customer", "Sales Manager", "Employee", "Support Manager",
"HR Manager", "HR User", "Maintenance Manager", "Maintenance User", "Material Manager",
"Material Master Manager", "Material User", "Manufacturing Manager",
"Manufacturing User", "Projects User", "Purchase Manager", "Purchase Master Manager",
"Purchase User", "Quality Manager", "Report Manager", "Sales Master Manager",
"Sales User", "Supplier", "Support Team"]
def add_roles(doc):
for role in roles:
doc.append("user_roles", {
"doctype": "UserRole",
"role": role
})
# make demo user
if frappe.db.exists("User", "*****@*****.**"):
frappe.delete_doc("User", "*****@*****.**")
# add User Type property setter
user_types = frappe.get_meta("User").get_field("user_type").options
frappe.make_property_setter({
"doctype_or_field": "DocField",
"doctype": "User",
"fieldname": "user_type",
"property": "options",
"value": (user_types or "") + "\nERP Boost Demo",
"property_type": "Text"
})
p = frappe.new_doc("User")
p.email = "*****@*****.**"
p.first_name = "Demo"
p.last_name = "User"
p.enabled = 1
p.user_type = "ERP Boost Demo"
p.insert()
add_roles(p)
p.save()
_update_password("*****@*****.**", "demo")
# only read for newsletter
frappe.db.sql("""update `tabDocPerm` set `write`=0, `create`=0, `cancel`=0
where parent='Newsletter'""")
frappe.db.sql("""update `tabDocPerm` set `write`=0, `create`=0, `cancel`=0
where parent='User' and role='All'""")
frappe.db.commit()
def execute():
frappe.reload_doc('stock', 'doctype', 'item')
frappe.reload_doc('stock', 'doctype', 'stock_settings')
stock_settings = frappe.get_single("Stock Settings")
stock_settings.item_naming_by = "Item Name"
stock_settings.save()
frappe.make_property_setter({'doctype': 'Item', 'fieldname': 'item_code', 'property': 'hidden',
'value': 0})
frappe.make_property_setter({'doctype': 'Item', 'fieldname': 'item_name', 'property': 'hidden',
'value': 0})
frappe.make_property_setter({'doctype': 'Item', 'fieldname': 'item_name', 'property': 'read_only',
'value': 0})
frappe.make_property_setter({'doctype': 'Item', 'fieldname': 'naming_series', 'property': 'hidden',
'value': 0})
for name in frappe.get_all("Item"):
name = name.name
item = frappe.get_doc("Item", name)
if item.clean_name(item.name) == item.clean_name(item.item_name):
item.db_set('item_naming_by', 'Item Name')
else:
item.db_set('item_naming_by', 'Item Code')
if item.name == "Service":
item.db_set('show_item_code', 'No')
def execute():
# deprecated on 2016-03-09
# using insert_after instead
return
frappe.db.sql("""delete from `tabProperty Setter` where property='previous_field'""")
all_custom_fields = frappe._dict()
for d in frappe.db.sql("""select name, dt, fieldname, insert_after from `tabCustom Field`
where insert_after is not null and insert_after != ''""", as_dict=1):
all_custom_fields.setdefault(d.dt, frappe._dict()).setdefault(d.fieldname, d.insert_after)
for dt, custom_fields in all_custom_fields.items():
_idx = []
existing_ps = frappe.db.get_value("Property Setter",
{"doc_type": dt, "property": "_idx"}, ["name", "value", "creation"], as_dict=1)
# if no existsing property setter, build based on meta
if not existing_ps:
_idx = get_sorted_fields(dt, custom_fields)
else:
_idx = json.loads(existing_ps.value)
idx_needs_to_be_fixed = False
for fieldname, insert_after in custom_fields.items():
# Delete existing property setter if field is not there
if fieldname not in _idx:
idx_needs_to_be_fixed = True
break
else:
previous_field = _idx[_idx.index(fieldname) - 1]
if previous_field != insert_after and cstr(existing_ps.creation) >= "2015-12-28":
idx_needs_to_be_fixed = True
break
if idx_needs_to_be_fixed:
frappe.delete_doc("Property Setter", existing_ps.name)
_idx = get_sorted_fields(dt, custom_fields)
if _idx:
frappe.make_property_setter({
"doctype":dt,
"doctype_or_field": "DocType",
"property": "_idx",
"value": json.dumps(_idx),
"property_type": "Text"
}, validate_fields_for_doctype=False)
def make_property_setter(self, property, value, property_type, fieldname=None):
self.delete_existing_property_setter(property, fieldname)
property_value = self.get_existing_property_value(property, fieldname)
if property_value==value:
return
# create a new property setter
frappe.make_property_setter({
"doctype": self.doc_type,
"doctype_or_field": "DocField" if fieldname else "DocType",
"fieldname": fieldname,
"property": property,
"value": value,
"property_type": property_type
})
def validate(self):
for key in ["item_naming_by", "item_group", "stock_uom", "allow_negative_stock", "default_warehouse"]:
frappe.db.set_default(key, self.get(key, ""))
from erpnext.setup.doctype.naming_series.naming_series import set_by_naming_series
set_by_naming_series("Item", "item_code",
self.get("item_naming_by")=="Naming Series", hide_name_field=True)
stock_frozen_limit = 356
submitted_stock_frozen = self.stock_frozen_upto_days
if submitted_stock_frozen > stock_frozen_limit:
self.stock_frozen_upto_days = stock_frozen_limit
frappe.msgprint (_("`Freeze Stocks Older Than` should be smaller than %d days.") %stock_frozen_limit)
# show/hide barcode field
frappe.make_property_setter({'fieldname': 'barcode', 'property': 'hidden',
'value': 0 if self.show_barcode_field else 1})
def make_property_setter(self, property, value, property_type, fieldname=None):
self.delete_existing_property_setter(property, fieldname)
property_value = self.get_existing_property_value(property, fieldname)
if property_value==value:
return
# create a new property setter
# ignore validation becuase it will be done at end
frappe.make_property_setter({
"doctype": self.doc_type,
"doctype_or_field": "DocField" if fieldname else "DocType",
"fieldname": fieldname,
"property": property,
"value": value,
"property_type": property_type
}, ignore_validate=True)
def execute():
frappe.reload_doc("automation", "doctype", "auto_repeat")
auto_repeats = frappe.get_all("Auto Repeat",\
fields=["name", "docstatus", "status", "reference_doctype"])
references = set()
for auto_repeat in auto_repeats:
if auto_repeat["docstatus"] == 2 or auto_repeat["status"] in [
"Stopped", "Cancelled"
]:
frappe.db.set_value("Auto Repeat", auto_repeat["name"], "disabled",
1)
if auto_repeat["docstatus"] != 0:
frappe.db.set_value("Auto Repeat", auto_repeat["name"],
"docstatus", 0)
references.add(auto_repeat["reference_doctype"])
for reference in references:
frappe.make_property_setter({
"doctype": reference,
"doctype_or_field": "DocType",
"property": "allow_auto_repeat",
"value": 1,
"property_type": "Check"
})
if not frappe.db.exists('Custom Field', {
'fieldname': 'auto_repeat',
'dt': reference
}):
doc = frappe.get_doc("DocType", reference)
insert_after = doc.fields[len(doc.fields) - 1].fieldname
df = dict(fieldname='auto_repeat', label='Auto Repeat', fieldtype='Link', options='Auto Repeat',\
insert_after=insert_after, read_only=1, no_copy=1, print_hide=1)
create_custom_field(reference, df)
for auto_repeat in auto_repeats:
doc = frappe.get_doc("Auto Repeat", auto_repeat["name"])
doc.update_status()
try:
doc.save()
except frappe.ValidationError:
continue
def create_property_setter(self):
if not self.insert_after: return
idx_label_list, field_list = get_fields_label(self.dt, 0)
label_index = idx_label_list.index(self.insert_after)
if label_index==-1: return
prev_field = field_list[label_index]
frappe.db.sql("""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s
AND property = 'previous_field'""", (self.dt, self.fieldname))
frappe.make_property_setter({
"doctype":self.dt,
"fieldname": self.fieldname,
"property": "previous_field",
"value": prev_field
})
def set_property_setter_for_idx(self):
dt_meta = frappe.get_meta(self.dt)
self.validate_insert_after(dt_meta)
_idx = []
existing_property_setter = frappe.db.get_value("Property Setter", {
"doc_type": self.dt,
"property": "_idx"
}, ["name", "value"],
as_dict=1)
# if no existsing property setter, build based on meta
if not existing_property_setter:
for df in sorted(dt_meta.get("fields"), key=lambda x: x.idx):
if df.fieldname != self.fieldname:
_idx.append(df.fieldname)
else:
_idx = json.loads(existing_property_setter.value)
# Delete existing property setter if field is not there
if self.fieldname not in _idx:
frappe.delete_doc("Property Setter",
existing_property_setter.name)
existing_property_setter = None
# Create new peroperty setter if order changed
if _idx and not existing_property_setter:
field_idx = (_idx.index(self.insert_after) +
1) if (self.insert_after in _idx) else len(_idx)
_idx.insert(field_idx, self.fieldname)
frappe.make_property_setter(
{
"doctype": self.dt,
"doctype_or_field": "DocType",
"property": "_idx",
"value": json.dumps(_idx),
"property_type": "Text"
},
validate_fields_for_doctype=False)
def create_property_setter(self):
if not self.insert_after: return
dt_meta = frappe.get_meta(self.dt)
if not dt_meta.get_field(self.insert_after):
frappe.throw(_("Insert After field '{0}' mentioned in Custom Field '{1}', does not exist")
.format(self.insert_after, self.label), frappe.DoesNotExistError)
frappe.db.sql("""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s
AND property = 'previous_field'""", (self.dt, self.fieldname))
frappe.make_property_setter({
"doctype":self.dt,
"fieldname": self.fieldname,
"property": "previous_field",
"value": self.insert_after
}, validate_fields_for_doctype=False)
def create_property_setter(self):
if not self.doc.insert_after: return
idx_label_list, field_list = get_fields_label(self.doc.dt, 0)
label_index = idx_label_list.index(self.doc.insert_after)
if label_index == -1: return
prev_field = field_list[label_index]
frappe.db.sql(
"""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s
AND property = 'previous_field'""", (self.doc.dt, self.doc.fieldname))
frappe.make_property_setter({
"doctype": self.doc.dt,
"fieldname": self.doc.fieldname,
"property": "previous_field",
"value": prev_field
})
def make_default(name):
"""Set print format as default"""
frappe.has_permission("Print Format", "write")
print_format = frappe.get_doc("Print Format", name)
if (frappe.conf.get('developer_mode') or 0) == 1:
# developer mode, set it default in doctype
doctype = frappe.get_doc("DocType", print_format.doc_type)
doctype.default_print_format = name
doctype.save()
else:
# customization
frappe.make_property_setter({
'doctype_or_field': "DocType",
'doctype': print_format.doc_type,
'property': "default_print_format",
'value': name,
})
frappe.msgprint(frappe._("Done"))
def validate(self):
for key in ["item_naming_by", "item_group", "stock_uom",
"allow_negative_stock", "default_warehouse", "set_qty_in_transactions_based_on_serial_no_input"]:
frappe.db.set_default(key, self.get(key, ""))
from erpnext.setup.doctype.naming_series.naming_series import set_by_naming_series
set_by_naming_series("Item", "item_code",
self.get("item_naming_by")=="Naming Series", hide_name_field=True)
stock_frozen_limit = 356
submitted_stock_frozen = self.stock_frozen_upto_days or 0
if submitted_stock_frozen > stock_frozen_limit:
self.stock_frozen_upto_days = stock_frozen_limit
frappe.msgprint (_("`Freeze Stocks Older Than` should be smaller than %d days.") %stock_frozen_limit)
# show/hide barcode field
for name in ["barcode", "barcodes", "scan_barcode"]:
frappe.make_property_setter({'fieldname': name, 'property': 'hidden',
'value': 0 if self.show_barcode_field else 1})
self.cant_change_valuation_method()
self.validate_clean_description_html()
def make_default(name):
"""Set print format as default"""
frappe.has_permission("Print Format", "write")
print_format = frappe.get_doc("Print Format", name)
if (frappe.conf.get("developer_mode") or 0) == 1:
# developer mode, set it default in doctype
doctype = frappe.get_doc("DocType", print_format.doc_type)
doctype.default_print_format = name
doctype.save()
else:
# customization
frappe.make_property_setter({
"doctype_or_field": "DocType",
"doctype": print_format.doc_type,
"property": "default_print_format",
"value": name,
})
frappe.msgprint(
frappe._("{0} is now default print format for {1} doctype").format(
frappe.bold(name), frappe.bold(print_format.doc_type)))
def execute():
is_dev_mode = frappe.conf.developer_mode
frappe.conf.developer_mode = 0
rename_doc("DocType", "Order Type", "Transaction Type", 1, 0, 1)
frappe.conf.developer_mode = is_dev_mode
frappe.reload_doc("selling", "doctype", "transaction_type")
frappe.reload_doc("selling", "doctype", "sales_order")
frappe.reload_doc("stock", "doctype", "delivery_note")
frappe.reload_doc("accounts", "doctype", "sales_invoice")
frappe.reload_doc("accounts", "doctype", "tax_rule")
frappe.reload_doc("core", "doctype", "auto_value_setter")
frappe.reload_doc("core", "doctype", "auto_value_setter_condition")
rename_field("Transaction Type", "order_type_name",
"transaction_type_name")
rename_field("Transaction Type", "type", "order_type")
rename_field("Sales Order", "order_type_name", "transaction_type")
rename_field("Delivery Note", "order_type_name", "transaction_type")
rename_field("Sales Invoice", "order_type_name", "transaction_type")
rename_field("Tax Rule", "stin", "has_stin")
rename_field("Tax Rule", "order_type", "transaction_type")
frappe.db.sql(
"""update `tabTax Rule` set has_stin = 'Yes' where has_stin = 'Set'""")
frappe.db.sql(
"""update `tabTax Rule` set has_stin = 'No' where has_stin = 'Not Set'"""
)
frappe.db.sql(
"""update `tabSales Invoice` set has_stin = if(ifnull(stin, 0) = 0, 0, 1)"""
)
site_name = frappe.utils.get_site_name(frappe.utils.get_host_name())
if site_name in ('tar.time.net.pk', 'time.time.net.pk', 'tti.time.net.pk',
'ct.time.net.pk', 'atc.time.net.pk', 'pc.time.net.pk',
'personal.time.net.pk', 'tar'):
for dt, names in iteritems(to_delete):
for dn in names:
frappe.delete_doc_if_exists(dt, dn)
for dn, script in iteritems(custom_scripts):
if frappe.db.exists("Custom Script", dn):
frappe.db.set_value("Custom Script", dn, 'script', script)
for company in frappe.get_all("Company", fields=['name', 'abbr']):
max_fbr_stin = frappe.db.sql(
"""
select max(stin)
from `tabSales Invoice`
where company = %s and transaction_type != 'Service' and docstatus=1 and is_return=0
""", company.name)
max_srb_stin = frappe.db.sql(
"""
select max(stin)
from `tabSales Invoice`
where company = %s and transaction_type = 'Service' and docstatus=1 and is_return=0
""", company.name)
if max_fbr_stin and max_fbr_stin[0][0]:
prefix = "{0}-".format(company.abbr)
frappe.db.sql(
"replace into `tabSeries` (name, current) values (%s, %s)",
[prefix, max_fbr_stin[0][0]])
if max_srb_stin and max_srb_stin[0][0]:
prefix = "{0}-S-".format(company.abbr)
frappe.db.sql(
"replace into `tabSeries` (name, current) values (%s, %s)",
[prefix, max_srb_stin[0][0]])
naming_series_controller = frappe.new_doc("Naming Series")
for dt, series in iteritems(doctype_naming_series):
naming_series_controller.user_must_always_select = cint(
series.startswith("\n"))
naming_series_controller.set_series_for(dt, series.split("\n"))
for dt in naming_series_to_hide:
frappe.make_property_setter({
'doctype': dt,
'fieldname': 'naming_series',
'property': 'hidden',
'value': 1
})
for d in auto_value_setters:
doc = frappe.new_doc("Auto Value Setter")
doc.update(d)
doc.save()
for name in print_headings:
if not frappe.db.exists("Print Heading", name):
doc = frappe.new_doc("Print Heading")
doc.print_heading = name
doc.save()
def setup_properties(data):
if data.properties:
for args in data.properties:
frappe.make_property_setter(args)
def setup_properties(self): if self.data.properties: for args in self.data.properties: frappe.make_property_setter(args)
def execute():
print('Applying Sales Invoice defaults...')
fields = [{
"field_name": "naming_series",
"property": "read_only",
"property_type": "Check",
"value": "1"
}, {
"field_name": "project",
"property": "hidden",
"property_type": "Link",
"value": "1"
}, {
"field_name": "loyalty_points_redemption",
"property": "hidden",
"property_type": "Section Break",
"value": "1"
}, {
"field_name": "loyalty_points",
"property": "hidden",
"property_type": "Int",
"value": "1"
}, {
"field_name": "loyalty_amount",
"property": "hidden",
"property_type": "Currency",
"value": "1"
}, {
"field_name": "redeem_loyalty_points",
"property": "hidden",
"property_type": "Check",
"value": "1"
}, {
"field_name": "column_break_77",
"property": "hidden",
"property_type": "Column Break",
"value": "1"
}, {
"field_name": "loyalty_program",
"property": "hidden",
"property_type": "Link",
"value": "1"
}, {
"field_name": "loyalty_redemption_account",
"property": "hidden",
"property_type": "Link",
"value": "1"
}, {
"field_name": "loyalty_redemption_cost_center",
"property": "hidden",
"property_type": "Link",
"value": "1"
}, {
"field_name": "time_sheet_list",
"property": "hidden",
"property_type": "Section Break",
"value": "1"
}, {
"field_name": "timesheets",
"property": "hidden",
"property_type": "Table",
"value": "1"
}, {
"field_name": "total_billing_amount",
"property": "hidden",
"property_type": "Currency",
"value": "1"
}]
for field in fields:
frappe.make_property_setter({
'doctype': 'Sales Invoice',
'fieldname': field['field_name'],
'property': field['property'],
'value': field['value'],
'property_type': field['property_type']
})
print('Created property setter for {}'.format(field['field_name']))
_set_printing_settings()
set_hidden_property_setter('Sales Invoice', 'total_net_weight')
set_hidden_property_setter('Sales Invoice', 'shipping_rule')
def setup_properties(data): if data.properties: for args in data.properties: frappe.make_property_setter(args)
def setup_properties(self):
if self.data.properties:
for args in self.data.properties:
frappe.make_property_setter(args)
