def prepare(theme):
for d in default_properties:
if not theme.get(d):
theme.set(d, default_properties[d])
theme.footer_border_color = get_shade(theme.footer_color, 10)
theme.border_color = get_shade(theme.background_color, 10)
webfonts = list(
set(
theme.get(key) for key in ("heading_webfont", 'text_webfont')
if theme.get(key)))
theme.webfont_import = "\n".join('@import url(@import url(http://fonts.googleapis.com/css?family={0}:400,300,400italic,700&subset=latin,latin-ext);)'\
.format(font.replace(" ", "+")) for font in webfonts)
# move @import from css field to the top of the css file
if theme.css:
if "@import url" in theme.css:
webfont_import = list(
set(re.findall("@import url\([^\(\)]*\);", theme.css)))
theme.webfont_import += "\n" + "\n".join(webfont_import)
for wfimport in webfont_import:
theme.css = theme.css.replace(wfimport, "")
theme.css = frappe.get_jenv().from_string(theme.css)
def build_page(path):
if not getattr(frappe.local, "path", None):
frappe.local.path = path
context = get_context(path)
if context.source:
html = frappe.render_template(context.source, context)
elif context.template:
if path.endswith('min.js'):
html = frappe.get_jloader().get_source(frappe.get_jenv(),
context.template)[0]
else:
html = frappe.get_template(context.template).render(context)
if '{index}' in html:
html = html.replace('{index}', get_toc(context.route))
if '{next}' in html:
html = html.replace('{next}', get_next_link(context.route))
# html = frappe.get_template(context.base_template_path).render(context)
if can_cache(context.no_cache):
page_cache = frappe.cache().hget("website_page", path) or {}
page_cache[frappe.local.lang] = html
frappe.cache().hset("website_page", path, page_cache)
return html
def build_page(path):
if not getattr(frappe.local, "path", None):
frappe.local.path = path
context = get_context(path)
if context.source:
html = frappe.render_template(context.source, context)
elif context.template:
if path.endswith('min.js'):
html = frappe.get_jloader().get_source(frappe.get_jenv(), context.template)[0]
else:
html = frappe.get_template(context.template).render(context)
if '{index}' in html:
html = html.replace('{index}', get_toc(context.route))
if '{next}' in html:
html = html.replace('{next}', get_next_link(context.route))
# html = frappe.get_template(context.base_template_path).render(context)
if can_cache(context.no_cache):
page_cache = frappe.cache().hget("website_page", path) or {}
page_cache[frappe.local.lang] = html
frappe.cache().hset("website_page", path, page_cache)
return html
def validate(self):
jenv = frappe.get_jenv()
try:
route = resolve_route(get_path_without_slash(self.web_route))
except Exception:
frappe.throw(frappe.get_traceback(),
title=_(f"Please recheck the path: {self.web_route}"))
if not route:
self.validate_new_file()
return
route.route = get_path_without_slash(self.web_route)
route.path = route.route
route = build_context(route)
if route.page_or_generator == "Generator":
self.orignal_code = get_source_generator(route, jenv)
self.orignal_preview_store = self.orignal_code
self.new_preview_store = self.new_code
elif route.page_or_generator == "Page":
self.orignal_code = jenv.loader.get_source(jenv, route.template)[0]
old_html = self.orignal_code
new_html = self.new_code
if route.template.endswith(".md"):
old_html = frappe.utils.md_to_html(self.orignal_code)
new_html = frappe.utils.md_to_html(self.new_code)
self.orignal_preview_store = clean_js_css(route, old_html, jenv)
self.new_preview_store = clean_js_css(route, old_html, jenv)
self.set_diff()
def get_code(route):
resolved_route = resolve_route(get_path_without_slash(route))
jenv = frappe.get_jenv()
if not resolved_route:
return ""
return get_source(resolved_route, jenv)
def setup_source(page_info):
'''Get the HTML source of the template'''
jenv = frappe.get_jenv()
source = jenv.loader.get_source(jenv, page_info.template)[0]
html = ''
if page_info.template.endswith(('.md', '.html')):
# extract frontmatter block if exists
try:
# values will be used to update page_info
res = get_frontmatter(source)
if res['attributes']:
page_info.update(res['attributes'])
source = res['body']
except Exception:
pass
if page_info.template.endswith('.md'):
source = frappe.utils.md_to_html(source)
page_info.page_toc_html = source.toc_html
if not page_info.show_sidebar:
source = '<div class="from-markdown">' + source + '</div>'
if not page_info.base_template:
page_info.base_template = get_base_template(page_info.route)
if page_info.template.endswith(('.html', '.md', )) and \
'{%- extends' not in source and '{% extends' not in source:
# set the source only if it contains raw content
html = source
# load css/js files
js, css = '', ''
js_path = os.path.join(page_info.basepath, (page_info.basename or 'index') + '.js')
if os.path.exists(js_path):
if not '{% block script %}' in html:
with io.open(js_path, 'r', encoding = 'utf-8') as f:
js = f.read()
html += '\n{% block script %}<script>' + js + '\n</script>\n{% endblock %}'
css_path = os.path.join(page_info.basepath, (page_info.basename or 'index') + '.css')
if os.path.exists(css_path):
if not '{% block style %}' in html:
with io.open(css_path, 'r', encoding='utf-8') as f:
css = f.read()
html += '\n{% block style %}\n<style>\n' + css + '\n</style>\n{% endblock %}'
if html:
page_info.source = html
page_info.base_template = page_info.base_template or 'templates/web.html'
else:
page_info.source = ''
# show table of contents
setup_index(page_info)
def set_vars(self):
self.jenv = frappe.get_jenv()
repository = frappe.get_all("Repository", [["enabled", "=", "1"]])
if not repository:
frappe.throw(
"No active repositories found, contact System Manager")
self.app = repository[0]["name"]
self.repository = frappe.get_doc("Repository", self.app)
self.uuid = frappe.generate_hash()
self.repository_base_path = f"{os.getcwd()}/{frappe.local.site}/private/edit_docs/{self.uuid}"
def render_blocks(template_path, out, context): """Build the template block by block from the main template.""" env = frappe.get_jenv() source = frappe.local.jloader.get_source(frappe.local.jenv, template_path)[0] for referenced_template_path in meta.find_referenced_templates(env.parse(source)): if referenced_template_path: render_blocks(referenced_template_path, out, context) template = frappe.get_template(template_path) for block, render in template.blocks.items(): new_context = template.new_context(context) out[block] = concat(render(new_context))
def render_blocks(template_path, out, context): """Build the template block by block from the main template.""" env = frappe.get_jenv() source = frappe.local.jloader.get_source(frappe.local.jenv, template_path)[0] for referenced_template_path in meta.find_referenced_templates(env.parse(source)): if referenced_template_path: render_blocks(referenced_template_path, out, context) template = frappe.get_template(template_path) for block, render in template.blocks.items(): new_context = template.new_context(context) out[block] = concat(render(new_context))
def validate(self):
if self.standard=="Yes" and frappe.session.user != "Administrator":
frappe.throw(frappe._("Standard Print Format cannot be updated"))
# old_doc_type is required for clearing item cache
self.old_doc_type = frappe.db.get_value('Print Format',
self.name, 'doc_type')
jenv = frappe.get_jenv()
try:
jenv.from_string(self.html)
except TemplateSyntaxError:
frappe.throw(frappe._("Syntax error in Jinja template"))
def validate(self):
if self.standard == "Yes" and frappe.session.user != "Administrator":
frappe.throw(frappe._("Standard Print Format cannot be updated"))
# old_doc_type is required for clearing item cache
self.old_doc_type = frappe.db.get_value('Print Format', self.name,
'doc_type')
jenv = frappe.get_jenv()
try:
jenv.from_string(self.html)
except TemplateSyntaxError:
frappe.throw(frappe._("Syntax error in Jinja template"))
def get_html(doc,
name=None,
print_format=None,
meta=None,
no_letterhead=None,
trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(
frappe.db.get_single_value("Print Settings", "with_letterhead"))
if isinstance(doc, basestring) and isinstance(name, basestring):
doc = frappe.get_doc(doc, name)
if isinstance(doc, basestring):
doc = frappe.get_doc(json.loads(doc))
doc.in_print = True
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
if print_format in ("Standard", standard_format):
template = jenv.get_template("templates/print_formats/standard.html")
else:
template = jenv.from_string(get_print_format(doc.doctype,
print_format))
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": get_letter_head(doc, no_letterhead)
}
html = template.render(args, filters={"len": len})
return html
def render_blocks(context):
"""returns a dict of block name and its rendered content"""
out = {}
env = frappe.get_jenv()
def _render_blocks(template_path):
source = frappe.local.jloader.get_source(frappe.local.jenv, template_path)[0]
for referenced_template_path in meta.find_referenced_templates(env.parse(source)):
if referenced_template_path:
_render_blocks(referenced_template_path)
template = frappe.get_template(template_path)
for block, render in template.blocks.items():
out[block] = scrub_relative_urls(concat(render(template.new_context(context))))
_render_blocks(context["template_path"])
# default blocks if not found
if "title" not in out and out.get("header"):
out["title"] = out["header"]
if "title" not in out:
out["title"] = context.get("title")
if "header" not in out and out.get("title"):
out["header"] = out["title"]
if not out["header"].startswith("<h"):
out["header"] = "<h2>" + out["header"] + "</h2>"
if "breadcrumbs" not in out:
out["breadcrumbs"] = scrub_relative_urls(
frappe.get_template("templates/includes/breadcrumbs.html").render(context))
if "<!-- no-sidebar -->" in out.get("content", ""):
out["no_sidebar"] = 1
if "sidebar" not in out and not out.get("no_sidebar"):
out["sidebar"] = scrub_relative_urls(
frappe.get_template("templates/includes/sidebar.html").render(context))
out["title"] = strip_html(out.get("title") or "")
# remove style and script tags from blocks
out["style"] = re.sub("</?style[^<>]*>", "", out.get("style") or "")
out["script"] = re.sub("</?script[^<>]*>", "", out.get("script") or "")
return out
def get_html(doc, name=None, print_format=None, meta=None,
no_letterhead=None, trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(frappe.db.get_single_value("Print Settings", "with_letterhead"))
if isinstance(doc, basestring) and isinstance(name, basestring):
doc = frappe.get_doc(doc, name)
if isinstance(doc, basestring):
doc = frappe.get_doc(json.loads(doc))
doc.in_print = True
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
if print_format in ("Standard", standard_format):
template = jenv.get_template("templates/print_formats/standard.html")
else:
template = jenv.from_string(get_print_format(doc.doctype,
print_format))
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": get_letter_head(doc, no_letterhead)
}
html = template.render(args, filters={"len": len})
return html
def setup_source(page_info):
'''Get the HTML source of the template'''
jenv = frappe.get_jenv()
source = jenv.loader.get_source(jenv, page_info.template)[0]
html = ''
if page_info.template.endswith('.md'):
source = frappe.utils.md_to_html(source)
if not page_info.show_sidebar:
source = '<div class="from-markdown">' + source + '</div>'
# if only content
if page_info.template.endswith('.html') or page_info.template.endswith(
'.md'):
if ('</body>' not in source) and ('{% block' not in source):
page_info.only_content = True
html = '{% extends "templates/web.html" %}'
html += '\n{% block page_content %}\n' + source + '\n{% endblock %}'
else:
html = source
# load css/js files
js, css = '', ''
js_path = os.path.join(page_info.basepath,
(page_info.basename or 'index') + '.js')
if os.path.exists(js_path):
if not '{% block script %}' in html:
with io.open(js_path, 'r', encoding='utf-8') as f:
js = f.read()
html += '\n{% block script %}<script>' + js + '\n</script>\n{% endblock %}'
css_path = os.path.join(page_info.basepath,
(page_info.basename or 'index') + '.css')
if os.path.exists(css_path):
if not '{% block style %}' in html:
with io.open(css_path, 'r', encoding='utf-8') as f:
css = f.read()
html += '\n{% block style %}\n<style>\n' + css + '\n</style>\n{% endblock %}'
page_info.source = html
# show table of contents
setup_index(page_info)
def validate(self):
if (self.standard=="Yes"
and not frappe.local.conf.get("developer_mode")
and not (frappe.flags.in_import or frappe.flags.in_test)):
frappe.throw(frappe._("Standard Print Format cannot be updated"))
# old_doc_type is required for clearing item cache
self.old_doc_type = frappe.db.get_value('Print Format',
self.name, 'doc_type')
if self.html:
jenv = frappe.get_jenv()
try:
jenv.from_string(self.html)
except TemplateSyntaxError, e:
frappe.msgprint('Line {}: {}'.format(e.lineno, e.message))
frappe.throw(frappe._("Syntax error in Jinja template"))
def add_embedded_js(doc):
"""embed all require files"""
import re, os
from frappe import conf
js = doc.fields.get('__js') or ''
# custom script
custom = frappe.db.get_value("Custom Script", {
"dt": doc.name,
"script_type": "Client"
}, "script") or ""
js = (js + '\n' + custom).encode("utf-8")
if "{% include" in js:
js = frappe.get_jenv().from_string(js).render()
doc.fields["__js"] = js
def render_blocks(context):
"""returns a dict of block name and its rendered content"""
out = {}
env = frappe.get_jenv()
def _render_blocks(template_path):
source = frappe.local.jloader.get_source(frappe.local.jenv,
template_path)[0]
for referenced_template_path in meta.find_referenced_templates(
env.parse(source)):
if referenced_template_path:
_render_blocks(referenced_template_path)
template = frappe.get_template(template_path)
for block, render in template.blocks.items():
out[block] = scrub_relative_urls(
concat(render(template.new_context(context))))
_render_blocks(context["template_path"])
# default blocks if not found
if "title" not in out:
out["title"] = context.get("title")
if "header" not in out:
out["header"] = out["title"]
if not out["header"].startswith("<h"):
out["header"] = "<h2>" + out["header"] + "</h2>"
if "breadcrumbs" not in out:
out["breadcrumbs"] = scrub_relative_urls(
frappe.get_template("templates/includes/breadcrumbs.html").render(
context))
if "sidebar" not in out:
out["sidebar"] = scrub_relative_urls(
frappe.get_template("templates/includes/sidebar.html").render(
context))
return out
def setup_source(page_info):
'''Get the HTML source of the template'''
from markdown2 import markdown
jenv = frappe.get_jenv()
source = jenv.loader.get_source(jenv, page_info.template)[0]
html = ''
if page_info.template.endswith('.md'):
source = markdown(source)
# if only content
if page_info.template.endswith('.html') or page_info.template.endswith(
'.md'):
if ('</body>' not in source) and ('{% block' not in source):
page_info.only_content = True
js, css = '', ''
js_path = os.path.join(page_info.basepath,
page_info.basename + '.js')
if os.path.exists(js_path):
js = unicode(open(js_path, 'r').read(), 'utf-8')
css_path = os.path.join(page_info.basepath,
page_info.basename + '.css')
if os.path.exists(css_path):
css = unicode(open(css_path, 'r').read(), 'utf-8')
html = '{% extends "templates/web.html" %}'
if css:
html += '\n{% block style %}\n<style>\n' + css + '\n</style>\n{% endblock %}'
html += '\n{% block page_content %}\n' + source + '\n{% endblock %}'
if js:
html += '\n{% block script %}<script>' + js + '\n</script>\n{% endblock %}'
else:
html = source
page_info.source = html
# show table of contents
setup_index(page_info)
def setup_source(page_info):
'''Get the HTML source of the template'''
jenv = frappe.get_jenv()
source = jenv.loader.get_source(jenv, page_info.template)[0]
html = ''
if page_info.template.endswith('.md'):
source = frappe.utils.md_to_html(source)
if not page_info.show_sidebar:
source = '<div class="from-markdown">' + source + '</div>'
# if only content
if page_info.template.endswith('.html') or page_info.template.endswith('.md'):
if ('</body>' not in source) and ('{% block' not in source):
page_info.only_content = True
html = '{% extends "templates/web.html" %}'
html += '\n{% block page_content %}\n' + source + '\n{% endblock %}'
else:
html = source
# load css/js files
js, css = '', ''
js_path = os.path.join(page_info.basepath, (page_info.basename or 'index') + '.js')
if os.path.exists(js_path):
if not '{% block script %}' in html:
with io.open(js_path, 'r', encoding = 'utf-8') as f:
js = f.read()
html += '\n{% block script %}<script>' + js + '\n</script>\n{% endblock %}'
css_path = os.path.join(page_info.basepath, (page_info.basename or 'index') + '.css')
if os.path.exists(css_path):
if not '{% block style %}' in html:
with io.open(css_path, 'r', encoding='utf-8') as f:
css = f.read()
html += '\n{% block style %}\n<style>\n' + css + '\n</style>\n{% endblock %}'
page_info.source = html
# show table of contents
setup_index(page_info)
def validate(self):
if (self.standard=="Yes"
and not frappe.local.conf.get("developer_mode")
and not (frappe.flags.in_import or frappe.flags.in_test)):
frappe.throw(frappe._("Standard Print Format cannot be updated"))
# old_doc_type is required for clearing item cache
self.old_doc_type = frappe.db.get_value('Print Format',
self.name, 'doc_type')
self.extract_images()
if self.html:
jenv = frappe.get_jenv()
try:
jenv.from_string(self.html)
except TemplateSyntaxError, e:
frappe.msgprint('Line {}: {}'.format(e.lineno, e.message))
frappe.throw(frappe._("Syntax error in Jinja template"))
def setup_source(page_info):
'''Get the HTML source of the template'''
from markdown2 import markdown
jenv = frappe.get_jenv()
source = jenv.loader.get_source(jenv, page_info.template)[0]
html = ''
if page_info.template.endswith('.md'):
source = markdown(source)
# if only content
if page_info.template.endswith('.html') or page_info.template.endswith('.md'):
if ('</body>' not in source) and ('{% block' not in source):
page_info.only_content = True
js, css = '', ''
js_path = os.path.join(page_info.basepath, page_info.basename + '.js')
if os.path.exists(js_path):
js = unicode(open(js_path, 'r').read(), 'utf-8')
css_path = os.path.join(page_info.basepath, page_info.basename + '.css')
if os.path.exists(css_path):
css = unicode(open(css_path, 'r').read(), 'utf-8')
html = '{% extends "templates/web.html" %}'
if css:
html += '\n{% block style %}\n<style>\n' + css + '\n</style>\n{% endblock %}'
html += '\n{% block page_content %}\n' + source + '\n{% endblock %}'
if js:
html += '\n{% block script %}<script>' + js + '\n</script>\n{% endblock %}'
else:
html = source
page_info.source = html
# show table of contents
setup_index(page_info)
def preview(content, path, attachments="{}"):
raw_edited_content = content
attachments = json.loads(attachments)
for attachment in attachments:
if attachment.get("save_path"):
content = content.replace(attachment.get("save_path"),
attachment.get("file_url"))
try:
resolved_route = resolve_route(get_path_without_slash(path))
except Exception:
frappe.throw(frappe.get_traceback(),
title=_(f"Please recheck the path: {path}"))
if not resolved_route:
return {
"diff": diff("", content),
"html": frappe.utils.md_to_html(content)
}
resolved_route.route = get_path_without_slash(path)
resolved_route.path = resolved_route.route
resolved_route = build_context(resolved_route)
jenv = frappe.get_jenv()
old_code_md = get_source(resolved_route, jenv)
if resolved_route.page_or_generator == "Page":
if resolved_route.template.endswith(".md"):
content = frappe.utils.md_to_html(content)
old_code = frappe.utils.md_to_html(old_code_md)
content = clean_js_css(resolved_route, content, jenv)
return {"diff": diff(old_code_md, raw_edited_content), "html": content}
def render_blocks(context):
"""returns a dict of block name and its rendered content"""
out = {}
env = frappe.get_jenv()
def _render_blocks(template_path):
source = frappe.local.jloader.get_source(frappe.local.jenv,
template_path)[0]
for referenced_template_path in meta.find_referenced_templates(
env.parse(source)):
if referenced_template_path:
_render_blocks(referenced_template_path)
template = frappe.get_template(template_path)
for block, render in template.blocks.items():
out[block] = scrub_relative_urls(
concat(render(template.new_context(context))))
_render_blocks(context["template"])
# default blocks if not found
if "title" not in out and out.get("header"):
out["title"] = out["header"]
if "title" not in out:
out["title"] = context.get("title")
if "header" not in out and out.get("title"):
out["header"] = out["title"]
if out.get("header") and not out["header"].startswith("<h"):
out["header"] = "<h2>" + out["header"] + "</h2>"
if "breadcrumbs" not in out:
out["breadcrumbs"] = scrub_relative_urls(
frappe.get_template("templates/includes/breadcrumbs.html").render(
context))
if "meta_block" not in out:
out["meta_block"] = frappe.get_template(
"templates/includes/meta_block.html").render(context)
out["no_sidebar"] = context.get("no_sidebar", 0)
if "<!-- no-sidebar -->" in out.get("content", ""):
out["no_sidebar"] = 1
if "<!-- title:" in out.get("content", ""):
out["title"] = re.findall('<!-- title:([^>]*) -->',
out.get("content"))[0].strip()
if "{index}" in out.get("content", "") and context.get("children"):
html = frappe.get_template(
"templates/includes/static_index.html").render(
{"items": context["children"]})
out["content"] = out["content"].replace("{index}", html)
if "{next}" in out.get("content", ""):
next_item = context.doc.get_next()
if next_item:
if next_item.name[0] != "/": next_item.name = "/" + next_item.name
html = '''<p><br><a href="{name}" class="btn btn-primary">
{title} <i class="icon-chevron-right"></i></a>
</p>'''.format(**next_item)
out["content"] = out["content"].replace("{next}", html)
if "sidebar" not in out and not out.get("no_sidebar"):
out["sidebar"] = scrub_relative_urls(
frappe.get_template("templates/includes/sidebar.html").render(
context))
out["title"] = strip_html(out.get("title") or "")
# remove style and script tags from blocks
out["style"] = re.sub("</?style[^<>]*>", "", out.get("style") or "")
out["script"] = re.sub("</?script[^<>]*>", "", out.get("script") or "")
return out
def get_html(doc,
name=None,
print_format=None,
meta=None,
no_letterhead=None,
trigger_print=False):
print_settings = frappe.db.get_singles_dict("Print Settings")
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(print_settings.with_letterhead)
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if doc.meta.is_submittable:
if doc.docstatus == 0 and not cint(
print_settings.allow_print_for_draft):
frappe.throw(_("Not allowed to print draft documents"),
frappe.PermissionError)
if doc.docstatus == 2 and not cint(
print_settings.allow_print_for_cancelled):
frappe.throw(_("Not allowed to print cancelled documents"),
frappe.PermissionError)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format:
doc._show_section_headings = print_format.show_section_headings
doc._line_breaks = print_format.line_breaks
doc._align_labels_left = print_format.align_labels_left
def get_template_from_string():
return jenv.from_string(get_print_format(doc.doctype,
print_format))
if print_format.custom_format:
template = get_template_from_string()
elif print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
elif print_format.standard == "Yes":
template = get_template_from_string()
else:
# fallback
template = "standard"
else:
template = "standard"
if template == "standard":
template = jenv.get_template(standard_format)
letter_head = frappe._dict(get_letter_head(doc, no_letterhead) or {})
if letter_head.content:
letter_head.content = frappe.utils.jinja.render_template(
letter_head.content, {"doc": doc.as_dict()})
if letter_head.footer:
letter_head.footer = frappe.utils.jinja.render_template(
letter_head.footer, {"doc": doc.as_dict()})
convert_markdown(doc, meta)
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": letter_head.content,
"footer": letter_head.footer,
"print_settings": frappe.get_doc("Print Settings")
}
html = template.render(args, filters={"len": len})
if cint(trigger_print):
html += trigger_print_script
return html
def render_jinja(content):
if "{% include" in content:
content = frappe.get_jenv().from_string(content).render()
return content
def get_raw_template(self):
return frappe.get_jloader().get_source(frappe.get_jenv(),
self.context.template)[0]
def get_html(doc, name=None, print_format=None, meta=None,
no_letterhead=None, trigger_print=False):
print_settings = frappe.db.get_singles_dict("Print Settings")
if isinstance(no_letterhead, string_types):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(print_settings.with_letterhead)
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if doc.meta.is_submittable:
if doc.docstatus==0 and not cint(print_settings.allow_print_for_draft):
frappe.throw(_("Not allowed to print draft documents"), frappe.PermissionError)
if doc.docstatus==2 and not cint(print_settings.allow_print_for_cancelled):
frappe.throw(_("Not allowed to print cancelled documents"), frappe.PermissionError)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format:
doc._show_section_headings = print_format.show_section_headings
doc._line_breaks = print_format.line_breaks
doc._align_labels_right = print_format.align_labels_right
def get_template_from_string():
return jenv.from_string(get_print_format(doc.doctype,
print_format))
if print_format.custom_format:
template = get_template_from_string()
elif print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
elif print_format.standard=="Yes":
template = get_template_from_string()
else:
# fallback
template = "standard"
else:
template = "standard"
if template == "standard":
template = jenv.get_template(standard_format)
letter_head = frappe._dict(get_letter_head(doc, no_letterhead) or {})
if letter_head.content:
letter_head.content = frappe.utils.jinja.render_template(letter_head.content, {"doc": doc.as_dict()})
if letter_head.footer:
letter_head.footer = frappe.utils.jinja.render_template(letter_head.footer, {"doc": doc.as_dict()})
convert_markdown(doc, meta)
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": letter_head.content,
"footer": letter_head.footer,
"print_settings": frappe.get_doc("Print Settings")
}
html = template.render(args, filters={"len": len})
if cint(trigger_print):
html += trigger_print_script
return html
def render_blocks(context):
"""returns a dict of block name and its rendered content"""
out = {}
env = frappe.get_jenv()
def _render_blocks(template_path):
source = frappe.local.jloader.get_source(frappe.local.jenv, template_path)[0]
for referenced_template_path in meta.find_referenced_templates(env.parse(source)):
if referenced_template_path:
_render_blocks(referenced_template_path)
template = frappe.get_template(template_path)
for block, render in template.blocks.items():
out[block] = scrub_relative_urls(concat(render(template.new_context(context))))
_render_blocks(context["template"])
# default blocks if not found
if "title" not in out and out.get("header"):
out["title"] = out["header"]
if "title" not in out:
out["title"] = context.get("title")
if "header" not in out and out.get("title"):
out["header"] = out["title"]
if out.get("header") and not out["header"].startswith("<h"):
out["header"] = "<h2>" + out["header"] + "</h2>"
if "breadcrumbs" not in out:
out["breadcrumbs"] = scrub_relative_urls(
frappe.get_template("templates/includes/breadcrumbs.html").render(context))
if "meta_block" not in out:
out["meta_block"] = frappe.get_template("templates/includes/meta_block.html").render(context)
out["no_sidebar"] = context.get("no_sidebar", 0)
if "<!-- no-sidebar -->" in out.get("content", ""):
out["no_sidebar"] = 1
if "<!-- title:" in out.get("content", ""):
out["title"] = re.findall('<!-- title:([^>]*) -->', out.get("content"))[0].strip()
if "{index}" in out.get("content", "") and context.get("children"):
html = frappe.get_template("templates/includes/static_index.html").render({
"items": context["children"]})
out["content"] = out["content"].replace("{index}", html)
if "{next}" in out.get("content", ""):
next_item = context.doc.get_next()
if next_item:
if next_item.name[0]!="/": next_item.name = "/" + next_item.name
html = '''<p><br><a href="{name}" class="btn btn-primary">
{title} <i class="icon-chevron-right"></i></a>
</p>'''.format(**next_item)
out["content"] = out["content"].replace("{next}", html)
if "sidebar" not in out and not out.get("no_sidebar"):
out["sidebar"] = scrub_relative_urls(
frappe.get_template("templates/includes/sidebar.html").render(context))
out["title"] = strip_html(out.get("title") or "")
# remove style and script tags from blocks
out["style"] = re.sub("</?style[^<>]*>", "", out.get("style") or "")
out["script"] = re.sub("</?script[^<>]*>", "", out.get("script") or "")
return out
def render(doc, format='Invoice Receiving Email'):
jenv = frappe.get_jenv()
template = jenv.from_string(
get_print_format('Invoice Receiving Email Tool', format))
return template.render(**doc)
def render(self, row):
jenv = frappe.get_jenv()
template = jenv.from_string(
get_print_format('Quotation Tool', 'Quotation Email'))
return template.render(**row)
def get_html(doc, name=None, print_format=None, meta=None,
no_letterhead=None, trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(frappe.db.get_single_value("Print Settings", "with_letterhead"))
if isinstance(doc, basestring) and isinstance(name, basestring):
doc = frappe.get_doc(doc, name)
if isinstance(doc, basestring):
doc = frappe.get_doc(json.loads(doc))
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format in ("Standard", standard_format):
template = "standard"
else:
print_format = frappe.get_doc("Print Format", print_format)
if print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
else:
template = jenv.from_string(get_print_format(doc.doctype,
print_format))
if template == "standard":
template = jenv.get_template("templates/print_formats/standard.html")
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": get_letter_head(doc, no_letterhead)
}
html = template.render(args, filters={"len": len})
return html
def get_html(doc,
name=None,
print_format=None,
meta=None,
no_letterhead=None,
trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(
frappe.db.get_single_value("Print Settings", "with_letterhead"))
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format:
if print_format.standard == "Yes" or print_format.custom_format:
template = jenv.from_string(
get_print_format(doc.doctype, print_format))
elif print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
else:
# fallback
template = "standard"
else:
template = "standard"
if template == "standard":
template = jenv.get_template(standard_format)
letter_head = frappe._dict(get_letter_head(doc, no_letterhead) or {})
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": letter_head.content,
"footer": letter_head.footer,
"print_settings": frappe.get_doc("Print Settings")
}
html = template.render(args, filters={"len": len})
if cint(trigger_print):
html += trigger_print_script
return html
def get_html(doc, name=None, print_format=None, meta=None,
no_letterhead=None, trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(frappe.db.get_single_value("Print Settings", "with_letterhead"))
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format:
if print_format.standard=="Yes" or print_format.custom_format:
template = jenv.from_string(get_print_format(doc.doctype,
print_format))
elif print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
else:
# fallback
template = "standard"
else:
template = "standard"
if template == "standard":
template = jenv.get_template(standard_format)
letter_head = frappe._dict(get_letter_head(doc, no_letterhead) or {})
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": letter_head.content,
"footer": letter_head.footer,
"print_settings": frappe.get_doc("Print Settings")
}
html = template.render(args, filters={"len": len})
if cint(trigger_print):
html += trigger_print_script
return html
def get_html(doc, name=None, print_format=None, meta=None,
no_letterhead=None, trigger_print=False):
if isinstance(no_letterhead, basestring):
no_letterhead = cint(no_letterhead)
elif no_letterhead is None:
no_letterhead = not cint(frappe.db.get_single_value("Print Settings", "with_letterhead"))
if isinstance(doc, basestring) and isinstance(name, basestring):
doc = frappe.get_doc(doc, name)
if isinstance(doc, basestring):
doc = frappe.get_doc(json.loads(doc))
doc.flags.in_print = True
if not frappe.flags.ignore_print_permissions:
validate_print_permission(doc)
if hasattr(doc, "before_print"):
doc.before_print()
if not hasattr(doc, "print_heading"): doc.print_heading = None
if not hasattr(doc, "sub_heading"): doc.sub_heading = None
if not meta:
meta = frappe.get_meta(doc.doctype)
jenv = frappe.get_jenv()
format_data, format_data_map = [], {}
# determine template
if print_format in ("Standard", standard_format):
template = "standard"
else:
print_format = frappe.get_doc("Print Format", print_format)
if print_format.format_data:
# set format data
format_data = json.loads(print_format.format_data)
for df in format_data:
format_data_map[df.get("fieldname")] = df
if "visible_columns" in df:
for _df in df.get("visible_columns"):
format_data_map[_df.get("fieldname")] = _df
doc.format_data_map = format_data_map
template = "standard"
else:
template = jenv.from_string(get_print_format(doc.doctype,
print_format))
if template == "standard":
template = jenv.get_template("templates/print_formats/standard.html")
args = {
"doc": doc,
"meta": frappe.get_meta(doc.doctype),
"layout": make_layout(doc, meta, format_data),
"no_letterhead": no_letterhead,
"trigger_print": cint(trigger_print),
"letter_head": get_letter_head(doc, no_letterhead)
}
html = template.render(args, filters={"len": len})
return html
