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 add_website_sitemap_config(page_or_generator, app, path, fname, basepath):
name = fname[:-5] if fname.endswith(".html") else fname
wsc = webnotes._dict({
"doctype": "Website Sitemap Config",
"page_or_generator": page_or_generator,
"link_name": name,
"template_path": os.path.relpath(os.path.join(path, fname), basepath),
})
controller_name = fname.split(".")[0].replace("-", "_") + ".py"
controller_path = os.path.join(path, controller_name)
if os.path.exists(controller_path):
wsc.controller = app + "." + os.path.relpath(controller_path[:-3], basepath).replace(os.path.sep, ".")
if wsc.controller:
# verbose print wsc.controller
module = webnotes.get_module(wsc.controller)
wsc.no_cache = getattr(module, "no_cache", 0)
wsc.no_sitemap = wsc.no_cache or getattr(module, "no_sitemap", 0)
wsc.ref_doctype = getattr(module, "doctype", None)
wsc.page_name_field = getattr(module, "page_name_field", "page_name")
wsc.condition_field = getattr(module, "condition_field", None)
wsc.base_template_path = getattr(module, "base_template_path", None)
if webnotes.conn.exists("Website Sitemap Config", wsc.link_name):
# found by earlier app, override
webnotes.conn.sql("""delete from `tabWebsite Sitemap Config` where name=%s""", (wsc.link_name,))
webnotes.bean(wsc).insert()
return name
def get_build_maps():
"""get all build.jsons with absolute paths"""
# framework js and css files
pymodules = [webnotes.get_module(app) for app in webnotes.get_all_apps(True)]
app_paths = [os.path.dirname(pymodule.__file__) for pymodule in pymodules]
build_maps = {}
for app_path in app_paths:
path = os.path.join(app_path, 'public', 'build.json')
if os.path.exists(path):
with open(path) as f:
try:
for target, sources in json.loads(f.read()).iteritems():
# update app path
source_paths = []
for source in sources:
if isinstance(source, list):
s = webnotes.get_pymodule_path(source[0], *source[1].split("/"))
else:
s = os.path.join(app_path, source)
source_paths.append(s)
build_maps[target] = source_paths
except Exception, e:
print path
raise
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 run_unittest(doctype, verbose=False):
module = webnotes.conn.get_value("DocType", doctype, "module")
test_module = get_module_name(doctype, module, "test_")
make_test_records(doctype, verbose=verbose)
test_suite = unittest.TestSuite()
module = webnotes.get_module(test_module)
test_suite.addTest(unittest.TestLoader().loadTestsFromModule(module))
return unittest.TextTestRunner(verbosity=1+(verbose and 1 or 0)).run(test_suite)
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 build_context(sitemap_options):
"""get_context method of bean or module is supposed to render content templates and push it into context"""
context = webnotes._dict({ "_": webnotes._ })
context.update(sitemap_options)
context.update(get_website_settings())
if sitemap_options.get("controller"):
module = webnotes.get_module(sitemap_options.get("controller"))
if module and hasattr(module, "get_context"):
context.data = module.get_context(context) or {}
return context
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)
p["no_sitemap"] = getattr(module, "no_sitemap",
False) or p["no_cache"]
# generators
for g in config["generators"].values():
g["is_generator"] = True
module = webnotes.get_module(g["controller"])
condition = ""
page_name_field = "page_name"
if hasattr(module, "page_name_field"):
page_name_field = module.page_name_field
if hasattr(module, "condition_field"):
condition = " where ifnull(%s, 0)=1" % module.condition_field
for page_name, name, modified in webnotes.conn.sql(
"""select %s, name, modified from
`tab%s` %s""" % (page_name_field, module.doctype, condition)):
opts = g.copy()
opts["doctype"] = module.doctype
opts["no_cache"] = getattr(module, "no_cache", False)
opts["page_name"] = page_name
if page_name_field != "page_name":
opts["page_name_field"] = page_name_field
opts["docname"] = name
opts["lastmod"] = modified.strftime("%Y-%m-%d %H:%M:%S")
sitemap[page_name] = opts
return sitemap
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 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)
p["no_sitemap"] = getattr(module, "no_sitemap", False) or p["no_cache"]
# generators
for g in config["generators"].values():
g["is_generator"] = True
module = webnotes.get_module(g["controller"])
condition = ""
page_name_field = "page_name"
if hasattr(module, "page_name_field"):
page_name_field = module.page_name_field
if hasattr(module, "condition_field"):
condition = " where ifnull(%s, 0)=1" % module.condition_field
for page_name, name, modified in webnotes.conn.sql("""select %s, name, modified from
`tab%s` %s""" % (page_name_field, module.doctype, condition)):
opts = g.copy()
opts["doctype"] = module.doctype
opts["no_cache"] = getattr(module, "no_cache", False)
opts["page_name"] = page_name
if page_name_field != "page_name":
opts["page_name_field"] = page_name_field
opts["docname"] = name
opts["lastmod"] = modified.strftime("%Y-%m-%d %H:%M:%S")
sitemap[page_name] = opts
return sitemap
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 make_asset_dirs(): assets_path = os.path.join(webnotes.local.sites_path, "assets") site_public_path = os.path.join(webnotes.local.site_path, 'public') for dir_path in [ os.path.join(assets_path, 'js'), os.path.join(assets_path, 'css')]: if not os.path.exists(dir_path): os.makedirs(dir_path) # symlink app/public > assets/app for app_name in webnotes.get_all_apps(True): pymodule = webnotes.get_module(app_name) source = os.path.join(os.path.abspath(os.path.dirname(pymodule.__file__)), 'public') target = os.path.join(assets_path, app_name) if not os.path.exists(target) and os.path.exists(source): os.symlink(os.path.abspath(source), target)
def add_website_sitemap_config(page_or_generator, path, fname,
existing_configs):
basepath = webnotes.utils.get_base_path()
template_path = os.path.relpath(os.path.join(path, fname), basepath)
lastmod = int(os.path.getmtime(template_path))
name = fname[:-5] if fname.endswith(".html") else fname
config_lastmod = existing_configs.get(name)
if str(config_lastmod) != str(lastmod):
webnotes.delete_doc("Website Sitemap Config", name)
else:
return name
# already exists and safe
wsc = webnotes._dict({
"doctype": "Website Sitemap Config",
"page_or_generator": page_or_generator,
"link_name": name,
"template_path": template_path,
"lastmod": lastmod
})
controller_name = fname.split(".")[0].replace("-", "_") + ".py"
controller_path = os.path.join(path, controller_name)
if os.path.exists(controller_path):
wsc.controller = os.path.relpath(controller_path[:-3],
basepath).replace(os.path.sep, ".")
wsc.controller = ".".join(wsc.controller.split(".")[1:])
if wsc.controller:
module = webnotes.get_module(wsc.controller)
wsc.no_cache = getattr(module, "no_cache", 0)
wsc.no_sitemap = wsc.no_cache or getattr(module, "no_sitemap", 0)
wsc.ref_doctype = getattr(module, "doctype", None)
wsc.page_name_field = getattr(module, "page_name_field", "page_name")
wsc.condition_field = getattr(module, "condition_field", None)
webnotes.bean(wsc).insert()
return name
def add_website_sitemap_config(page_or_generator, path, fname, existing_configs):
basepath = webnotes.utils.get_base_path()
template_path = os.path.relpath(os.path.join(path, fname), basepath)
lastmod = int(os.path.getmtime(template_path))
name = fname[:-5] if fname.endswith(".html") else fname
config_lastmod = existing_configs.get(name)
if str(config_lastmod) != str(lastmod):
webnotes.delete_doc("Website Sitemap Config", name)
else:
return name
# already exists and safe
wsc = webnotes._dict({
"doctype": "Website Sitemap Config",
"page_or_generator": page_or_generator,
"link_name": name,
"template_path": template_path,
"lastmod": lastmod
})
controller_name = fname.split(".")[0].replace("-", "_") + ".py"
controller_path = os.path.join(path, controller_name)
if os.path.exists(controller_path):
wsc.controller = os.path.relpath(controller_path[:-3], basepath).replace(os.path.sep, ".")
wsc.controller = ".".join(wsc.controller.split(".")[1:])
if wsc.controller:
module = webnotes.get_module(wsc.controller)
wsc.no_cache = getattr(module, "no_cache", 0)
wsc.no_sitemap = wsc.no_cache or getattr(module, "no_sitemap", 0)
wsc.ref_doctype = getattr(module, "doctype", None)
wsc.page_name_field = getattr(module, "page_name_field", "page_name")
wsc.condition_field = getattr(module, "condition_field", None)
webnotes.bean(wsc).insert()
return name
def load_doctype_module(doctype, module=None, prefix=""): if not module: module = get_doctype_module(doctype) return webnotes.get_module(get_module_name(doctype, module, prefix))
def get_handler(group_type):
handler = webnotes.get_hooks("website_group_handler:{}".format(group_type))
if handler:
return webnotes.get_module(handler[0])
def sync_for(app_name, force=0, sync_everything = False, verbose=False): for module_name in webnotes.local.app_modules[app_name]: folder = os.path.dirname(webnotes.get_module(app_name + "." + module_name).__file__) walk_and_sync(folder, force, sync_everything, verbose=verbose)
def build_page(page_name):
from jinja2 import Environment, FileSystemLoader
from markdown2 import markdown
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_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 = Environment(loader=FileSystemLoader(basepath))
jenv.filters["markdown"] = markdown
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
