def queue_index_actions(blog):
'''
Pushes to the publishing queue all the index pages for a given blog
that are marked for Immediate publishing.
'''
try:
templates = Template.select().where(
Template.blog == blog,
Template.template_type == template_type.index,
Template.publishing_mode == publishing_mode.immediate)
if templates.count() == 0:
raise Template.DoesNotExist
except Template.DoesNotExist:
raise Template.DoesNotExist(
"No index templates exist for blog {}.".format(blog.for_log))
else:
mappings = TemplateMapping.select().where(
TemplateMapping.template << templates)
fileinfos = FileInfo.select().where(
FileInfo.template_mapping << mappings)
for f in fileinfos:
push_to_queue(job_type=job_type.index,
priority=1,
blog=blog,
site=blog.site,
data_integer=f.id)
def export_theme_for_blog(blog_id):
from core.models import Template, TemplateMapping, KeyValue
theme_to_export = Template.select().where(
Template.blog == blog_id)
theme = {}
theme["title"] = theme_to_export[0].theme.title
theme["description"] = theme_to_export[0].theme.description
theme["data"] = {}
for n in theme_to_export:
theme["data"][n.id] = {}
theme["data"][n.id]["template"] = json_dump(n)
mappings_to_export = TemplateMapping.select().where(
TemplateMapping.template == n)
theme["data"][n.id]["mapping"] = {}
for m in mappings_to_export:
theme["data"][n.id]["mapping"][m.id] = json_dump(m)
theme["kv"] = {}
kv_list = []
top_kvs = KeyValue.select().where(
KeyValue.object == 'Theme',
KeyValue.objectid == theme_to_export[0].theme.id,
KeyValue.is_schema == True)
for n in top_kvs:
kv_list.append(n)
while len(kv_list) > 0:
theme["kv"][kv_list[0].id] = json_dump(kv_list[0])
next_kvs = KeyValue.select().where(
KeyValue.parent == kv_list[0],
KeyValue.is_schema == True)
for f in next_kvs:
kv_list.append(f)
del kv_list[0]
import settings
with open(settings.APPLICATION_PATH + settings._sep + "install" + settings._sep +
"templates.json", "w", encoding='utf-8') as output_file:
output_file.write(json.dumps(theme,
indent=1,
sort_keys=True,
allow_nan=True))
return theme
def page_get_media_templates(page_id, media_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
media = Media.load(media_id, page.blog)
media_templates = Template.select().where(
Template.blog == page.blog,
Template.template_type == template_type.media).order_by(Template.title)
buttons = media_buttons.format('onclick="add_template();"', 'Apply')
tpl = template('modal/modal_image_templates',
media=media,
templates=media_templates,
buttons=buttons,
title='Choose a template for {}'.format(media.for_log))
return tpl
def page_get_media_templates(page_id, media_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
media = Media.load(media_id, page.blog)
media_templates = Template.select().where(
Template.blog == page.blog,
Template.template_type == template_type.media).order_by(Template.title)
buttons = media_buttons.format(
'onclick="add_template();"',
'Apply')
tpl = template('modal/modal_image_templates',
media=media,
templates=media_templates,
buttons=buttons,
title='Choose a template for {}'.format(
media.for_log))
return tpl
def blog_templates(blog_id):
'''
List all templates in a given blog
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_designer(user, blog)
reason = auth.check_template_lock(blog, True)
tags = template_tags(blog_id=blog.id, user=user)
tags.status = reason
from core.libs.peewee import JOIN_LEFT_OUTER
template_list = Template.select(Template, TemplateMapping).join(
TemplateMapping, JOIN_LEFT_OUTER).where(
(Template.blog == blog)).order_by(Template.title)
index_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.index)
page_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.page)
archive_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.archive)
template_includes = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.include)
media_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.media)
code_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.code)
system_templates = template_list.select(
Template,
TemplateMapping).where(Template.template_type == template_type.system)
from core.models import archive_defaults
tags.list_items = (
{
'title': 'Index Templates',
'type': template_type.index,
'data': index_templates,
'defaults': archive_defaults[template_type.index]
},
{
'title': 'Page Templates',
'type': template_type.page,
'data': page_templates,
'defaults': archive_defaults[template_type.page]
},
{
'title': 'Archive Templates',
'type': template_type.archive,
'data': archive_templates,
'defaults': archive_defaults[template_type.archive]
},
{
'title': 'Includes',
'type': template_type.include,
'data': template_includes
},
{
'title': 'Media Templates',
'type': template_type.media,
'data': media_templates
},
{
'title': 'Code',
'type': template_type.code,
'data': code_templates
},
{
'title': 'System Templates',
'type': template_type.system,
'data': system_templates
},
)
return template('ui/ui_blog_templates',
icons=icons,
section_title="Templates",
publishing_mode=publishing_mode,
search_context=(search_contexts['blog_templates'], blog),
menu=generate_menu('blog_manage_templates', blog),
templates_with_defaults=('Index', 'Page', 'Archive'),
**tags.__dict__)
def blog_templates(blog_id):
'''
List all templates in a given blog
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_designer(user, blog)
reason = auth.check_template_lock(blog, True)
tags = template_tags(blog_id=blog.id,
user=user)
tags.status = reason
from core.libs.peewee import JOIN_LEFT_OUTER
template_list = Template.select(Template, TemplateMapping).join(
TemplateMapping, JOIN_LEFT_OUTER).where(
(Template.blog == blog)
).order_by(Template.title)
index_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.index)
page_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.page)
archive_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.archive)
template_includes = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.include)
media_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.media)
code_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.code)
system_templates = template_list.select(Template, TemplateMapping).where(
Template.template_type == template_type.system)
from core.models import archive_defaults
tags.list_items = (
{'title':'Index Templates',
'type': template_type.index,
'data':index_templates,
'defaults': archive_defaults[template_type.index]},
{'title':'Page Templates',
'type': template_type.page,
'data':page_templates,
'defaults':archive_defaults[template_type.page]},
{'title':'Archive Templates',
'type': template_type.archive,
'data':archive_templates,
'defaults': archive_defaults[template_type.archive]},
{'title':'Includes',
'type': template_type.include,
'data':template_includes},
{'title':'Media Templates',
'type': template_type.media,
'data':media_templates},
{'title':'Code',
'type': template_type.code,
'data':code_templates},
{'title':'System Templates',
'type': template_type.system,
'data':system_templates},
)
return template('ui/ui_blog_templates',
icons=icons,
section_title="Templates",
publishing_mode=publishing_mode,
search_context=(search_contexts['blog_templates'], blog),
menu=generate_menu('blog_manage_templates', blog),
templates_with_defaults=('Index', 'Page', 'Archive'),
** tags.__dict__)
