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 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 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 get_defaults_for(parent="Control Panel"):
"""get all defaults"""
defaults = webnotes.cache().get_value("__defaults:" + parent)
if not defaults:
res = webnotes.conn.sql(
"""select defkey, defvalue from `tabDefaultValue`
where parent = %s order by creation""",
parent,
as_dict=1)
defaults = webnotes._dict({})
for d in res:
if d.defkey in defaults:
# listify
if not isinstance(defaults[d.defkey],
list) and defaults[d.defkey] != d.defvalue:
defaults[d.defkey] = [defaults[d.defkey]]
if d.defvalue not in defaults[d.defkey]:
defaults[d.defkey].append(d.defvalue)
elif d.defvalue is not None:
defaults[d.defkey] = d.defvalue
if webnotes.session and parent == webnotes.session.user:
defaults.update(get_defaults_for_match(defaults))
webnotes.cache().set_value("__defaults:" + parent, defaults)
return defaults
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 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 get():
"""get session boot info"""
from webnotes.widgets.notification import get_notification_info_for_boot
bootinfo = None
if not getattr(conf, 'auto_cache_clear', None):
# check if cache exists
bootinfo = webnotes.cache().get_value('bootinfo:' +
webnotes.session.user)
if bootinfo:
bootinfo['from_cache'] = 1
if not bootinfo:
if not webnotes.cache().get_stats():
webnotes.msgprint(
"memcached is not working / stopped. Please start memcached for best results."
)
# if not create it
from webnotes.boot import get_bootinfo
bootinfo = get_bootinfo()
webnotes.cache().set_value('bootinfo:' + webnotes.session.user,
bootinfo)
bootinfo["notification_info"] = get_notification_info_for_boot()
return bootinfo
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 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 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 get_defaults_for(parent="Control Panel"):
"""get all defaults"""
defaults = webnotes.cache().get_value("__defaults:" + parent)
if not defaults:
res = webnotes.conn.sql("""select defkey, defvalue from `tabDefaultValue`
where parent = %s order by creation""", parent, as_dict=1)
defaults = webnotes._dict({})
for d in res:
if d.defkey in defaults:
# listify
if not isinstance(defaults[d.defkey], list) and defaults[d.defkey] != d.defvalue:
defaults[d.defkey] = [defaults[d.defkey]]
if d.defvalue not in defaults[d.defkey]:
defaults[d.defkey].append(d.defvalue)
elif d.defvalue is not None:
defaults[d.defkey] = d.defvalue
if webnotes.session and parent == webnotes.session.user:
defaults.update(get_defaults_for_match(defaults))
webnotes.cache().set_value("__defaults:" + parent, defaults)
return defaults
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 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 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 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 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 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 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_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 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 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 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 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 to_cache(doctype, processed, doclist):
if not doctype_cache:
webnotes.local.doctype_doctype_cache = {}
webnotes.cache().set_value(cache_name(doctype, processed),
[d.fields for d in doclist])
if not processed:
doctype_cache[doctype] = doclist
def to_cache(doctype, processed, doclist):
if not doctype_cache:
webnotes.local.doctype_doctype_cache = {}
webnotes.cache().set_value(cache_name(doctype, processed),
[d.fields for d in doclist])
if not processed:
doctype_cache[doctype] = doclist
def to_cache(doctype, processed, doclist): global doctype_cache import json from webnotes.handler import json_handler webnotes.cache().set_value(cache_name(doctype, processed), [d.fields for d in doclist]) if not processed: doctype_cache[doctype] = doclist
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():
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 to_cache(doctype, processed, doclist):
global doctype_cache
import json
from webnotes.handler import json_handler
webnotes.cache().set_value(cache_name(doctype, processed),
[d.fields for d in doclist])
if not processed:
doctype_cache[doctype] = doclist
def logout(self, arg='', user=None):
if not user: user = webnotes.session.user
self.user = user
self.run_trigger('on_logout')
if user in ['*****@*****.**', '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)
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 build_page(page_name):
if not webnotes.conn:
webnotes.connect()
sitemap_options = webnotes.doc("Website Sitemap", page_name).fields
page_options = webnotes.doc(
"Website Sitemap Config",
sitemap_options.get("website_sitemap_config")).fields.update({
"page_name":
sitemap_options.page_name,
"docname":
sitemap_options.docname
})
if not page_options:
raise PageNotFoundError
else:
page_options["page_name"] = page_name
basepath = webnotes.utils.get_base_path()
no_cache = page_options.get("no_cache")
# if generator, then load bean, pass arguments
if page_options.get("page_or_generator") == "Generator":
doctype = page_options.get("ref_doctype")
obj = webnotes.get_obj(doctype,
page_options["docname"],
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 page_options.get("controller"):
module = webnotes.get_module(page_options.get("controller"))
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_path']
html = jenv.get_template(template_name).render(context)
if not no_cache:
webnotes.cache().set_value("page:" + page_name, html)
return html
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 not (keep_current and webnotes.session.sid == sid[0]):
webnotes.cache().delete_value("session:" + sid[0])
if keep_current:
webnotes.conn.sql('delete from tabSessions where user=%s and sid!=%s', (user,
webnotes.session.sid))
else:
webnotes.conn.sql('delete from tabSessions where user=%s', user)
def update_gravatar(bean, trigger):
import md5
if not bean.doc.user_image:
if bean.doc.fb_username:
bean.doc.user_image = "https://graph.facebook.com/" + bean.doc.fb_username + "/picture"
else:
bean.doc.user_image = "https://secure.gravatar.com/avatar/" + md5.md5(bean.doc.name).hexdigest() \
+ "?d=retro"
webnotes.cache().delete_value(bean.doc.name + ":user_image")
webnotes.cache().delete_value("total_users")
def get_sitemap_options(page_name):
sitemap_options = None
cache_key = "sitemap_options:{}".format(page_name)
if can_cache():
sitemap_options = webnotes.cache().get_value(cache_key)
if not sitemap_options:
sitemap_options = build_sitemap_options(page_name)
if can_cache(sitemap_options.no_cache):
webnotes.cache().set_value(cache_key, sitemap_options)
return sitemap_options
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 logout(self, arg='', user=None):
if not user: user = webnotes.session.user
self.run_trigger('on_logout')
if user in ['*****@*****.**', '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)
if user == webnotes.session.user:
webnotes.add_cookies["full_name"] = ""
webnotes.add_cookies["sid"] = ""
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 build_page(page_name):
if not webnotes.conn:
webnotes.connect()
sitemap_options = webnotes.doc("Website Sitemap", page_name).fields
page_options = webnotes.doc("Website Sitemap Config",
sitemap_options.get("website_sitemap_config")).fields.update({
"page_name":sitemap_options.page_name,
"docname":sitemap_options.docname
})
if not page_options:
raise PageNotFoundError
else:
page_options["page_name"] = page_name
basepath = webnotes.utils.get_base_path()
no_cache = page_options.get("no_cache")
# if generator, then load bean, pass arguments
if page_options.get("page_or_generator")=="Generator":
doctype = page_options.get("ref_doctype")
obj = webnotes.get_obj(doctype, page_options["docname"], 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 page_options.get("controller"):
module = webnotes.get_module(page_options.get("controller"))
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_path']
html = jenv.get_template(template_name).render(context)
if not no_cache:
webnotes.cache().set_value("page:" + page_name, html)
return html
def logout(self, arg="", user=None):
if not user:
user = webnotes.session.user
self.run_trigger("on_logout")
if user in ["*****@*****.**", "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)
if user == webnotes.session.user:
webnotes.add_cookies["full_name"] = ""
webnotes.add_cookies["sid"] = ""
def get_html(page_name):
"""get page html"""
page_name = scrub_page_name(page_name)
html = ''
# load from cache, if auto cache clear is falsy
if not (hasattr(conf, 'auto_cache_clear') and conf.auto_cache_clear or 0):
if not get_page_settings().get(page_name, {}).get("no_cache"):
html = webnotes.cache().get_value("page:" + page_name)
from_cache = True
if not html:
from webnotes.auth import HTTPRequest
webnotes.http_request = HTTPRequest()
#webnotes.connect()
html = load_into_cache(page_name)
from_cache = False
if not html:
html = get_html("404")
if page_name == "error":
html = html.replace("%(error)s", webnotes.getTraceback())
else:
comments = "\n\npage:"+page_name+\
"\nload status: " + (from_cache and "cache" or "fresh")
html += """\n<!-- %s -->""" % webnotes.utils.cstr(comments)
return html
def render_page(page_name):
"""get page html"""
set_content_type(page_name)
if page_name.endswith('.html'):
page_name = page_name[:-5]
html = ''
if not conf.auto_cache_clear:
html = webnotes.cache().get_value("page:" + page_name)
from_cache = True
if not html:
html = build_page(page_name)
from_cache = False
if not html:
raise PageNotFoundError
if page_name == "error":
html = html.replace("%(error)s", webnotes.getTraceback())
elif "text/html" in webnotes._response.headers["Content-Type"]:
comments = "\npage:"+page_name+\
"\nload status: " + (from_cache and "cache" or "fresh")
html += """\n<!-- %s -->""" % webnotes.utils.cstr(comments)
return html
def clear_cache(page_name=None):
if page_name:
delete_page_cache(page_name)
else:
cache = webnotes.cache()
for p in get_all_pages():
cache.delete_value("page:" + p)
def get():
"""get session boot info"""
# check if cache exists
if not getattr(conf, 'auto_cache_clear', None):
cache = webnotes.cache().get_value('bootinfo:' + webnotes.session.user)
if cache:
cache['from_cache'] = 1
return cache
# if not create it
from webnotes.boot import get_bootinfo
bootinfo = get_bootinfo()
webnotes.cache().set_value('bootinfo:' + webnotes.session.user, bootinfo)
return bootinfo
def bundle(no_compress, cms_make=True):
"""concat / minify js files"""
# build js files
check_public()
check_lang()
bundle = Bundle()
bundle.no_compress = no_compress
bundle.make()
webnotes.cache().delete_value("website_routes")
if cms_make:
try:
from startup.event_handlers import on_build
on_build()
except ImportError, e:
pass
def render_page(page_name):
"""get page html"""
page_name = scrub_page_name(page_name)
html = ''
if not (hasattr(conf, 'auto_cache_clear') and conf.auto_cache_clear or 0):
html = webnotes.cache().get_value("page:" + page_name)
from_cache = True
if not html:
from webnotes.auth import HTTPRequest
webnotes.http_request = HTTPRequest()
html = build_page(page_name)
from_cache = False
if not html:
raise PageNotFoundError
if page_name == "error":
html = html.replace("%(error)s", webnotes.getTraceback())
else:
comments = "\n\npage:"+page_name+\
"\nload status: " + (from_cache and "cache" or "fresh")
html += """\n<!-- %s -->""" % webnotes.utils.cstr(comments)
return html
def update_recent(self, dt, dn):
rdl = webnotes.cache().get_value("recent:" + self.name) or []
new_rd = [dt, dn]
# clear if exists
for i in range(len(rdl)):
rd = rdl[i]
if rd == new_rd:
del rdl[i]
break
if len(rdl) > 19:
rdl = rdl[:19]
rdl = [new_rd] + rdl
r = webnotes.cache().set_value("recent:" + self.name, rdl)
def load_profile(self):
d = webnotes.conn.sql("""select email, first_name, last_name,
email_signature, background_image, user_type
from tabProfile where name = %s""",
self.name,
as_dict=1)[0]
if not self.can_read:
self.build_permissions()
d.name = self.name
d.recent = json.dumps(webnotes.cache().get_value("recent:" + self.name)
or [])
d['roles'] = self.get_roles()
d['defaults'] = self.get_defaults()
d['can_create'] = self.can_create
d['can_write'] = self.can_write
d['can_read'] = list(set(self.can_read))
d['can_cancel'] = list(set(self.can_cancel))
d['can_get_report'] = list(set(self.can_get_report))
d['allow_modules'] = self.allow_modules
d['all_read'] = self.all_read
d['can_search'] = list(set(self.can_search))
d['in_create'] = self.in_create
return d
def build_sitemap():
sitemap = {}
config = webnotes.cache().get_value("website_sitemap_config",
build_website_sitemap_config)
sitemap.update(config["pages"])
# pages
for p in config["pages"].values():
if p.get("controller"):
module = webnotes.get_module(p["controller"])
p["no_cache"] = getattr(module, "no_cache", False)
# generators
for g in config["generators"].values():
g["is_generator"] = True
module = webnotes.get_module(g["controller"])
for page_name, name in webnotes.conn.sql(
"""select page_name, name from `tab%s` where
ifnull(%s, 0)=1 and ifnull(page_name, '')!=''""" %
(module.doctype, module.condition_field)):
opts = g.copy()
opts["doctype"] = module.doctype
opts["docname"] = name
opts["no_cache"] = getattr(module, "no_cache", False)
sitemap[page_name] = opts
return sitemap
def read_file(module, doctype, docname, plugin=None, extn="py", cache=False): import os content = None if cache: content = webnotes.cache().get_value(get_cache_key(doctype, docname, extn)) if not content: path = get_path(module, doctype, docname, plugin, extn) if os.path.exists(path): with open(path, 'r') as f: content = f.read() or "Does Not Exist" if cache: webnotes.cache().set_value(get_cache_key(doctype, docname, extn), content) return None if (content == "Does Not Exist") else content
def get_custom_server_script(doctype, plugin=None):
import os, MySQLdb
custom_script = webnotes.cache().get_value("_server_script:" + doctype)
if not custom_script:
try:
script_path = get_custom_server_script_path(doctype, plugin)
if os.path.exists(script_path):
with open(script_path, 'r') as f:
custom_script = f.read()
else:
custom_script = "Does Not Exist"
webnotes.cache().set_value("_server_script:" + doctype, custom_script)
except (webnotes.DoesNotExistError, MySQLdb.OperationalError):
# this happens when syncing
return None
return None if custom_script == "Does Not Exist" else custom_script
def clear_cache(page_name=None):
if page_name:
delete_page_cache(page_name)
else:
cache = webnotes.cache()
for p in webnotes.conn.sql_list("""select name from `tabWebsite Sitemap`"""):
if p is not None:
cache.delete_value("page:" + p)
cache.delete_value("page:index")
cache.delete_value("website_sitemap")
cache.delete_value("website_sitemap_config")
def clear_cache(page_name=None):
if page_name:
delete_page_cache(page_name)
else:
cache = webnotes.cache()
for p in get_all_pages():
if p is not None:
cache.delete_value("page:" + p)
cache.delete_value("page:index")
cache.delete_value("website_sitemap")
cache.delete_value("website_sitemap_config")
