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 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 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 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 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 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 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_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 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 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()
		
		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 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 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 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("[email protected]")

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