def blog_publish(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
queue_length = Queue.job_counts(blog=blog)
if queue_length > 0:
start_message = template('queue/queue_run_include',
queue=Queue.jobs(blog),
percentage_complete=0,
blog=blog,
break_path='{}/blog/{}/publish/break'.format(
BASE_URL, blog.id))
Queue.start(blog, queue_length)
else:
start_message = "Queue empty."
tags = template_tags(blog_id=blog.id, user=user)
#
return template(
'queue/queue_run_ui',
start=queue_length,
start_message=start_message,
action_url="../../blog/{}/publish/progress/{}".format(
blog.id, queue_length),
title='Publishing queue progress',
# search_context=(search_context['blog_queue'], blog),
menu=generate_menu('blog_queue', blog),
**tags.__dict__)
def tag_make_for_page(blog_id=None, page_id=None):
user = auth.is_logged_in(request)
if page_id is None:
# page = Page()
blog = Blog.load(blog_id)
page = None
permission = auth.is_blog_editor(user, blog)
assoc = {'blog':blog}
else:
page = Page.load(page_id)
blog = None
permission = auth.is_page_editor(user, page)
assoc = {'page':page}
tag_name = request.forms.getunicode('tag')
if len(tag_name) < 1:
return None
# Note that this is a single tag only!
tag = Tag.add_or_create(
[tag_name, ],
**assoc
)
if len(tag[0]) > 0:
tpl = template(tag[0][0].new_tag_for_display)
else:
tpl = template(tag[1][0].for_display)
return tpl
def tag_make_for_media(media_id=None, tag=None):
user = auth.is_logged_in(request)
media = Media.load(media_id)
permission = auth.is_media_owner(user, media)
if tag == None:
tag_name = request.forms.getunicode('tag')
else:
tag_name = tag
if len(tag_name) < 1:
return None
# Note that this is a single tag only!
tag = Tag.add_or_create((tag_name,),
media=media)
if len(tag[0]) > 0:
tpl = template(tag[0][0].new_tag_for_display)
else:
tpl = template(tag[1][0].for_display)
return tpl
def blog_publish(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
queue_length = Queue.job_counts(blog=blog)
if queue_length > 0:
start_message = template('queue/queue_run_include',
queue=Queue.jobs(blog),
percentage_complete=0,
blog=blog,
break_path='{}/blog/{}/publish/break'.format(BASE_URL, blog.id)
)
Queue.start(blog, queue_length)
else:
start_message = "Queue empty."
tags = template_tags(blog_id=blog.id,
user=user)
#
return template('queue/queue_run_ui',
start=queue_length,
start_message=start_message,
action_url="../../blog/{}/publish/progress/{}".format(blog.id,
queue_length),
title='Publishing queue progress',
# search_context=(search_context['blog_queue'], blog),
menu=generate_menu('blog_queue', blog),
**tags.__dict__)
def tag_make_for_page(blog_id=None, page_id=None):
user = auth.is_logged_in(request)
if page_id is None:
# page = Page()
blog = Blog.load(blog_id)
page = None
permission = auth.is_blog_editor(user, blog)
assoc = {'blog': blog}
else:
page = Page.load(page_id)
blog = None
permission = auth.is_page_editor(user, page)
assoc = {'page': page}
tag_name = request.forms.getunicode('tag')
if len(tag_name) < 1:
return None
# Note that this is a single tag only!
tag = Tag.add_or_create([
tag_name,
], **assoc)
if len(tag[0]) > 0:
tpl = template(tag[0][0].new_tag_for_display)
else:
tpl = template(tag[1][0].for_display)
return tpl
def blog_create(site_id):
user = auth.is_logged_in(request)
site = Site.load(site_id)
permission = auth.is_site_admin(user, site)
new_blog = Blog(
name="",
description="",
url="",
path="")
tags = template_tags(site_id=site.id,
user=user)
tags.blog = new_blog
from core.libs import pytz
themes = Theme.select()
return template('ui/ui_blog_settings',
section_title="Create new blog",
# search_context=(search_context['sites'], None),
menu=generate_menu('site_create_blog', site),
nav_default='all',
timezones=pytz.all_timezones,
themes=themes,
** tags.__dict__
)
def main_ui():
'''
Top level UI
This will eventually become a full-blown user dashboard.
Right now it just returns a list of sites in the system.
All users for the system can see this dashboard.
'''
user = auth.is_logged_in(request)
# TODO: replace with actual user-centric setting
try:
from settings import MAX_RECENT_PAGES
except ImportError:
MAX_RECENT_PAGES = 10
recent_pages = Page.select().where(
Page.user == user).order_by(
Page.modified_date.desc()).limit(MAX_RECENT_PAGES)
your_blogs = user.blogs()
tpl = template('ui/ui_dashboard',
search_context=(search_contexts['sites'], None),
menu=generate_menu('system_menu', None),
recent_pages=recent_pages,
your_blogs=your_blogs,
**template_tags(user=user).__dict__
)
return tpl
def system_site_index():
from core.models import Site
sites = Site.select()
tpl = '''
<p>This is the local web server for an installation of {}.
<p><a href='{}'>Open the site dashboard</a>
<hr/>
<p>You can also preview sites and blogs available on this server:
<ul>'''.format(PRODUCT_NAME, BASE_PATH) + '''
% for site in sites:
<li>{{site.name}}</li>
% if site.blogs.count()>0:
<ul>
% for blog in site.blogs:
% if blog.published_pages().count()>0:
<li><a href="/?_={{blog.id}}">{{blog.name}}</a></li>
% else:
<li>{{blog.name}} [No published pages on this blog]</li>
% end
% end
</ul>
% end
%end
</ul><hr/>
'''
return template(tpl, sites=sites)
def blog_publish_progress(blog_id, original_queue_length):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
queue_count = 0
control_jobs = Queue.control_jobs(blog)
if control_jobs.count() > 0:
# queue_count = queue.process_queue(blog)
# queue_count = transaction(queue.process_queue)(blog)
queue_count = q_p(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
queue_count = 0
percentage_complete = int(
(1 - (int(queue_count) / int(original_queue_length))) * 100)
import settings
return template('queue/queue_run_include',
queue_count=queue_count,
blog=blog,
break_path='{}/blog/{}/publish/break'.format(
BASE_URL, blog.id),
settings=settings,
percentage_complete=percentage_complete)
def login_verify():
'''
Verifies user login, provides session cookie if successful
'''
_forms = request.forms
email = _forms.get('email')
password = _forms.get('password')
if login_verify_core(email, password) is True:
if request.query.action:
utils.safe_redirect(request.query.action)
else:
redirect(BASE_URL)
else:
tags = template_tags()
tags.status = utils.Status(
type='danger',
no_sure=True,
message="Email or password not found.")
return template('ui/ui_login',
**tags.__dict__)
def blog_publish_process(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
control_jobs = Queue.control_jobs(blog)
if control_jobs.count() > 0:
queue_count = q_p(blog)
# queue_count = transaction(queue.process_queue)(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
jobs = Queue.jobs(blog)
if jobs.count() > 0:
queue_count = jobs.count()
Queue.start(blog, queue_count)
queue_count = q_p(blog)
# queue_count = transaction(queue.process_queue)(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
queue_count = 0
import settings
return template('queue/queue_counter_include',
blog=blog,
settings=settings,
queue_count=queue_count)
def blog_publish_progress(blog_id, original_queue_length):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
queue_count = 0
control_jobs = Queue.control_jobs(blog)
if control_jobs.count() > 0:
# queue_count = queue.process_queue(blog)
# queue_count = transaction(queue.process_queue)(blog)
queue_count = q_p(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
queue_count = 0
percentage_complete = int((1 - (int(queue_count) / int(original_queue_length))) * 100)
import settings
return template('queue/queue_run_include',
queue_count=queue_count,
blog=blog,
break_path='{}/blog/{}/publish/break'.format(BASE_URL, blog.id),
settings=settings,
percentage_complete=percentage_complete)
def page_media_upload(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
overwrite = []
for n in request.files:
x = request.files.get(n)
media_path = _join(page.blog.path, page.blog.media_path_generated)
file_path = _join(media_path, x.filename)
if _exists(file_path):
from core.error import FileExistsError
raise FileExistsError("File '{}' already exists on the server.".format(
utils.html_escape(x.filename)))
else:
Media.register_media(x.filename, file_path, user, page=page)
if not _exists(media_path):
makedirs(media_path)
x.save(file_path)
tags = template_tags(page=page)
return template('edit/page_media_list.tpl',
**tags.__dict__)
def page_edit_save(page_id):
'''
UI for saving changes to an edited blog page
'''
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page.delete_preview()
# from core.cms import save_action_list
tags = save_page(page, user, page.blog)
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
tpl = template('edit/page_ajax',
sidebar=sidebar.render_sidebar(
panel_set='edit_page',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__
),
msg_float=False,
**tags.__dict__)
return tpl
def blog_publish_process(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
control_jobs = Queue.control_jobs(blog)
if control_jobs.count() > 0:
queue_count = q_p(blog)
# queue_count = transaction(queue.process_queue)(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
jobs = Queue.jobs(blog)
if jobs.count() > 0:
queue_count = jobs.count()
Queue.start(blog, queue_count)
queue_count = q_p(blog)
# queue_count = transaction(queue.process_queue)(blog)
time.sleep(RETRY_INTERVAL * 5)
else:
queue_count = 0
import settings
return template('queue/queue_counter_include',
blog=blog,
settings=settings,
queue_count=queue_count)
def error_handler(error):
import settings as _settings
tpl = template('500_error', settings=_settings, error=error)
if error.exception.__class__ == CSRFTokenNotFound:
response.status = '401 CSRF token not found'
return tpl
def media_edit_output(tags):
return template('edit/media',
icons=icons,
menu=generate_menu('blog_edit_media', tags.media),
search_context=(search_contexts['blog_media'], tags.blog),
**tags.__dict__)
def media_edit_output(tags):
return template('edit/media',
icons=icons,
menu=generate_menu('blog_edit_media', tags.media),
search_context=(search_contexts['blog_media'], tags.blog),
**tags.__dict__)
def main_ui():
'''
Top level UI
This will eventually become a full-blown user dashboard.
Right now it just returns a list of sites in the system.
All users for the system can see this dashboard.
'''
user = auth.is_logged_in(request)
# TODO: replace with actual user-centric setting
try:
from settings import MAX_RECENT_PAGES
except ImportError:
MAX_RECENT_PAGES = 10
recent_pages = Page.select().where(Page.user == user).order_by(
Page.modified_date.desc()).limit(MAX_RECENT_PAGES)
your_blogs = user.blogs()
tpl = template('ui/ui_dashboard',
search_context=(search_contexts['sites'], None),
menu=generate_menu('system_menu', None),
recent_pages=recent_pages,
your_blogs=your_blogs,
**template_tags(user=user).__dict__)
return tpl
def page_media_upload(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
overwrite = []
for n in request.files:
x = request.files.get(n)
media_path = _join(page.blog.path, page.blog.media_path_generated)
file_path = _join(media_path, x.filename)
if _exists(file_path):
from core.error import FileExistsError
raise FileExistsError(
"File '{}' already exists on the server.".format(
utils.html_escape(x.filename)))
else:
Media.register_media(x.filename, file_path, user, page=page)
if not _exists(media_path):
makedirs(media_path)
x.save(file_path)
tags = template_tags(page=page)
return template('edit/page_media_list.tpl', **tags.__dict__)
def page_edit_save(page_id):
'''
UI for saving changes to an edited blog page
'''
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page.delete_preview()
# from core.cms import save_action_list
tags = save_page(page, user, page.blog)
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
tpl = template('edit/page_ajax',
sidebar=sidebar.render_sidebar(
panel_set='edit_page',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__),
msg_float=False,
**tags.__dict__)
return tpl
def load_view(self, view, **args):
try:
with open("views{}{}.html".format(os.sep, view.lower())) as fview:
view = fview.read()
except FileNotFoundError:
raise ControllerException("{}: La vista \"{}\" no existe."\
.format(self.__class__.__name__, view.lower()))
return template(view, **args)
def blog_new_page(blog_id):
'''
Displays UI for newly created (unsaved) page
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_member(user, blog)
tags = template_tags(blog=blog, user=user)
tags.page = Page()
referer = request.headers.get('Referer')
if referer is None:
referer = BASE_URL + "/blog/" + str(blog.id)
blog_new_page = tags.page
for n in new_page_submission_fields:
blog_new_page.__setattr__(n, "")
if n in request.query:
blog_new_page.__setattr__(n, request.query.getunicode(n))
import datetime
blog_new_page.blog = blog
blog_new_page.user = user
blog_new_page.publication_date = datetime.datetime.utcnow()
blog_new_page.basename = ''
from core.cms import save_action_list
from core.ui import kv
kv_ui_data = kv.ui(blog_new_page.kv_list())
try:
html_editor_settings = Template.get(
Template.blog == blog, Template.title == 'HTML Editor Init',
Template.template_type == template_type.system).body
except Template.DoesNotExist:
from core.static import html_editor_settings
return template(
'edit/page',
menu=generate_menu('create_page', blog),
parent_path=referer,
# search_context=(search_context['blog'], blog),
html_editor_settings=html_editor_settings,
sidebar=sidebar.render_sidebar(panel_set='edit_page',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=None,
**tags.__dict__),
**tags.__dict__)
def step(step):
if get_ini('main', 'BASE_URL_ROOT') is not None:
_s.BASE_URL_ROOT = get_ini('main', 'BASE_URL_ROOT')
_s.BASE_URL_PATH = get_ini('main', 'BASE_URL_PATH')
_s.BASE_URL = _s.BASE_URL_ROOT + _s.BASE_URL_PATH
error_msg = None
if request.method == "POST":
try:
results = step_text[step]['post-step']()
except SetupError as e:
results = step_text[step]['pre-step']()
error_msg = e
else:
step += 1
redirect('{}/install/step-{}'.format(_s.BASE_URL, step))
else:
try:
results = step_text[step]['pre-step']()
except SetupError as e:
error_msg = e
results = {}
if error_msg is None:
template_button = button(step, step_text[step]['next_action'])
else:
template_button = button(step, None, error_msg)
return template(tpl,
settings=_s,
step=step,
title=step_text[step]['title'],
text=template(step_text[step]['text'],
button=template_button,
form_action='{}/install/step-{}'.format(
_s.BASE_URL, step),
**results),
crumbs=crumbs(step),
error=error_msg)
def step(step):
if get_ini('main', 'BASE_URL_ROOT') is not None:
_s.BASE_URL_ROOT = get_ini('main', 'BASE_URL_ROOT')
_s.BASE_URL_PATH = get_ini('main', 'BASE_URL_PATH')
_s.BASE_URL = _s.BASE_URL_ROOT + _s.BASE_URL_PATH
error_msg = None
if request.method == "POST":
try:
results = step_text[step]['post-step']()
except SetupError as e:
results = step_text[step]['pre-step']()
error_msg = e
else:
step += 1
redirect('{}/install/step-{}'.format(_s.BASE_URL, step))
else:
try:
results = step_text[step]['pre-step']()
except SetupError as e:
error_msg = e
results = {}
if error_msg is None:
template_button = button(step, step_text[step]['next_action'])
else:
template_button = button(step, None, error_msg)
return template(tpl,
settings=_s,
step=step,
title=step_text[step]['title'],
text=template(step_text[step]['text'],
button=template_button,
form_action='{}/install/step-{}'.format(_s.BASE_URL, step),
**results),
crumbs=crumbs(step),
error=error_msg)
def new_category(blog_id):
from core.models import db
with db.atomic() as txn:
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_editor(user, blog)
category_list = [n for n in blog.categories]
category = Category(id=0,
title='',
blog=blog)
top_level_category = Category(
id=None,
title='[Top-level category]',
parent=None
)
category_list.insert(0, top_level_category)
tags = template_tags(
blog=blog,
user=user)
if request.method == "POST":
with db.atomic() as txn:
category_title = request.forms.getunicode('category_title')
try:
parent_category = int(request.forms.getunicode('category_parent'))
except ValueError:
parent_category = None
with db.atomic() as txn:
category = Category(blog=blog,
title=category_title,
parent_category=parent_category
)
category.save()
redirect('{}/blog/{}/category/{}'.format(
BASE_URL, blog.id, category.id))
tpl = template('edit/category',
category=category,
category_list=category_list,
menu=generate_menu('blog_new_category', category),
search_context=(search_contexts['sites'], None),
**tags.__dict__)
return tpl
def login():
'''
User login interface
'''
tpl = template('ui/ui_login', **template_tags().__dict__)
logger.info("Login page requested from IP {}.".format(request.remote_addr))
response.delete_cookie("login", path="/")
return tpl
def render_sidebar(**k):
from core.libs.bottle import template
panels = panels_dict[k['panel_set']]['panel_order']
panel_set = panels_dict[k['panel_set']]['panels']
sidebar_panels = []
for n in panels:
panels_n = panel_set[n]
if not 'collapse' in panels_n:
panels_n['collapse'] = ''
panel_body = template(panels_n['template'], **k)
panel = template('sidebar/panel', body=panel_body, **panels_n)
sidebar_panels.append(panel)
sidebar_template = template('sidebar/sidebar_ui',
panels=''.join(sidebar_panels))
return sidebar_template
def render_sidebar(**k):
from core.libs.bottle import template
panels = panels_dict[k['panel_set']]['panel_order']
panel_set = panels_dict[k['panel_set']]['panels']
sidebar_panels = []
for n in panels:
panels_n = panel_set[n]
if not 'collapse' in panels_n:
panels_n['collapse'] = ''
panel_body = template(panels_n['template'], **k)
panel = template('sidebar/panel',
body=panel_body,
**panels_n)
sidebar_panels.append(panel)
sidebar_template = template('sidebar/sidebar_ui', panels=''.join(sidebar_panels))
return sidebar_template
def page_edit(page_id):
'''
UI for editing a page in a blog
'''
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
status = None
referer = request.headers.get('Referer')
if (referer is None
or page.modified_date is None
or re.match(re.escape(BASE_URL + "/blog/" + str(page.blog.id)), referer) is None):
referer = BASE_URL + "/blog/" + str(page.blog.id)
if page.modified_date is None:
status = utils.Status(
type='info',
message="Page <b>{}</b> created.".format(page.for_log))
page.modified_date = datetime.datetime.utcnow()
page.save(user)
tags = template_tags(page=page,
user=user,
status=status)
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
tpl = template('edit/page',
menu=generate_menu('edit_page', page),
parent_path=referer,
# search_context=(search_context['blog'], page.blog),
html_editor_settings=html_editor_settings(page.blog),
sidebar=sidebar.render_sidebar(
panel_set='edit_page',
status_badge=status_badge,
save_action_list=save_action_list,
save_action=save_action,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__),
msg_float=False,
**tags.__dict__)
logger.info("Page {} opened for editing by {}.".format(
page.for_log,
user.for_log))
return tpl
def template_edit_output(tags):
return template('edit/template',
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__),
**tags.__dict__)
def login():
'''
User login interface
'''
tpl = template('ui/ui_login',
**template_tags().__dict__)
logger.info("Login page requested from IP {}.".format(request.remote_addr))
response.delete_cookie("login", path="/")
return tpl
def get_handler(controller="init", args=""):
ctrl = controller.lower()
args = args.split("/")
try:
controller = importlib.import_module("controllers.{}".format(ctrl))
except ImportError:
return template("error", ctrl=ctrl)
try:
controller = getattr(controller, ctrl.title())
except AttributeError:
raise ValueError("There is no \"{}\" controller class."\
.format(ctrl.title()))
return controller().run(*args)
def blog_settings_output(tags):
from core.libs import pytz
timezones = pytz.all_timezones
path = '/blog/{}/settings/'.format(tags.blog.id)
return template(
'ui/ui_blog_settings',
# search_context=(search_context['blog'], tags.blog),
timezones=timezones,
menu=generate_menu('blog_settings', tags.blog),
nav_tabs=(('basic', path + 'basic', 'Basic'), ('dirs', path + 'dirs',
'Directories')),
**tags.__dict__)
def plugin_settings(plugin_id, errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
plugin = Plugin.get(Plugin.id == plugin_id)
tags = template_tags(user=user)
tpl = template('system/plugin',
plugin_ui=plugin.ui(),
search_context=(search_contexts['sites'], None),
menu=generate_menu('system_plugin_data', plugin),
**tags.__dict__)
return tpl
def page_media_delete(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)
media_reference = MediaAssociation.get(MediaAssociation.page == page,
MediaAssociation.media == media)
media_reference.delete_instance(recursive=True, delete_nullable=True)
tags = template_tags(page=page)
return template('edit/page_media_list.tpl', **tags.__dict__)
def page_edit(page_id):
'''
UI for editing a page in a blog
'''
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
status = None
referer = request.headers.get('Referer')
if (referer is None or page.modified_date is None
or re.match(re.escape(BASE_URL + "/blog/" + str(page.blog.id)),
referer) is None):
referer = BASE_URL + "/blog/" + str(page.blog.id)
if page.modified_date is None:
status = utils.Status(type='info',
message="Page <b>{}</b> created.".format(
page.for_log))
page.modified_date = datetime.datetime.utcnow()
page.save(user)
tags = template_tags(page=page, user=user, status=status)
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
tpl = template(
'edit/page',
menu=generate_menu('edit_page', page),
parent_path=referer,
# search_context=(search_context['blog'], page.blog),
html_editor_settings=html_editor_settings(page.blog),
sidebar=sidebar.render_sidebar(panel_set='edit_page',
status_badge=status_badge,
save_action_list=save_action_list,
save_action=save_action,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__),
msg_float=False,
**tags.__dict__)
logger.info("Page {} opened for editing by {}.".format(
page.for_log, user.for_log))
return tpl
def blog_settings_output(tags):
from core.libs import pytz
timezones = pytz.all_timezones
path = '/blog/{}/settings/'.format(tags.blog.id)
return template('ui/ui_blog_settings',
# search_context=(search_context['blog'], tags.blog),
timezones=timezones,
menu=generate_menu('blog_settings', tags.blog),
nav_tabs=(
('basic', path + 'basic', 'Basic'),
('dirs', path + 'dirs', 'Directories')
),
**tags.__dict__)
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 plugin_settings(plugin_id, errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
plugin = Plugin.get(Plugin.id == plugin_id)
tags = template_tags(
user=user)
tpl = template('system/plugin',
plugin_ui=plugin.ui(),
search_context=(search_contexts['sites'], None),
menu=generate_menu('system_plugin_data', plugin),
**tags.__dict__)
return tpl
def page_media_add(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
media_list = Media.select().where(Media.blog == page.blog)
tags = template_tags(page=page, user=user)
return template('modal/modal_images.tpl',
media_list=media_list,
title="Select media",
buttons='',
**tags.__dict__)
def tag_make_for_media(media_id=None, tag=None):
user = auth.is_logged_in(request)
media = Media.load(media_id)
permission = auth.is_media_owner(user, media)
if tag == None:
tag_name = request.forms.getunicode('tag')
else:
tag_name = tag
if len(tag_name) < 1:
return None
# Note that this is a single tag only!
tag = Tag.add_or_create((tag_name, ), media=media)
if len(tag[0]) > 0:
tpl = template(tag[0][0].new_tag_for_display)
else:
tpl = template(tag[1][0].for_display)
return tpl
def new_category(blog_id):
from core.models import db
with db.atomic() as txn:
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_editor(user, blog)
category_list = [n for n in blog.categories]
category = Category(id=0, title='', blog=blog)
top_level_category = Category(id=None,
title='[Top-level category]',
parent=None)
category_list.insert(0, top_level_category)
tags = template_tags(blog=blog, user=user)
if request.method == "POST":
with db.atomic() as txn:
category_title = request.forms.getunicode('category_title')
try:
parent_category = int(
request.forms.getunicode('category_parent'))
except ValueError:
parent_category = None
with db.atomic() as txn:
category = Category(blog=blog,
title=category_title,
parent_category=parent_category)
category.save()
redirect('{}/blog/{}/category/{}'.format(BASE_URL, blog.id,
category.id))
tpl = template('edit/category',
category=category,
category_list=category_list,
menu=generate_menu('blog_new_category', category),
search_context=(search_contexts['sites'], None),
**tags.__dict__)
return tpl
def page_revisions(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
tags = template_tags(page=page)
try:
tpl = template('modal/modal_revisions',
title='Revisions for page #{}'.format(page.id),
buttons='',
**tags.__dict__)
except:
raise
return tpl
def page_revisions(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
tags = template_tags(page=page)
try:
tpl = template('modal/modal_revisions',
title='Revisions for page #{}'.format(page.id),
buttons='',
**tags.__dict__)
except:
raise
return tpl
def page_revision_restore(page_id, revision_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page_revision = PageRevision.select().where(PageRevision.id == revision_id).get()
status = utils.Status(
type='success',
message='Page <b>{}</b> has been restored from backup dated {}.'.format(page.for_log,
page_revision.modified_date)
)
tags = template_tags(page=page,
user=user,
status=status)
page_revision.id = page.id
tags.page = page_revision
referer = BASE_URL + "/blog/" + str(page.blog.id)
# from core.cms import save_action_list
# from core.ui_kv import kv_ui
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
# TODO: save action from this doesn't trigger queue run
tpl = template('edit/page',
status_badge=status_badge,
save_action=save_action,
menu=generate_menu('edit_page', page),
search_context=(search_contexts['blog'], page.blog),
html_editor_settings=html_editor_settings(page.blog),
sidebar=sidebar.render_sidebar(
panel_set='edit_page',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__
),
**tags.__dict__)
return tpl
def kv_response(object_name, object_type, object_identifier, object_id):
# from core.ui_kv import kv_ui
from core.ui import kv
from core.models import template_tags
tag_args = {}
tag_args[object_identifier] = object_id
tags = template_tags(**tag_args)
kv_ui_data = kv.ui(tags.__dict__[object_type].kv_list())
tpl = template('sidebar/kv',
kv_ui=kv_ui_data,
kv_object=object_name,
kv_objectid=object_id,
**tags.__dict__)
return tpl
def page_media_add(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
media_list = Media.select().where(
Media.blog == page.blog)
tags = template_tags(page=page,
user=user)
return template('modal/modal_images.tpl',
media_list=media_list,
title="Select media",
buttons='',
**tags.__dict__)
def page_media_delete(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)
media_reference = MediaAssociation.get(
MediaAssociation.page == page,
MediaAssociation.media == media)
media_reference.delete_instance(recursive=True,
delete_nullable=True)
tags = template_tags(page=page)
return template('edit/page_media_list.tpl',
**tags.__dict__)
def kv_response(object_name, object_type, object_identifier, object_id):
# from core.ui_kv import kv_ui
from core.ui import kv
from core.models import template_tags
tag_args = {}
tag_args[object_identifier] = object_id
tags = template_tags(**tag_args)
kv_ui_data = kv.ui(tags.__dict__[object_type].kv_list())
tpl = template('sidebar/kv',
kv_ui=kv_ui_data,
kv_object=object_name,
kv_objectid=object_id,
**tags.__dict__)
return tpl
def page_revision_restore(page_id, revision_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page_revision = PageRevision.select().where(
PageRevision.id == revision_id).get()
status = utils.Status(
type='success',
message='Page <b>{}</b> has been restored from backup dated {}.'.
format(page.for_log, page_revision.modified_date))
tags = template_tags(page=page, user=user, status=status)
page_revision.id = page.id
tags.page = page_revision
referer = BASE_URL + "/blog/" + str(page.blog.id)
# from core.cms import save_action_list
# from core.ui_kv import kv_ui
from core.ui import kv
kv_ui_data = kv.ui(page.kv_list())
# TODO: save action from this doesn't trigger queue run
tpl = template('edit/page',
status_badge=status_badge,
save_action=save_action,
menu=generate_menu('edit_page', page),
search_context=(search_contexts['blog'], page.blog),
html_editor_settings=html_editor_settings(page.blog),
sidebar=sidebar.render_sidebar(
panel_set='edit_page',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
kv_ui=kv_ui_data,
kv_object='Page',
kv_objectid=page.id,
**tags.__dict__),
**tags.__dict__)
return tpl
def edit_user(edit_user, **ka):
context = ka.get('context')
editing_user = ka.get('editing_user', edit_user)
site = ka.get('site')
blog = ka.get('blog')
tags = ka.get('tags')
tags.nav_default = context['nav_default']
tags.nav_tabs = context['nav_tabs']
tpl = template('edit/user_settings',
edit_user=edit_user,
menu=generate_menu('system_edit_user', edit_user),
search_context=(search_contexts['sites'], None),
context=None,
**tags.__dict__)
return tpl
def page_revision_restore_save(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
tags = save_page(page, user, page.blog)
from core.cms import save_action_list
tpl = template('edit/page_ajax',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
sidebar='',
**tags.__dict__)
response.add_header('X-Redirect', BASE_URL + '/page/{}/edit'.format(str(tags.page.id)))
return tpl
def page_revision_restore_save(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
tags = save_page(page, user, page.blog)
from core.cms import save_action_list
tpl = template('edit/page_ajax',
status_badge=status_badge,
save_action=save_action,
save_action_list=save_action_list,
sidebar='',
**tags.__dict__)
response.add_header('X-Redirect',
BASE_URL + '/page/{}/edit'.format(str(tags.page.id)))
return tpl
def blog_create_user(blog_id):
'''
Creates a user and gives it certain permissions within the context of a given blog
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
tags = template_tags(blog_id=blog.id,
user=user)
edit_user = Struct()
edit_user.name = ""
edit_user.email = ""
return template('edit/user_settings',
section_title="Create new blog user",
# search_context=(search_context['sites'], None),
edit_user=edit_user,
**tags.__dict__
)
def edit_user(edit_user, **ka):
context = ka.get('context')
editing_user = ka.get('editing_user', edit_user)
site = ka.get('site')
blog = ka.get('blog')
tags = ka.get('tags')
tags.nav_default = context['nav_default']
tags.nav_tabs = context['nav_tabs']
tpl = template('edit/user_settings',
edit_user=edit_user,
menu=generate_menu('system_edit_user', edit_user),
search_context=(search_contexts['sites'], None),
context=None,
**tags.__dict__
)
return tpl
def kv_edit(kv_id):
user = auth.is_logged_in(request)
from core import models
kv = models.KeyValue.get(
models.KeyValue.id == kv_id)
object_with_kv = models.__dict__[kv.object]
object_instance = object_with_kv.get(
object_with_kv.id == kv.objectid)
security = auth.__dict__[object_with_kv.security](user, object_instance)
if request.method == 'POST':
kv.key = request.forms.getunicode('key')
kv.value = request.forms.getunicode('value')
kv.save()
return kv_response(kv.object, objmap[kv.object][0],
objmap[kv.object][1], object_instance.id)
# return kv_list from kv_response above
from core.ui.page import media_buttons
buttons = media_buttons.format(
'onclick="save_kv_changes();"',
'Save changes')
tpl = template('modal/modal_kv_edit',
key=kv.key,
value=kv.value,
kv=kv,
title='Edit KV #{} (on {} #{})'.format(kv.id,
kv.object, kv.objectid),
buttons=buttons
)
# save button formatting is odd, fix that
return tpl
def blog_break_queue(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
Queue.stop(blog)
tags = template_tags(blog=blog,
user=user)
return template('queue/queue_run_ui',
start=None,
action_url='',
start_message='''
<p>Queue publishing stopped. Note that queued items are still in the queue,
and may still be processed on the next queue run.</p>
<p><a href="{}/blog/{}/queue/clear"><button class="btn">Clear the queue</button></a> to remove them entirely.</p>
'''.format(BASE_URL, blog_id),
title='Publishing queue progress',
# search_context=(search_context['blog_queue'], blog),
menu=generate_menu('blog_queue', blog),
**tags.__dict__)
def system_info():
# alt. implementation, less boilerplate?
# user, permission = auth.is_sys_admin()
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
tags = template_tags(
user=user)
python_list = []
environ_list = []
settings_list = []
# Generate interpreter info
import os
data = os.environ.__dict__['_data']
for n in data:
environ_list.append((n, data[n]))
# List all settings variables
import settings
s_dict = settings.__dict__
for n in s_dict:
if n is not '__builtins__':
settings_list.append((n, s_dict[n]))
# List all plugins
tpl = template('ui/ui_system_info',
menu=generate_menu('system_info', None),
search_context=(search_contexts['sites'], None),
environ_list=sorted(environ_list),
settings_list=sorted(settings_list),
**tags.__dict__)
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
