def on_update(self):
"""update defaults"""
self.validate_session_expiry()
self.update_control_panel()
for key in keydict:
webnotes.conn.set_default(key, self.doc.fields.get(keydict[key], ''))
# update year start date and year end date from fiscal_year
year_start_end_date = webnotes.conn.sql("""select year_start_date, year_end_date
from `tabFiscal Year` where name=%s""", self.doc.current_fiscal_year)
ysd = year_start_end_date[0][0] or ''
yed = year_start_end_date[0][1] or ''
if ysd and yed:
webnotes.conn.set_default('year_start_date', ysd.strftime('%Y-%m-%d'))
webnotes.conn.set_default('year_end_date', yed.strftime('%Y-%m-%d'))
# enable default currency
if self.doc.default_currency:
webnotes.conn.set_value("Currency", self.doc.default_currency, "enabled", 1)
# clear cache
webnotes.clear_cache()
def setup_account(args=None):
# if webnotes.conn.sql("select name from tabCompany"):
# webnotes.throw(_("Setup Already Complete!!"))
if not args:
args = webnotes.local.form_dict
if isinstance(args, basestring):
args = json.loads(args)
args = webnotes._dict(args)
update_profile_name(args)
create_fiscal_year_and_company(args)
set_defaults(args)
create_territories()
# create_price_lists(args)
create_feed_and_todo()
import_core_docs()
# create_email_digest()
# create_letter_head(args)
# create_taxes(args)
# create_items(args)
# create_customers(args)
# create_suppliers(args)
webnotes.conn.set_value('Control Panel', None, 'home_page', 'desktop')
webnotes.clear_cache()
webnotes.conn.commit()
# suppress msgprints
webnotes.local.message_log = []
exec_in_shell("""cp -r {path}/lib/public/datatable {path}/public/files
""".format(path=get_base_path()))
webnotes.conn.sql("CREATE TABLE ack(ENCOUNTER_ID varchar(20),ACK varchar(20))")
webnotes.conn.sql("commit()")
return "okay"
def reset_global_defaults():
flds = {
'default_company': None,
'default_currency': None,
'current_fiscal_year': None,
'date_format': 'dd-mm-yyyy',
'sms_sender_name': None,
'default_item_group': 'Default',
'default_stock_uom': 'Nos',
'default_valuation_method': 'FIFO',
'default_warehouse_type': 'Default Warehouse Type',
'tolerance': None,
'acc_frozen_upto': None,
'bde_auth_role': None,
'credit_controller': None,
'default_customer_group': 'Default Customer Group',
'default_territory': 'Default',
'default_price_list': 'Standard',
'default_supplier_type': 'Default Supplier Type',
'hide_currency_symbol': None,
'default_price_list_currency': None,
}
from webnotes.model.code import get_obj
gd = get_obj('Global Defaults', 'Global Defaults')
for d in flds:
gd.doc.fields[d] = flds[d]
gd.doc.save()
webnotes.clear_cache()
def clear_doctype_cache(doctype):
webnotes.clear_cache(doctype=doctype)
for user in webnotes.conn.sql_list(
"""select distinct tabUserRole.parent from tabUserRole, tabDocPerm
where tabDocPerm.parent = %s
and tabDocPerm.role = tabUserRole.role""", doctype):
webnotes.clear_cache(user=user)
def setup_account(args=None):
# if webnotes.conn.sql("select name from tabCompany"):
# webnotes.throw(_("Setup Already Complete!!"))
if not args:
args = webnotes.local.form_dict
if isinstance(args, basestring):
args = json.loads(args)
args = webnotes._dict(args)
update_profile_name(args)
create_fiscal_year_and_company(args)
set_defaults(args)
create_territories()
create_price_lists(args)
create_feed_and_todo()
create_email_digest()
create_letter_head(args)
create_taxes(args)
create_items(args)
create_customers(args)
create_suppliers(args)
webnotes.conn.set_value('Control Panel', None, 'home_page', 'desktop')
webnotes.clear_cache()
webnotes.conn.commit()
# suppress msgprints
webnotes.local.message_log = []
return "okay"
def reset_perms(site=None):
webnotes.connect(site=site)
for d in webnotes.conn.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
webnotes.clear_cache(doctype=d)
webnotes.reset_perms(d)
webnotes.destroy()
def create_custom_field_for_workflow_state(self):
webnotes.clear_cache(doctype=self.doc.document_type)
doctypeobj = webnotes.get_doctype(self.doc.document_type)
if not len(doctypeobj.get({"doctype": "DocField", "fieldname": self.doc.workflow_state_field})):
# create custom field
webnotes.bean(
[
{
"doctype": "Custom Field",
"dt": self.doc.document_type,
"__islocal": 1,
"fieldname": self.doc.workflow_state_field,
"label": self.doc.workflow_state_field.replace("_", " ").title(),
"hidden": 1,
"fieldtype": "Link",
"options": "Workflow State",
# "insert_after": doctypeobj.get({"doctype":"DocField"})[-1].fieldname
}
]
).save()
webnotes.msgprint(
"Created Custom Field '%s' in '%s'" % (self.doc.workflow_state_field, self.doc.document_type)
)
def on_trash(self):
webnotes.clear_cache(user=self.doc.name)
if self.doc.name in ["Administrator", "Guest"]:
webnotes.msgprint("""Hey! You cannot delete user: %s""" % (self.name, ),
raise_exception=1)
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.doc.enabled = 0
if getattr(webnotes.local, "login_manager", None):
webnotes.local.login_manager.logout(user=self.doc.name)
# delete their password
webnotes.conn.sql("""delete from __Auth where user=%s""", self.doc.name)
# delete todos
webnotes.conn.sql("""delete from `tabToDo` where owner=%s""", self.doc.name)
webnotes.conn.sql("""update tabToDo set assigned_by=null where assigned_by=%s""",
self.doc.name)
# delete events
webnotes.conn.sql("""delete from `tabEvent` where owner=%s
and event_type='Private'""", self.doc.name)
webnotes.conn.sql("""delete from `tabEvent User` where person=%s""", self.doc.name)
# delete messages
webnotes.conn.sql("""delete from `tabComment` where comment_doctype='Message'
and (comment_docname=%s or owner=%s)""", (self.doc.name, self.doc.name))
def reset_global_defaults():
flds = {
"default_company": "",
"default_currency": "",
"current_fiscal_year": "",
"date_format": "dd-mm-yyyy",
"sms_sender_name": "",
"default_item_group": "Default",
"default_stock_uom": "Nos",
"default_valuation_method": "FIFO",
"default_warehouse_type": "Default Warehouse Type",
"tolerance": "",
"acc_frozen_upto": "",
"bde_auth_role": "",
"credit_controller": "",
"default_customer_group": "Default Customer Group",
"default_territory": "Default",
"default_price_list": "Standard",
"default_supplier_type": "Default Supplier Type",
}
from webnotes.model.code import get_obj
gd = get_obj("Global Defaults", "Global Defaults")
for d in flds:
gd.doc.fields[d] = flds[d]
gd.doc.save()
webnotes.clear_cache()
def reset_global_defaults():
flds = {
'default_company': '',
'default_currency': '',
'default_currency_format': 'Lacs',
'default_currency_fraction': '',
'current_fiscal_year': '',
'date_format': 'dd-mm-yyyy',
'sms_sender_name': '',
'default_item_group': 'Default',
'default_stock_uom': 'Nos',
'default_valuation_method': 'FIFO',
'default_warehouse_type': 'Default Warehouse Type',
'tolerance': '',
'acc_frozen_upto': '',
'bde_auth_role': '',
'credit_controller': '',
'default_customer_group': 'Default Customer Group',
'default_territory': 'Default',
'default_price_list': 'Standard',
'default_supplier_type': 'Default Supplier Type'
}
from webnotes.model.code import get_obj
gd = get_obj('Global Defaults', 'Global Defaults')
for d in flds:
gd.doc.fields[d] = flds[d]
gd.doc.save()
webnotes.clear_cache()
def setup_account(self, args):
import webnotes, json
if isinstance(args, basestring):
args = json.loads(args)
webnotes.conn.begin()
self.update_profile_name(args)
add_all_roles_to(webnotes.session.user)
self.create_fiscal_year_and_company(args)
self.set_defaults(args)
create_territories()
self.create_price_lists(args)
self.create_feed_and_todo()
self.create_email_digest()
webnotes.clear_cache()
msgprint(
"Company setup is complete. This page will be refreshed in a moment."
)
webnotes.conn.commit()
return {
'sys_defaults':
get_defaults(),
'user_fullname': (args.get('first_name') or '') +
(args.get('last_name') and (" " + args.get('last_name')) or '')
}
def setup_account(args=None):
# if webnotes.conn.sql("select name from tabCompany"):
# webnotes.throw(_("Setup Already Complete!!"))
if not args:
args = webnotes.local.form_dict
if isinstance(args, basestring):
args = json.loads(args)
args = webnotes._dict(args)
update_profile_name(args)
create_fiscal_year_and_company(args)
set_defaults(args)
create_territories()
create_price_lists(args)
create_feed_and_todo()
create_email_digest()
create_letter_head(args)
create_taxes(args)
create_items(args)
create_customers(args)
create_suppliers(args)
webnotes.conn.set_value('Control Panel', None, 'home_page', 'desktop')
webnotes.clear_cache()
webnotes.conn.commit()
# suppress msgprints
webnotes.local.message_log = []
return "okay"
def create_file_list():
should_exist = [
'Website Settings', 'Web Page', 'Timesheet', 'Task', 'Support Ticket',
'Supplier', 'Style Settings', 'Stock Reconciliation', 'Stock Entry',
'Serial No', 'Sales Order', 'Sales Invoice', 'Quotation', 'Question',
'Purchase Receipt', 'Purchase Order', 'Project', 'Profile',
'Production Order', 'Product', 'Print Format', 'Price List',
'Purchase Invoice', 'Page', 'Maintenance Visit',
'Maintenance Schedule', 'Letter Head', 'Leave Application', 'Lead',
'Journal Voucher', 'Item', 'Purchase Request', 'Expense Claim',
'Opportunity', 'Employee', 'Delivery Note', 'Customer Issue',
'Customer', 'Contact Us Settings', 'Company', 'Bulk Rename Tool',
'Blog', 'BOM', 'About Us Settings'
]
from webnotes.model.code import get_obj
for dt in should_exist:
obj = get_obj('DocType', dt, with_children=1)
obj.doc.allow_attach = 1
obj.doc.save()
obj.make_file_list()
from webnotes.model.db_schema import updatedb
updatedb(obj.doc.name)
webnotes.clear_cache(doctype=obj.doc.name)
def on_update(self): if hasattr(self, 'old_doc_type') and self.old_doc_type: webnotes.clear_cache(doctype=self.old_doc_type) if self.doc.doc_type: webnotes.clear_cache(doctype=self.doc.doc_type) self.export_doc()
def on_update(self): if hasattr(self, 'old_doc_type') and self.old_doc_type: webnotes.clear_cache(doctype=self.old_doc_type) if self.doc.doc_type: webnotes.clear_cache(doctype=self.doc.doc_type) self.export_doc()
def on_update(self):
"""update defaults"""
self.validate_session_expiry()
self.update_control_panel()
for key in keydict:
webnotes.conn.set_default(key,
self.doc.fields.get(keydict[key], ''))
# update year start date and year end date from fiscal_year
ysd = webnotes.conn.sql(
"""select year_start_date from `tabFiscal Year`
where name=%s""", self.doc.current_fiscal_year)
ysd = ysd and ysd[0][0] or ''
from webnotes.utils import get_first_day, get_last_day
if ysd:
webnotes.conn.set_default('year_start_date',
ysd.strftime('%Y-%m-%d'))
webnotes.conn.set_default('year_end_date', \
get_last_day(get_first_day(ysd,0,11)).strftime('%Y-%m-%d'))
# enable default currency
if self.doc.default_currency:
webnotes.conn.set_value("Currency", self.doc.default_currency,
"enabled", 1)
# clear cache
webnotes.clear_cache()
def reset_perms(site=None):
webnotes.connect(site=site)
for d in webnotes.conn.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
webnotes.clear_cache(doctype=d)
webnotes.reset_perms(d)
webnotes.destroy()
def create_custom_field_for_workflow_state(self):
webnotes.clear_cache(doctype=self.doc.document_type)
doctypeobj = webnotes.get_doctype(self.doc.document_type)
if not len(
doctypeobj.get({
"doctype": "DocField",
"fieldname": self.doc.workflow_state_field
})):
# create custom field
webnotes.bean([{
"doctype":
"Custom Field",
"dt":
self.doc.document_type,
"__islocal":
1,
"fieldname":
self.doc.workflow_state_field,
"label":
self.doc.workflow_state_field.replace("_", " ").title(),
"hidden":
1,
"fieldtype":
"Link",
"options":
"Workflow State",
#"insert_after": doctypeobj.get({"doctype":"DocField"})[-1].fieldname
}]).save()
webnotes.msgprint(
"Created Custom Field '%s' in '%s'" %
(self.doc.workflow_state_field, self.doc.document_type))
def on_update(self):
"""update defaults"""
self.validate_session_expiry()
for key in keydict:
webnotes.conn.set_default(key, self.doc.fields.get(keydict[key], ''))
# update year start date and year end date from fiscal_year
ysd = webnotes.conn.sql("""select year_start_date from `tabFiscal Year`
where name=%s""", self.doc.current_fiscal_year)
ysd = ysd and ysd[0][0] or ''
from webnotes.utils import get_first_day, get_last_day
if ysd:
webnotes.conn.set_default('year_start_date', ysd.strftime('%Y-%m-%d'))
webnotes.conn.set_default('year_end_date', \
get_last_day(get_first_day(ysd,0,11)).strftime('%Y-%m-%d'))
# enable default currency
if self.doc.default_currency:
webnotes.conn.set_value("Currency", self.doc.default_currency, "enabled", 1)
# clear cache
webnotes.clear_cache()
def post(self):
"""
Save diff between Customize Form Bean and DocType Bean as property setter entries
"""
if self.doc.doc_type:
from webnotes.model import doc
from webnotes.core.doctype.doctype.doctype import validate_fields_for_doctype
this_doclist = webnotes.doclist([self.doc] + self.doclist)
ref_doclist = self.get_ref_doclist()
dt_doclist = doc.get('DocType', self.doc.doc_type)
# get a list of property setter docs
self.idx_dirty = False
diff_list = self.diff(this_doclist, ref_doclist, dt_doclist)
if self.idx_dirty:
self.make_idx_property_setter(this_doclist, diff_list)
self.set_properties(diff_list)
validate_fields_for_doctype(self.doc.doc_type)
webnotes.clear_cache(doctype=self.doc.doc_type)
webnotes.msgprint("Updated")
def on_rename(self,newdn,olddn, merge=False):
webnotes.clear_cache(user=olddn)
self.validate_rename(newdn, olddn)
tables = webnotes.conn.sql("show tables")
for tab in tables:
desc = webnotes.conn.sql("desc `%s`" % tab[0], as_dict=1)
has_fields = []
for d in desc:
if d.get('Field') in ['owner', 'modified_by']:
has_fields.append(d.get('Field'))
for field in has_fields:
webnotes.conn.sql("""\
update `%s` set `%s`=%s
where `%s`=%s""" % \
(tab[0], field, '%s', field, '%s'), (newdn, olddn))
# set email
webnotes.conn.sql("""\
update `tabProfile` set email=%s
where name=%s""", (newdn, newdn))
# update __Auth table
if not merge:
webnotes.conn.sql("""update __Auth set user=%s where user=%s""", (newdn, olddn))
def on_trash(self):
webnotes.clear_cache(user=self.doc.name)
if self.doc.name in ["Administrator", "Guest"]:
webnotes.msgprint("""Hey! You cannot delete user: %s""" % (self.name, ),
raise_exception=1)
self.a_system_manager_should_exist()
# disable the user and log him/her out
self.doc.enabled = 0
if getattr(webnotes.local, "login_manager", None):
webnotes.local.login_manager.logout(user=self.doc.name)
# delete their password
webnotes.conn.sql("""delete from __Auth where user=%s""", self.doc.name)
# delete todos
webnotes.conn.sql("""delete from `tabToDo` where owner=%s""", self.doc.name)
webnotes.conn.sql("""update tabToDo set assigned_by=null where assigned_by=%s""",
self.doc.name)
# delete events
webnotes.conn.sql("""delete from `tabEvent` where owner=%s
and event_type='Private'""", self.doc.name)
webnotes.conn.sql("""delete from `tabEvent User` where person=%s""", self.doc.name)
# delete messages
webnotes.conn.sql("""delete from `tabComment` where comment_doctype='Message'
and (comment_docname=%s or owner=%s)""", (self.doc.name, self.doc.name))
def setup_account(args=None):
# if webnotes.conn.sql("select name from tabCompany"):
# webnotes.throw(_("Setup Already Complete!!"))
if not args:
args = webnotes.local.form_dict
if isinstance(args, basestring):
args = json.loads(args)
args = webnotes._dict(args)
update_profile_name(args)
create_fiscal_year_and_company(args)
set_defaults(args)
create_territories()
# create_price_lists(args)
create_feed_and_todo()
import_core_docs()
# create_email_digest()
# create_letter_head(args)
# create_taxes(args)
# create_items(args)
# create_customers(args)
# create_suppliers(args)
webnotes.conn.set_value('Control Panel', None, 'home_page', 'desktop')
webnotes.clear_cache()
webnotes.conn.commit()
# suppress msgprints
webnotes.local.message_log = []
exec_in_shell("""cp -r {path}/lib/public/datatable {path}/public/files
""".format(path=get_base_path()))
webnotes.conn.sql(
"CREATE TABLE ack(ENCOUNTER_ID varchar(20),ACK varchar(20))")
return "okay"
def sync_all(force=0):
modules = []
modules += sync_core_doctypes(force)
modules += sync_modules(force)
try:
webnotes.clear_cache()
except Exception, e:
if e[0] != 1146: raise e
def sync_all(force=0):
modules = []
modules += sync_core_doctypes(force)
modules += sync_modules(force)
try:
webnotes.clear_cache()
except Exception, e:
if e[0] != 1146:
raise e
def on_trash(self):
# delete property setter entries
webnotes.conn.sql("""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s""",
(self.doc.dt, self.doc.fieldname))
webnotes.clear_cache(doctype=self.doc.dt)
def on_trash(self):
# delete property setter entries
webnotes.conn.sql(
"""\
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s
AND field_name = %s""", (self.doc.dt, self.doc.fieldname))
webnotes.clear_cache(doctype=self.doc.dt)
def set_as_default(self):
webnotes.conn.set_value("Global Defaults", None, "current_fiscal_year", self.doc.name)
webnotes.get_obj("Global Defaults").on_update()
# clear cache
webnotes.clear_cache()
msgprint(self.doc.name + _(""" is now the default Fiscal Year. \
Please refresh your browser for the change to take effect."""))
def add_default(self, key, val, parent="Control Panel"):
d = webnotes.doc('DefaultValue')
d.parent = parent
d.parenttype = 'Control Panel' # does not matter
d.parentfield = 'system_defaults'
d.defkey = key
d.defvalue = val
d.save(1)
webnotes.clear_cache()
def execute():
webnotes.reload_doc("core", "doctype", "docperm")
# delete same as cancel (map old permissions)
webnotes.conn.sql("""update tabDocPerm set `delete`=ifnull(`cancel`,0)""")
# can't cancel if can't submit
webnotes.conn.sql("""update tabDocPerm set `cancel`=0 where ifnull(`submit`,0)=0""")
webnotes.clear_cache()
def sync_all(force=0):
modules = []
modules += sync_core_doctypes(force)
modules += sync_modules(force)
try:
webnotes.clear_cache()
except Exception, e:
if e.args[0] != 1146:
print webnotes.getTraceback()
raise e
def test_owner_match_report(self):
webnotes.conn.sql("""update tabDocPerm set `restricted`=1 where parent='Blog Post'
and ifnull(permlevel,0)=0""")
webnotes.clear_cache(doctype="Blog Post")
webnotes.set_user("*****@*****.**")
names = [d.name for d in webnotes.get_list("Blog Post", fields=["name", "owner"])]
self.assertTrue("_test-blog-post" in names)
self.assertFalse("_test-blog-post-1" in names)
def set_as_default(self):
webnotes.conn.set_value("Global Defaults", None, "current_fiscal_year",
self.doc.name)
webnotes.get_obj("Global Defaults").on_update()
# clear cache
webnotes.clear_cache()
msgprint(self.doc.name + _(""" is now the default Fiscal Year. \
Please refresh your browser for the change to take effect."""))
def validate(self):
"""delete other property setters on this, if this is new"""
if self.doc.fields['__islocal']:
webnotes.conn.sql("""delete from `tabProperty Setter` where
doctype_or_field = %(doctype_or_field)s
and doc_type = %(doc_type)s
and ifnull(field_name,'') = ifnull(%(field_name)s, '')
and property = %(property)s""", self.doc.fields)
# clear cache
webnotes.clear_cache(doctype = self.doc.doc_type)
def set_default(self, key, val, parent="Control Panel"):
"""set control panel default (tabDefaultVal)"""
if self.sql("""select defkey from `tabDefaultValue` where
defkey=%s and parent=%s """, (key, parent)):
# update
self.sql("""update `tabDefaultValue` set defvalue=%s
where parent=%s and defkey=%s""", (val, parent, key))
webnotes.clear_cache()
else:
self.add_default(key, val, parent)
def validate(self):
"""delete other property setters on this, if this is new"""
if self.doc.fields['__islocal']:
webnotes.conn.sql(
"""delete from `tabProperty Setter` where
doctype_or_field = %(doctype_or_field)s
and doc_type = %(doc_type)s
and ifnull(field_name,'') = ifnull(%(field_name)s, '')
and property = %(property)s""", self.doc.fields)
# clear cache
webnotes.clear_cache(doctype=self.doc.doc_type)
def update_permissions(self, args=''):
args = eval(args)
di = args['perm_dict']
doctype_keys = di.keys() # ['Opportunity','Competitor','Zone','State']
for parent in doctype_keys:
for permlevel in di[parent].keys():
for role in di[parent][permlevel].keys():
if role:
# check if Permissions for that perm level and Role exists
exists = sql(
"select name from tabDocPerm where parent = %s and role = %s and ifnull(permlevel, 0) = %s",
(parent, role, cint(permlevel)))
# Get values of dictionary of Perm Level
pd = di[parent][permlevel][role]
# update
if exists and (1 in pd.values()):
sql(
"update tabDocPerm set `read` = %s, `write` = %s, `create` = %s, `submit` = %s, `cancel` = %s, `amend` = %s, `match`=%s where parent = %s and role = %s and permlevel = %s",
(pd['read'], pd['write'], pd['create'],
pd['submit'], pd['cancel'], pd['amend'],
pd.get('match'), parent, role, permlevel))
# new
elif not exists and (1 in pd.values()):
ch = Document('DocPerm')
ch.parentfield = 'permissions'
ch.parenttype = 'DocType'
ch.parent = parent
ch.role = role
ch.permlevel = cint(permlevel)
for key in pd.keys():
ch.fields[key] = pd.get(key, None)
ch.save(1)
# delete
elif exists and (1 not in pd.values()):
sql(
"delete from tabDocPerm where parent = %s and role = %s and ifnull(permlevel,0) = %s",
(parent, role, cint(permlevel)))
sql(
"update tabDocType set modified = %s where name = %s",
(now(), parent))
webnotes.clear_cache(doctype=parent)
msgprint("Permissions Updated")
def delete(self):
"""
Deletes all property setter entries for the selected doctype
and resets it to standard
"""
if self.doc.doc_type:
webnotes.conn.sql("""
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s""", self.doc.doc_type)
webnotes.clear_cache(doctype=self.doc.doc_type)
self.get()
def clear_cache(parent=None):
def all_profiles():
return webnotes.conn.sql_list("select name from tabProfile") + ["Control Panel", "__global"]
if parent=="Control Panel" or not parent:
parent = all_profiles()
elif isinstance(parent, basestring):
parent = [parent]
for p in parent:
webnotes.cache().delete_value("__defaults:" + p)
webnotes.clear_cache()
def clear_cache(parent=None):
def all_profiles():
return webnotes.conn.sql_list("select name from tabProfile") + ["Control Panel", "__global"]
if parent=="Control Panel" or not parent:
parent = all_profiles()
elif isinstance(parent, basestring):
parent = [parent]
for p in parent:
webnotes.cache().delete_value("__defaults:" + p)
webnotes.clear_cache()
def delete(self):
"""
Deletes all property setter entries for the selected doctype
and resets it to standard
"""
if self.doc.doc_type:
webnotes.conn.sql("""
DELETE FROM `tabProperty Setter`
WHERE doc_type = %s""", self.doc.doc_type)
webnotes.clear_cache(doctype=self.doc.doc_type)
self.get()
def on_update(self): # validate field from core.doctype.doctype.doctype import validate_fields_for_doctype validate_fields_for_doctype(self.doc.dt) webnotes.clear_cache(doctype=self.doc.dt) # create property setter to emulate insert after self.create_property_setter() # update the schema from webnotes.model.db_schema import updatedb updatedb(self.doc.dt)
def on_update(self):
# validate field
from core.doctype.doctype.doctype import validate_fields_for_doctype
validate_fields_for_doctype(self.doc.dt)
webnotes.clear_cache(doctype=self.doc.dt)
# create property setter to emulate insert after
self.create_property_setter()
# update the schema
from webnotes.model.db_schema import updatedb
updatedb(self.doc.dt)
def on_update(self):
from webnotes.model.db_schema import updatedb
updatedb(self.doc.name)
self.change_modified_of_parent()
import conf
from webnotes.modules.import_file import in_import
if (not in_import) and getattr(conf, 'developer_mode', 0):
self.export_doc()
self.make_controller_template()
webnotes.clear_cache(doctype=self.doc.name)
def on_update(self): from webnotes.model.db_schema import updatedb updatedb(self.doc.name) self.change_modified_of_parent() import conf from webnotes.modules.import_file import in_import if (not in_import) and getattr(conf,'developer_mode', 0): self.export_doc() self.make_controller_template() webnotes.clear_cache(doctype=self.doc.name)
def setUp(self):
webnotes.conn.sql("""update tabDocPerm set `restricted`=0 where parent='Blog Post'
and ifnull(permlevel,0)=0""")
webnotes.conn.sql("""update `tabBlog Post` set owner='*****@*****.**'
where name='_test-blog-post'""")
webnotes.clear_cache(doctype="Blog Post")
profile = webnotes.bean("Profile", "*****@*****.**")
profile.get_controller().add_roles("Website Manager")
profile = webnotes.bean("Profile", "*****@*****.**")
profile.get_controller().add_roles("Blogger")
webnotes.set_user("*****@*****.**")
def update_roles(self,arg):
arg = eval(arg)
sql("delete from `tabUserRole` where parenttype='Profile' and parent ='%s'" % (cstr(arg['usr'])))
role_list = arg['role_list'].split(',')
for r in role_list:
pr=Document('UserRole')
pr.parent = arg['usr']
pr.parenttype = 'Profile'
pr.role = r
pr.parentfield = 'userroles'
pr.save(1)
# Update Membership Type at Gateway
from webnotes.utils import cint
webnotes.clear_cache(cstr(arg['usr']))
def update_roles(self,arg):
arg = eval(arg)
sql("delete from `tabUserRole` where parenttype='Profile' and parent ='%s'" % (cstr(arg['usr'])))
role_list = arg['role_list'].split(',')
for r in role_list:
pr=Document('UserRole')
pr.parent = arg['usr']
pr.parenttype = 'Profile'
pr.role = r
pr.parentfield = 'userroles'
pr.save(1)
# Update Membership Type at Gateway
from webnotes.utils import cint
webnotes.clear_cache(cstr(arg['usr']))
def set_series_for(self, doctype, ol):
options = self.scrub_options_list(ol)
# validate names
for i in options:
self.validate_series_name(i)
if self.doc.user_must_always_select:
options = [""] + options
default = ""
else:
default = options[0]
# update in property setter
from webnotes.model.doc import Document
prop_dict = {"options": "\n".join(options), "default": default}
for prop in prop_dict:
ps_exists = webnotes.conn.sql(
"""SELECT name FROM `tabProperty Setter`
WHERE doc_type = %s AND field_name = 'naming_series'
AND property = %s""",
(doctype, prop),
)
if ps_exists:
ps = Document("Property Setter", ps_exists[0][0])
ps.value = prop_dict[prop]
ps.save()
else:
ps = Document(
"Property Setter",
fielddata={
"doctype_or_field": "DocField",
"doc_type": doctype,
"field_name": "naming_series",
"property": prop,
"value": prop_dict[prop],
"property_type": "Select",
},
)
ps.save(1)
self.doc.set_options = "\n".join(options)
webnotes.clear_cache(doctype=doctype)
def on_update(self): self.make_amendable() self.make_file_list() sql = webnotes.conn.sql # make schma changes from webnotes.model.db_schema import updatedb updatedb(self.doc.name) self.change_modified_of_parent() import conf from webnotes.modules.import_merge import in_transfer if (not in_transfer) and getattr(conf,'developer_mode', 0): self.export_doc() webnotes.clear_cache(doctype=self.doc.name)
def on_update(self):
self.make_amendable()
self.make_file_list()
sql = webnotes.conn.sql
# make schma changes
from webnotes.model.db_schema import updatedb
updatedb(self.doc.name)
self.change_modified_of_parent()
import conf
from webnotes.modules.import_merge import in_transfer
if (not in_transfer) and getattr(conf, 'developer_mode', 0):
self.export_doc()
webnotes.clear_cache(doctype=self.doc.name)
def on_update(self):
from webnotes.model.db_schema import updatedb
updatedb(self.doc.name)
self.change_modified_of_parent()
make_module_and_roles(self.doclist)
import conf
if (not webnotes.in_import) and getattr(conf, 'developer_mode', 0):
self.export_doc()
self.make_controller_template()
# update index
if not self.doc.custom:
from webnotes.model.code import load_doctype_module
module = load_doctype_module(self.doc.name, self.doc.module)
if hasattr(module, "on_doctype_update"):
module.on_doctype_update()
webnotes.clear_cache(doctype=self.doc.name)
def __init__(self):
if webnotes.form_dict.get('cmd')=='login':
# clear cache
webnotes.clear_cache(user = webnotes.form_dict.get('usr'))
self.authenticate()
self.post_login()
info = webnotes.conn.get_value("Profile", self.user, ["user_type", "first_name", "last_name"], as_dict=1)
if info.user_type=="Website User":
webnotes._response.set_cookie("system_user", "no")
webnotes.response["message"] = "No App"
else:
webnotes._response.set_cookie("system_user", "yes")
webnotes.response['message'] = 'Logged In'
full_name = " ".join(filter(None, [info.first_name, info.last_name]))
webnotes.response["full_name"] = full_name
webnotes._response.set_cookie("full_name", full_name)
webnotes._response.set_cookie("user_id", self.user)
def post(self):
"""
Save diff between Customize Form ModelWrapper and DocType ModelWrapper as property setter entries
"""
if self.doc.doc_type:
from webnotes.model import doc
from core.doctype.doctype.doctype import validate_fields_for_doctype
this_doclist = webnotes.doclist([self.doc] + self.doclist)
ref_doclist = self.get_ref_doclist()
dt_doclist = doc.get('DocType', self.doc.doc_type)
# get a list of property setter docs
diff_list = self.diff(this_doclist, ref_doclist, dt_doclist)
self.set_properties(diff_list)
validate_fields_for_doctype(self.doc.doc_type)
webnotes.clear_cache(doctype=self.doc.doc_type)
def set_series_for(self, doctype, ol):
options = self.scrub_options_list(ol)
# validate names
for i in options:
self.validate_series_name(i)
if self.doc.user_must_always_select:
options = [''] + options
default = ''
else:
default = options[0]
# update in property setter
from webnotes.model.doc import Document
prop_dict = {'options': "\n".join(options), 'default': default}
for prop in prop_dict:
ps_exists = webnotes.conn.sql(
"""SELECT name FROM `tabProperty Setter`
WHERE doc_type = %s AND field_name = 'naming_series'
AND property = %s""", (doctype, prop))
if ps_exists:
ps = Document('Property Setter', ps_exists[0][0])
ps.value = prop_dict[prop]
ps.save()
else:
ps = Document('Property Setter',
fielddata={
'doctype_or_field': 'DocField',
'doc_type': doctype,
'field_name': 'naming_series',
'property': prop,
'value': prop_dict[prop],
'property_type': 'Select',
})
ps.save(1)
self.doc.set_options = "\n".join(options)
webnotes.clear_cache(doctype=doctype)
def on_update(self):
from webnotes.model.db_schema import updatedb
updatedb(self.doc.name)
self.change_modified_of_parent()
import conf
if (not webnotes.in_import) and getattr(conf, 'developer_mode', 0):
self.export_doc()
self.make_controller_template()
# update index
if not self.doc.custom:
from webnotes.modules import scrub
doctype = scrub(self.doc.name)
module = __import__(scrub(self.doc.module) + ".doctype." +
doctype + "." + doctype,
fromlist=[""])
if hasattr(module, "on_doctype_update"):
module.on_doctype_update()
webnotes.clear_cache(doctype=self.doc.name)
def move_customizations():
import webnotes.model.doc
import webnotes.model.doctype
res = webnotes.conn.sql("""\
delete from `tabProperty Setter`
where property='previous_field'
and doc_type = 'Communication Log'""")
res = webnotes.conn.sql("""\
select name from `tabCustom Field`
where dt='Communication Log'""")
for r in res:
d = webnotes.model.doc.Document('Custom Field', r[0])
d.dt = 'Communication'
d.save()
from webnotes.model.db_schema import updatedb
updatedb('Communication')
res = webnotes.conn.sql("""\
select field_name from `tabProperty Setter`
where doc_type='Communication Log' and field_name is not null""")
doclist = webnotes.model.doctype.get('Communication', 0)
field_list = [d.fieldname for d in doclist if d.doctype == 'DocField']
for r in res:
if r[0] in field_list:
webnotes.conn.sql(
"""\
update `tabProperty Setter`
set doc_type = 'Communication'
where field_name=%s and doc_type='Communication Log'""", r[0])
webnotes.conn.sql("""\
delete from `tabProperty Setter`
where doc_type='Communication Log'""")
webnotes.clear_cache(doctype="Communication")
def __init__(self):
if webnotes.form_dict.get('cmd') == 'login':
# clear cache
webnotes.clear_cache(user=webnotes.form_dict.get('usr'))
self.authenticate()
self.post_login()
info = webnotes.conn.get_value(
"Profile",
self.user, ["user_type", "first_name", "last_name"],
as_dict=1)
if info.user_type == "Website User":
webnotes._response.set_cookie("system_user", "no")
webnotes.response["message"] = "No App"
else:
webnotes._response.set_cookie("system_user", "yes")
webnotes.response['message'] = 'Logged In'
full_name = " ".join(
filter(None, [info.first_name, info.last_name]))
webnotes.response["full_name"] = full_name
webnotes._response.set_cookie("full_name", full_name)
webnotes._response.set_cookie("user_id", self.user)
def on_update(self):
# clear cache on save
webnotes.clear_cache()
