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 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')