def template_set_default(template_id):
'''
UI for setting a given template as the default for an archive type
'''
user = auth.is_logged_in(request)
tpl = Template.load(template_id)
blog = Blog.load(tpl.blog.id)
permission = auth.is_blog_designer(user, blog)
auth.check_template_lock(blog)
tags = template_tags(template=tpl, user=user)
from core.utils import Status
import settings
if request.forms.getunicode('confirm') == user.logout_nonce:
# check for form submission
# setting should be done by way of class object
# theme? blog? template?
# blog.set_default_archive_template(template,{archive_type.index...})
status = Status(
type='success',
close=False,
message=
'Template <b>{}</b> was successfully refreshed from theme <b>{}</b>.'
.format(tpl.for_display, tpl.theme.for_display),
action='Return to template',
url='{}/template/{}/edit'.format(settings.BASE_URL, tpl.id))
tags.status = status
else:
pass
from core.models import archive_defaults
return template('edit/template-set-default',
icons=icons,
search_context=(search_contexts['blog'], tags.blog),
menu=generate_menu('blog_edit_template', tags.template),
sidebar=sidebar.render_sidebar(
panel_set='edit_template',
publishing_mode=publishing_mode,
types=template_type,
**tags.__dict__),
archive_defaults=archive_defaults,
**tags.__dict__)
def template_delete(template_id):
'''
UI for deleting a template
'''
user = auth.is_logged_in(request)
tpl = Template.load(template_id)
blog = Blog.load(tpl.blog)
permission = auth.is_blog_designer(user, blog)
from core.utils import Status
import settings
tags = template_tags(template_id=tpl.id, user=user)
if request.forms.getunicode('confirm') == user.logout_nonce:
# _template.delete(tpl)
tpl.delete_instance()
status = Status(type='success',
close=False,
message='Template {} was successfully deleted.'.format(
tpl.for_log),
action='Return to template list',
url='{}/blog/{}/templates'.format(
settings.BASE_URL, blog.id))
else:
status = Status(
type='warning',
close=False,
message=
'You are attempting to delete template <b>{}</b> from blog <b>{}</b>.'
.format(tpl.for_display, blog.for_display),
no={
'url': '{}/template/{}/edit'.format(settings.BASE_URL, tpl.id),
'label': 'No, I don\'t want to delete this template'
},
yes={
'id': 'delete',
'name': 'confirm',
'label': 'Yes, I want to delete this template',
'value': user.logout_nonce
})
tags.status = status
return report(tags, 'blog_delete_template', tpl)
def queue_archive_template_fast(template_id, action, pass_id=0):
from core.models import Template, Queue
template = Template.load(template_id)
blog = template.blog
from core import cms
from core.libs.bottle import HTTPResponse
r = HTTPResponse()
fileinfos = FileInfo.select().where(FileInfo.template_mapping << template.mappings).paginate(pass_id, 50)
# TODO: if action is fast and no fileinfos present, redirect to full rebuild?
if fileinfos.count() > 0:
r.body = "Adding {}".format(pass_id * 50)
for f in fileinfos:
Queue.push(job_type=cms.queue.job_type.archive,
blog=blog,
site=blog.site,
data_integer=f.id)
pass_id += 1
r.add_header('Refresh', "0;{}/template/{}/{}/fast/{}".format(
BASE_PATH,
template_id,
action,
pass_id))
else:
r.body = "Queue insertion finished."
if action == 'publish':
redir = 'publish'
else:
redir = 'queue'
r.add_header('Refresh', "0;{}/blog/{}/{}".format(
BASE_PATH,
blog.id,
redir))
return r
def queue_archive_template_all(template_id, action, pass_id=0):
from core.models import Template, Queue
template = Template.load(template_id)
blog = template.blog
from core.cms import fileinfo, queue
from core.libs.bottle import HTTPResponse
r = HTTPResponse()
pages = blog.pages.published.paginate(pass_id, 50)
if pages.count() > 0:
r.body = "Adding {}".format(pass_id * 50)
for f in fileinfo.build_archives_fileinfos_by_mappings(template, pages):
Queue.push(job_type=queue.job_type.archive,
blog=blog,
site=blog.site,
data_integer=f.id)
pass_id += 1
r.add_header('Refresh', "0;{}/template/{}/{}/all/{}".format(
BASE_PATH,
template_id,
action,
pass_id))
else:
r.body = "Queue insertion finished."
if action == 'publish':
redir = 'publish'
else:
redir = 'queue'
r.add_header('Refresh', "0;{}/blog/{}/{}".format(
BASE_PATH,
blog.id,
redir))
return r
def queue_archive_template_fast(template_id, action, pass_id=0):
from core.models import Template, Queue
template = Template.load(template_id)
blog = template.blog
from core import cms
from core.libs.bottle import HTTPResponse
r = HTTPResponse()
fileinfos = FileInfo.select().where(
FileInfo.template_mapping << template.mappings).paginate(pass_id, 50)
# TODO: if action is fast and no fileinfos present, redirect to full rebuild?
if fileinfos.count() > 0:
r.body = "Adding {}".format(pass_id * 50)
for f in fileinfos:
Queue.push(job_type=cms.queue.job_type.archive,
blog=blog,
site=blog.site,
data_integer=f.id)
pass_id += 1
r.add_header(
'Refresh',
"0;{}/template/{}/{}/fast/{}".format(BASE_PATH, template_id,
action, pass_id))
else:
r.body = "Queue insertion finished."
if action == 'publish':
redir = 'publish'
else:
redir = 'queue'
r.add_header('Refresh',
"0;{}/blog/{}/{}".format(BASE_PATH, blog.id, redir))
return r
def template_edit(template_id):
'''
UI for editing a blog template
'''
user = auth.is_logged_in(request)
edit_template = Template.load(template_id)
blog = Blog.load(edit_template.blog.id)
permission = auth.is_blog_designer(user, blog)
auth.check_template_lock(blog)
utils.disable_protection()
tags = template_tags(template_id=template_id, user=user)
# find out if the template object returns a list of all the mappings, or just the first one
# it's edit_template.mappings
tags.mappings = template_mapping_index[edit_template.template_type]
return template_edit_output(tags)
def queue_archive_template_all(template_id, action, pass_id=0):
from core.models import Template, Queue
template = Template.load(template_id)
blog = template.blog
from core.cms import fileinfo, queue
from core.libs.bottle import HTTPResponse
r = HTTPResponse()
pages = blog.pages.published.paginate(pass_id, 50)
if pages.count() > 0:
r.body = "Adding {}".format(pass_id * 50)
for f in fileinfo.build_archives_fileinfos_by_mappings(
template, pages):
Queue.push(job_type=queue.job_type.archive,
blog=blog,
site=blog.site,
data_integer=f.id)
pass_id += 1
r.add_header(
'Refresh',
"0;{}/template/{}/{}/all/{}".format(BASE_PATH, template_id, action,
pass_id))
else:
r.body = "Queue insertion finished."
if action == 'publish':
redir = 'publish'
else:
redir = 'queue'
r.add_header('Refresh',
"0;{}/blog/{}/{}".format(BASE_PATH, blog.id, redir))
return r
def template_preview_core(template_id):
'''
UI for generating a preview of a given template
'''
from core.models import Page, FileInfo, page_status
from core.cms import fileinfo
from core.cms import invalidate_cache
invalidate_cache()
template = Template.load(template_id)
# TODO: only rebuild mappings if the dirty bit is set
if template.template_type == template_type.index:
fi = template.default_mapping.fileinfos
test_preview_mapping(fi.count(), template)
fi = fi.get()
tags = template_tags(blog=template.blog,
template=template,
fileinfo=fi)
elif template.template_type == template_type.page:
try:
fi = Page.load(int(request.query['use_page'])).fileinfos[0]
except (KeyError, TypeError):
fi = template.fileinfos
test_preview_mapping(fi.count(), template)
fi = fi.select().join(Page).where(
FileInfo.page == Page.id,
Page.blog == template.blog,
Page.status == page_status.published,
).order_by(Page.publication_date.desc()).get()
tags = template_tags(
template=template,
page=fi.page,
)
elif template.template_type == template_type.include:
if template.publishing_mode != publishing_mode.ssi:
from core.error import PreviewException
raise PreviewException(
'You can only preview server-side includes.')
page = template.blog.pages.published.order_by(
Page.publication_date.desc()).get()
fi = page.fileinfos[0]
tags = template_tags(
template=template,
page=page,
)
elif template.template_type == template_type.archive:
if 'use_page' in request.query:
page_list = [Page.load(int(request.query['use_page']))]
elif 'use_category' in request.query:
from core.models import Category
page_list = Category.load(int(
request.query['use_category'])).pages.published.limit(1)
elif 'use_tag' in request.query:
from core.models import Tag
page_list = Tag.load(int(
request.query['use_tag'])).pages.published.limit(1)
else:
page_list = template.blog.pages.published.limit(1)
fi = fileinfo.build_archives_fileinfos_by_mappings(template,
pages=page_list)
test_preview_mapping(len(fi), template)
fi = fi[0]
archive_pages = fileinfo.generate_archive_context_from_fileinfo(
fi.xref.archive_xref, template.blog.pages.published, fi)
tags = template_tags(blog=template.blog,
archive=archive_pages,
archive_context=fi,
fileinfo=fi,
template=template)
elif template.template_type in (template_type.media, template_type.system):
from core.error import PreviewException
raise PreviewException(
'Template {} is of a type that cannot yet be previewed.'.format(
template.for_log))
import time
from core.template import tplt
tc = time.clock
start = tc()
tpl_output = tplt(template, tags)
end = tc()
tpl_output = r'<!-- Produced by template {}. Total render time:{} secs -->{}'.format(
template.for_log, end - start, tpl_output)
preview_file_path, preview_url = fi.make_preview()
from core.cms import queue
queue.write_file(tpl_output, template.blog.path, preview_file_path)
return ("{}?_={}".format(preview_url, template.modified_date.microsecond))
def template_edit_save(template_id):
'''
UI for saving a blog template
'''
user = auth.is_logged_in(request)
tpl = Template.load(template_id)
blog = Blog.load(tpl.blog)
permission = auth.is_blog_designer(user, blog)
auth.check_template_lock(blog)
from core.utils import Status
from core.error import TemplateSaveException, PageNotChanged
status = None
save_mode = int(request.forms.getunicode('save', default="0"))
if save_mode in (1, 2, 3):
try:
message = template_save(request, user, tpl, blog)
except TemplateSaveException as e:
status = Status(type='danger',
no_sure=True,
message="Error saving template <b>{}</b>:".format(
tpl.for_display),
message_list=(e, ))
except PageNotChanged as e:
status = Status(type='success',
message="Template <b>{}</b> was unchanged.".format(
tpl.for_display))
except Exception as e:
raise e
status = Status(
type='warning',
no_sure=True,
message="Problem saving template <b>{}</b>: <br>".format(
tpl.for_display),
message_list=(e, ))
else:
tpl.delete_preview()
status = Status(
type='success',
message="Template <b>{}</b> saved successfully. {}".format(
tpl.for_display,
message) # TODO: move messages into message lister
)
tags = template_tags(template_id=template_id, user=user)
tags.mappings = template_mapping_index[tpl.template_type]
tags.status = status
from core.models import (template_type as template_types)
return template('edit/template_ajax',
sidebar=sidebar.render_sidebar(
panel_set='edit_template',
publishing_mode=publishing_mode,
types=template_types,
**tags.__dict__),
**tags.__dict__)
def template_refresh(template_id):
'''
UI for reloading a template from the original version stored in the
template's theme (assuming such an original template exists)
'''
user = auth.is_logged_in(request)
tpl = Template.load(template_id)
blog = Blog.load(tpl.blog)
permission = auth.is_blog_designer(user, blog)
from core.utils import Status
import settings
tags = template_tags(template_id=tpl.id, user=user)
if request.forms.getunicode('confirm') == user.logout_nonce:
import os, json
template_path = (os.path.join(tpl.theme.path, tpl.template_ref))
with open(template_path, 'r') as f:
tp_json = json.loads(f.read())
# TODO: We will eventually merge in all the other refresh functions
# and convert this to a generic function called from
# mgmt.theme_apply_to_blog as well
with open(template_path[:-5] + '.tpl', 'r') as b:
tpl.body = b.read()
tpl.save(user)
status = Status(
type='success',
close=False,
message=
'Template <b>{}</b> was successfully refreshed from theme <b>{}</b>.'
.format(tpl.for_display, tpl.theme.for_display),
action='Return to template',
url='{}/template/{}/edit'.format(settings.BASE_URL, tpl.id))
else:
status = Status(type='warning',
close=False,
message='''
You are attempting to refresh template <b>{}</b> for blog <b>{}</b> from its underlying theme <b>{}</b>.</p>
<p>This will <b>overwrite</b> the current version of the template and replace it with the original version
from the theme.
'''.format(tpl.for_display, blog.for_display, tpl.theme.for_display),
no={
'url':
'{}/template/{}/edit'.format(
settings.BASE_URL, tpl.id),
'label':
'No, I don\'t want to replace this template'
},
yes={
'id': 'delete',
'name': 'confirm',
'label': 'Yes, I want to replace this template',
'value': user.logout_nonce
})
tags.status = status
return report(tags, 'blog_delete_template', tpl)
