def update(self):
		"""extend session expiry"""
		self.data['data']['last_updated'] = webnotes.utils.now()

		# update session in db
		time_diff = None
		last_updated = webnotes.cache().get_value("last_db_session_update:" + self.sid)

		if last_updated:
			time_diff = webnotes.utils.time_diff_in_seconds(webnotes.utils.now(), 
				last_updated)

		if webnotes.session['user'] != 'Guest' and \
			((not time_diff) or (time_diff > 1800)):
			# database persistence is secondary, don't update it too often
			webnotes.conn.sql("""update tabSessions set sessiondata=%s, 
				lastupdate=NOW() where sid=%s""" , (str(self.data['data']), 
				self.data['sid']))
				
			# update timestamp of update
			webnotes.cache().set_value("last_db_session_update:" + self.sid, 
				webnotes.utils.now())

		if webnotes.request.cmd!="webnotes.sessions.clear":
			webnotes.cache().set_value("session:" + self.sid, self.data)

def execute():
    for p in webnotes.conn.sql(
        """select name, recent_documents from 
		tabProfile where ifnull(recent_documents,'')!=''"""
    ):
        if not "~~~" in p[1] and p[1][0] == "[":
            webnotes.cache().set_value("recent:" + p[0], json.loads(p[1]))

def to_cache(doctype, processed, doclist):
    global doctype_cache

    webnotes.cache().set_value(cache_name(doctype, processed), [d.fields for d in doclist])

    if not processed:
        doctype_cache[doctype] = doclist

def load_into_cache(page_name):
	args = prepare_args(page_name)
	if not args:
		return ""
	html = build_html(args)
	webnotes.cache().set_value("page:" + page_name, html)
	return html

	def update(self, force=False):
		"""extend session expiry"""
		self.data['data']['last_updated'] = webnotes.utils.now()
		self.data['data']['lang'] = unicode(webnotes.lang)


		# update session in db
		time_diff = None
		last_updated = webnotes.cache().get_value("last_db_session_update:" + self.sid)

		if last_updated:
			time_diff = webnotes.utils.time_diff_in_seconds(webnotes.utils.now(), 
				last_updated)
		
		if force or (webnotes.session['user'] != 'Guest' and \
			((time_diff==None) or (time_diff > 1800))):
			# database persistence is secondary, don't update it too often
			webnotes.conn.sql("""update tabSessions set sessiondata=%s, 
				lastupdate=NOW() where sid=%s""" , (str(self.data['data']), 
				self.data['sid']))

		if webnotes.form_dict.cmd not in ("webnotes.sessions.clear", "logout"):
			webnotes.cache().set_value("last_db_session_update:" + self.sid, 
				webnotes.utils.now())
			webnotes.cache().set_value("session:" + self.sid, self.data)

    def update(self):
        """extend session expiry"""
        self.data["data"]["last_updated"] = webnotes.utils.now()
        if webnotes.user_lang:
            # user language
            self.data["data"]["lang"] = webnotes.lang

            # update session in db
        time_diff = None
        last_updated = webnotes.cache().get_value("last_db_session_update:" + self.sid)

        if last_updated:
            time_diff = webnotes.utils.time_diff_in_seconds(webnotes.utils.now(), last_updated)

        if webnotes.session["user"] != "Guest" and ((time_diff == None) or (time_diff > 1800)):
            # database persistence is secondary, don't update it too often
            webnotes.conn.sql(
                """update tabSessions set sessiondata=%s, 
				lastupdate=NOW() where sid=%s""",
                (str(self.data["data"]), self.data["sid"]),
            )

        if webnotes.request.cmd not in ("webnotes.sessions.clear", "logout"):
            webnotes.cache().set_value("last_db_session_update:" + self.sid, webnotes.utils.now())
            webnotes.cache().set_value("session:" + self.sid, self.data)

	def clear_single(dt):
		webnotes.cache().delete_value(cache_name(dt, False))
		webnotes.cache().delete_value(cache_name(dt, True))
		webnotes.plugins.clear_cache("DocType", dt)

		if doctype_cache and doctype in doctype_cache:
			del doctype_cache[dt]

def add_post(unit, content, picture, picture_name, parent_post=None):
	access = get_access(unit)
	if not access.get("write"):
		raise webnotes.PermissionError
	
	post = webnotes.bean({
		"doctype":"Post",
		"content": markdown2.markdown(content),
		"unit": unit,
		"parent_post": parent_post or None
	})
	post.ignore_permissions = True
	post.insert()

	if picture_name and picture:
		file_data = save_file(picture_name, picture, "Post", post.doc.name, decode=True)
		post.doc.picture_url = file_data.file_name or file_data.file_url
		webnotes.conn.set_value("Post", post.doc.name, "picture_url", post.doc.picture_url)
	
	post.doc.fields.update(webnotes.conn.get_value("Profile", webnotes.session.user, 
		["first_name", "last_name", "fb_username"], as_dict=True))
	
	webnotes.cache().delete_value("unit_html:" + unit)
	
	return webnotes.get_template("templates/includes/inline_post.html").render({"post":post.doc.fields,
		"write": access.get("write")})

def build_page(page_name):
	if not webnotes.conn:
		webnotes.connect()

	sitemap = get_website_sitemap()
	page_options = sitemap.get(page_name)
	
	if not page_options:
		if page_name=="index":
			# page not found, try home page
			home_page = get_home_page()
			page_options = sitemap.get(home_page)
			if not page_options:
				raise PageNotFoundError
			page_options["page_name"] = home_page
		else:
			raise PageNotFoundError
	else:
		page_options["page_name"] = page_name
	
	basepath = webnotes.utils.get_base_path()
	module = None
	no_cache = False
	
	if page_options.get("controller"):
		module = webnotes.get_module(page_options["controller"])
		no_cache = getattr(module, "no_cache", False)

	# if generator, then load bean, pass arguments
	if page_options.get("is_generator"):
		if not module:
			raise Exception("Generator controller not defined")
		
		name = webnotes.conn.get_value(module.doctype, {
			page_options.get("page_name_field", "page_name"): page_options["page_name"]})
		obj = webnotes.get_obj(module.doctype, name, with_children=True)

		if hasattr(obj, 'get_context'):
			obj.get_context()

		context = webnotes._dict(obj.doc.fields)
		context["obj"] = obj
	else:
		# page
		context = webnotes._dict({ 'name': page_name })
		if module and hasattr(module, "get_context"):
			context.update(module.get_context())
	
	context.update(get_website_settings())

	jenv = webnotes.get_jenv()
	context["base_template"] = jenv.get_template(webnotes.get_config().get("base_template"))
	
	template_name = page_options['template']	
	html = jenv.get_template(template_name).render(context)
	
	if not no_cache:
		webnotes.cache().set_value("page:" + page_name, html)
	return html

def clear_cache(user=None):	
	to_clear = []
	if user:
		to_clear = [user]
	elif webnotes.flags.in_install_app!="webnotes":
		to_clear = webnotes.conn.sql_list("select name from tabProfile")
	for p in to_clear + common_keys:
		webnotes.cache().delete_value("__defaults:" + p)

def get_custom_server_script(doctype):
	custom_script = webnotes.cache().get_value("_server_script:" + doctype)
	if custom_script==None:
		custom_script = webnotes.conn.get_value("Custom Script", {"dt": doctype, "script_type":"Server"}, 
			"script") or ""
		webnotes.cache().set_value("_server_script:" + doctype, custom_script)
		
	return custom_script

def clear_cache(user=None):
	"""clear cache"""
	webnotes.cache().delete_keys("bootinfo:")
	webnotes.cache().delete_keys("doctype:")

	# rebuild a cache for guest
	if webnotes.session:
		webnotes.session['data'] = {}

	def delete_session(self):
		webnotes.cache().delete_value("session:" + self.sid)
                f=open("/tmp/err.log","a")
		f.write(self.sid)
		f.close()
		qry="delete from tabSessions where sid='"+self.sid+"'"		
		if self.sid:
			r = webnotes.conn.sql(qry)

	def insert_session_record(self):
		webnotes.conn.sql("""insert into tabSessions 
			(sessiondata, user, lastupdate, sid, status) 
			values (%s , %s, NOW(), %s, 'Active')""", 
				(str(self.data['data']), self.data['user'], self.data['sid']))
				
		# also add to memcache
		webnotes.cache().set_value("session:" + self.data.sid, self.data)

def clear_sessions(user=None, keep_current=False):
	if not user:
		user = webnotes.session.user
	for sid in webnotes.conn.sql("""select sid from tabSessions where user=%s""", (user,)):
		if keep_current and webnotes.session.sid==sid[0]:
			pass
		else:
			webnotes.cache().delete_value("session:" + sid[0])
			webnotes.conn.sql("""delete from tabSessions where sid=%s""", (sid[0],))

def build_page(page_name):
	context = get_context(page_name)
	
	html = webnotes.get_template(context.base_template_path).render(context)
	
	if can_cache(context.no_cache):
		webnotes.cache().set_value("page:" + page_name, html)
	
	return html

def get_user_time_zone():
    if getattr(webnotes.local, "user_time_zone", None) is None:
        webnotes.local.user_time_zone = webnotes.cache().get_value("time_zone")

    if not webnotes.local.user_time_zone:
        webnotes.local.user_time_zone = webnotes.conn.get_value("Control Panel", None, "time_zone") or "Asia/Calcutta"
        webnotes.cache().set_value("time_zone", webnotes.local.user_time_zone)

    return webnotes.local.user_time_zone

def get_user_time_zone():
	global user_time_zone
	if not user_time_zone:
		user_time_zone = webnotes.cache().get_value("time_zone")
	if not user_time_zone:
		user_time_zone = webnotes.conn.get_value('Control Panel', None, 'time_zone') \
			or 'Asia/Calcutta'
		webnotes.cache().set_value("time_zone", user_time_zone)
	return user_time_zone

def clear_cache(user=None):
	"""clear cache"""
	webnotes.cache().delete_keys("bootinfo:")
	webnotes.cache().delete_keys("doctype:")
	webnotes.cache().delete_keys("session:")
	if webnotes.session:
		webnotes.cache().delete_keys("bootinfo:" + webnotes.session.user)
		if webnotes.session.sid:
			webnotes.cache().delete_keys("session:" + webnotes.session.sid)

	def logout(self, arg='', user=None):
		if not user: user = webnotes.session.user
		self.user = user
		self.run_trigger('on_logout')
		if user in ['[email protected]', 'Administrator']:
			webnotes.conn.sql('delete from tabSessions where sid=%s', webnotes.session.get('sid'))
			webnotes.cache().delete_value("session:" + webnotes.session.get("sid"))
		else:
			from webnotes.sessions import clear_sessions
			clear_sessions(user)