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 page_media_upload_confirm(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
# get file NAMES, attributes, size, etc. first
# request.form.getunicode('filename')
# check each one on the SERVER side, not the client
# if each file is OK, then respond appropriately and have the client send the whole file
# if not, respond with a warning to be added to the notification area
_g = request.forms.getunicode
file_name = _g('filename')
file_size = _g('filesize')
# check for file types against master list
# check for file length
# check for name collision
for n in request.files:
x = request.files.get(n)
file_path = _join(page.blog.path, page.blog.media_path_generated,
x.filename)
if _exists(file_path):
pass
else:
pass
def kv_remove():
user = auth.is_logged_in(request)
kv_to_delete = int(request.forms.getunicode('kv'))
from core.models import KeyValue
object_type = KeyValue.get(KeyValue.id == kv_to_delete)
from core import models
object_to_delete_from = models.__dict__[object_type.object]
object_instance = object_to_delete_from.get(
object_to_delete_from.id == object_type.objectid)
security = auth.__dict__[object_to_delete_from.security](user,
object_instance)
# TODO: replace with kv_del?
kv_delete = KeyValue.delete().where(KeyValue.id == kv_to_delete)
kv_deleted = kv_delete.execute()
return kv_response(object_type.object, objmap[object_type.object][0],
objmap[object_type.object][1], object_instance.id)
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 kv_remove():
user = auth.is_logged_in(request)
kv_to_delete = int(request.forms.getunicode('kv'))
from core.models import KeyValue
object_type = KeyValue.get(
KeyValue.id == kv_to_delete)
from core import models
object_to_delete_from = models.__dict__[object_type.object]
object_instance = object_to_delete_from.get(
object_to_delete_from.id == object_type.objectid)
security = auth.__dict__[object_to_delete_from.security](user, object_instance)
# TODO: replace with kv_del?
kv_delete = KeyValue.delete().where(
KeyValue.id == kv_to_delete)
kv_deleted = kv_delete.execute()
return kv_response(object_type.object, objmap[object_type.object][0],
objmap[object_type.object][1], object_instance.id)
def kv_add():
user = auth.is_logged_in(request)
kv_object = request.forms.getunicode('kv_object')
kv_object_id = int(request.forms.getunicode('kv_objectid'))
key = request.forms.getunicode('kv_new_key_name')
value = request.forms.getunicode('kv_new_key_value')
from core import models
object_to_add_to = models.__dict__[kv_object]
object_instance = object_to_add_to.get(
object_to_add_to.id == kv_object_id)
security = auth.__dict__[object_to_add_to.security](user, object_instance)
added_kv = object_instance.kv_set(
# object=kv_object,
# objectid=kv_object_id,
key=key,
value=value)
return kv_response(kv_object, objmap[kv_object][0],
objmap[kv_object][1], kv_object_id)
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 delete_category(blog_id, category_id, confirm='N'):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
category = Category.load(category_id, blog_id=blog.id)
auth.check_category_editing_lock(blog)
tags = template_tags(blog=blog, user=user)
from core.utils import Status
if request.forms.getunicode('confirm') == user.logout_nonce:
message = 'Category {} successfully deleted'.format(category.for_log)
url = '{}/blog/{}/categories'.format(BASE_URL, blog.id)
action = 'Return to the category listing'
reparent_categories = Category.update(
parent_category=category.parent_category).where(
Category.parent_category == category)
reparent_categories.execute()
delete_category = PageCategory.delete().where(
PageCategory.category == category.id)
delete_category.execute()
category.delete_instance()
tags.status = Status(type='success',
message=message,
action=action,
url=url,
close=False)
else:
message = (
'You are about to delete category <b>{}</b> from blog <b>{}</b>.'.
format(category.for_display, blog.for_display))
yes = {
'label': 'Yes, delete this category',
'id': 'delete',
'name': 'confirm',
'value': user.logout_nonce
}
no = {
'label': 'No, return to category properties',
'url': '{}/blog/{}/category/{}'.format(BASE_URL, blog.id,
category.id)
}
tags.status = Status(message=message,
type='warning',
close=False,
yes=yes,
no=no)
tags.category = category
return report(tags, 'blog_delete_category', category)
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 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 delete_page_preview(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page.delete_preview()
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 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 blog_republish(blog_id, pass_id=1, item_id=0):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
data = []
# check for dirty templates?
from core import cms
from core.libs.bottle import HTTPResponse
from settings import BASE_PATH
r = HTTPResponse()
if pass_id == 1:
cms.queue.queue_ssi_actions(blog)
item_id = 0
data.append(
"<h3>Queuing <b>{}</b> for republishing, pass {}, item {}</h3><hr>"
.format(blog.for_log, pass_id, item_id))
elif pass_id == 2:
cms.queue.queue_index_actions(blog, include_manual=True)
item_id = 0
data.append(
"<h3>Queuing <b>{}</b> for republishing, pass {}, item {}</h3><hr>"
.format(blog.for_log, pass_id, item_id))
elif pass_id == 3:
total = blog.pages.published.naive().count()
pages = blog.pages.published.paginate(item_id, 20).naive()
data.append(
"<h3>Queuing <b>{}</b> for republishing, pass {}, item {} of {}</h3><hr>"
.format(blog.for_log, pass_id, item_id * 20, total))
if pages.count() > 0:
cms.queue.queue_page_actions(pages, no_neighbors=True)
item_id += 1
else:
item_id = 0
if item_id == 0:
pass_id += 1
r.body = ''.join(data)
if pass_id < 4:
r.add_header(
'Refresh',
"0;{}/blog/{}/republish/{}/{}".format(BASE_PATH, blog_id, pass_id,
item_id))
else:
r.body = "Queue insertion finished."
r.add_header('Refresh',
"0;{}/blog/{}/publish".format(BASE_PATH, blog_id))
return r
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_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 system_users():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
return listing(request, None, User.select(),
'system_users', 'system_manage_users',
user=user)
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 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 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 delete_page_preview(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
page.delete_preview()
def blog_delete_preview(blog_id, preview_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
f = lambda:None
f.blog = blog
if preview_id == 'all':
previews_to_delete = blog.fileinfos.where(FileInfo.preview_path.is_null(False))
message = 'All previews for blog {} deleted.'.format(blog.for_display)
f.msg = 'Delete all'
else:
previews_to_delete = blog.fileinfos.where(FileInfo.id == preview_id)
message = 'Preview for fileinfo {} deleted.'.format(preview_id)
f.msg = 'Delete preview {}'.format(preview_id)
for n in previews_to_delete:
if n.page is not None:
n.page.delete_preview()
else:
n.template_mapping.template.delete_preview()
tags = template_tags(blog_id=blog.id, user=user)
from core.utils import Status
tags.status = Status(
type='success',
message=message,
close=False,
)
return report(tags, 'blog_delete_preview', f)
def page_media_upload_confirm(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
# get file NAMES, attributes, size, etc. first
# request.form.getunicode('filename')
# check each one on the SERVER side, not the client
# if each file is OK, then respond appropriately and have the client send the whole file
# if not, respond with a warning to be added to the notification area
_g = request.forms.getunicode
file_name = _g('filename')
file_size = _g('filesize')
# check for file types against master list
# check for file length
# check for name collision
for n in request.files:
x = request.files.get(n)
file_path = _join(page.blog.path, page.blog.media_path_generated, x.filename)
if _exists(file_path):
pass
else:
pass
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 media_edit(blog_id, media_id, status=None):
'''
UI for editing a given media entry
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
is_member = auth.is_blog_member(user, blog)
media = Media.load(media_id, blog)
permission = auth.is_media_owner(user, media)
from core.ui import kv
kv_ui_data = kv.ui(media.kv_list())
tags = template_tags(blog=blog,
media=media,
status=status,
user=user,
)
tags.sidebar = sidebar.render_sidebar(
panel_set='edit_media',
status_badge=status_badge,
kv_object='Media',
kv_objectid=media.id,
kv_ui=kv_ui_data)
return media_edit_output(tags)
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 media_edit(blog_id, media_id, status=None):
'''
UI for editing a given media entry
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
is_member = auth.is_blog_member(user, blog)
media = Media.load(media_id, blog)
permission = auth.is_media_owner(user, media)
from core.ui import kv
kv_ui_data = kv.ui(media.kv_list())
tags = template_tags(
blog=blog,
media=media,
status=status,
user=user,
)
tags.sidebar = sidebar.render_sidebar(panel_set='edit_media',
status_badge=status_badge,
kv_object='Media',
kv_objectid=media.id,
kv_ui=kv_ui_data)
return media_edit_output(tags)
def system_sites(errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
return listing(request, None, Site.select(),
'all_sites', 'manage_sites',
user=user)
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 system_log():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
log = Log.select().order_by(Log.date.desc(), Log.id.desc())
return listing(request, None, log,
'system_log', 'system_log',
user=user)
def site_info():
'''
Route for site installation information
'''
user = auth.is_logged_in(request)
admin = auth.is_sys_admin(user)
from core.ui import system
return system.system_info()
def site_user(user_id, site_id):
# Obtains user edit in site context.
user = auth.is_logged_in(request)
site = Site.load(site_id)
permission = auth.is_site_admin(user, site)
user_to_edit = User.find(user_id)
return edit_user(user_to_edit, editing_user=user, context=site_context, site=site)
def site_info():
'''
Route for site installation information
'''
user = auth.is_logged_in(request)
admin = auth.is_sys_admin(user)
from core.ui import system
return system.system_info()
def blog_user(user_id, blog_id):
# Obtains user edit in blog context.
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
user_to_edit = User.find(user_id)
return edit_user(user_to_edit, editing_user=user, context=blog_context, blog=blog)
def system_queue():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
queue = Queue.select().order_by(Queue.site.asc(), Queue.blog.asc(),
Queue.job_type.asc(),
Queue.date_touched.desc())
return listing(request, None, queue, 'queue', 'system_queue', user=user)
def media_edit_save(blog_id, media_id):
'''
Save changes to a media entry.
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
is_member = auth.is_blog_member(user, blog)
media = Media.load(media_id)
permission = auth.is_media_owner(user, media)
friendly_name = request.forms.getunicode('media_friendly_name')
changes = False
if friendly_name != media.friendly_name:
changes = True
media.friendly_name = friendly_name
import datetime
if changes is True:
media.modified_date = datetime.datetime.utcnow()
media.save()
status = utils.Status(
type='success',
message='Changes to media <b>{}</b> saved successfully.'.format(
media.for_display)
)
else:
status = utils.Status(
type='warning',
no_sure=True,
message='No discernible changes submitted for media <b>{}</b>.'.format(
media.id, media.for_display)
)
logger.info("Media {} edited by user {}.".format(
media.for_log,
user.for_log))
from core.ui import kv
kv_ui_data = kv.ui(media.kv_list())
tags = template_tags(blog=blog,
media=media,
status=status,
user=user)
tags.sidebar = sidebar.render_sidebar(
panel_set='edit_media',
status_badge=status_badge,
kv_object='Media',
kv_objectid=media.id,
kv_ui=kv_ui_data)
return media_edit_output(tags)
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 blog_queue_clear(blog_id):
'''
Clear all pending jobs out of the queue
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
Queue.clear(blog)
def blog_queue_clear(blog_id):
'''
Clear all pending jobs out of the queue
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
Queue.clear(blog)
def system_queue():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
queue = Queue.select().order_by(Queue.site.asc(), Queue.blog.asc(), Queue.job_type.asc(),
Queue.date_touched.desc())
return listing(request, None, queue,
'queue', 'system_queue',
user=user)
def system_list_themes():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
from core.models import Theme
return listing(request, None, Theme.select().order_by(Theme.id),
'themes_site', 'system_manage_themes',
user=user,
)
def system_plugins(errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
plugins = Plugin.select()
return listing(request, None, plugins,
'plugins', 'system_plugins',
user=user)
def system_users():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
return listing(request,
None,
User.select(),
'system_users',
'system_manage_users',
user=user)
def register_plugin(plugin_path):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
from core.plugins import register_plugin, PluginImportError
try:
new_plugin = register_plugin(plugin_path)
except PluginImportError as e:
return (str(e))
return ("Plugin " + new_plugin.friendly_name + " registered.")
def system_sites(errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
return listing(request,
None,
Site.select(),
'all_sites',
'manage_sites',
user=user)
def register_plugin(plugin_path):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
from core.plugins import register_plugin, PluginImportError
try:
new_plugin = register_plugin(plugin_path)
except PluginImportError as e:
return (str(e))
return ("Plugin " + new_plugin.friendly_name + " registered.")
def site_user(user_id, site_id):
# Obtains user edit in site context.
user = auth.is_logged_in(request)
site = Site.load(site_id)
permission = auth.is_site_admin(user, site)
user_to_edit = User.find(user_id)
return edit_user(user_to_edit,
editing_user=user,
context=site_context,
site=site)
def blog_user(user_id, blog_id):
# Obtains user edit in blog context.
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
user_to_edit = User.find(user_id)
return edit_user(user_to_edit,
editing_user=user,
context=blog_context,
blog=blog)
def blog_list_users(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
return listing(request, blog, blog.users,
'blog_users', 'blog_list_users',
user=user,
tags_data={'blog':blog}
)
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 system_plugins(errormsg=None):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
plugins = Plugin.select()
return listing(request,
None,
plugins,
'plugins',
'system_plugins',
user=user)
def system_theme_download(theme_id):
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
from core.models import Theme
theme = Theme.load(theme_id)
import shutil, tempfile, os
from core.libs.bottle import static_file
with tempfile.TemporaryDirectory() as temp_zipdir:
zip_filename = 'theme_{}'.format(theme.id)
shutil.make_archive(os.path.join(temp_zipdir, zip_filename), 'zip', theme.path)
return static_file('{}.zip'.format(zip_filename), root=temp_zipdir, download=True)
def blog_list_users(blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
return listing(request,
blog,
blog.users,
'blog_users',
'blog_list_users',
user=user,
tags_data={'blog': blog})
def blog_settings(blog_id, nav_setting):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
auth.check_settings_lock(blog)
tags = template_tags(blog_id=blog.id, user=user)
tags.nav_default = nav_setting
return blog_settings_output(tags)
def system_list_themes():
user = auth.is_logged_in(request)
permission = auth.is_sys_admin(user)
from core.models import Theme
return listing(
request,
None,
Theme.select().order_by(Theme.id),
'themes_site',
'system_manage_themes',
user=user,
)
def self_setting():
user = auth.is_logged_in(request)
setting_key = request.forms.getunicode('key')
setting_value = request.forms.getunicode('value')
kv_to_set = user.kv(setting_key)
if kv_to_set is None:
user.kv_set(setting_key, setting_value)
else:
kv_to_set.value = setting_value
kv_to_set.save()
return
def media_edit_save(blog_id, media_id):
'''
Save changes to a media entry.
'''
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
is_member = auth.is_blog_member(user, blog)
media = Media.load(media_id)
permission = auth.is_media_owner(user, media)
friendly_name = request.forms.getunicode('media_friendly_name')
changes = False
if friendly_name != media.friendly_name:
changes = True
media.friendly_name = friendly_name
import datetime
if changes is True:
media.modified_date = datetime.datetime.utcnow()
media.save()
status = utils.Status(
type='success',
message='Changes to media <b>{}</b> saved successfully.'.format(
media.for_display))
else:
status = utils.Status(
type='warning',
no_sure=True,
message='No discernible changes submitted for media <b>{}</b>.'.
format(media.id, media.for_display))
logger.info("Media {} edited by user {}.".format(media.for_log,
user.for_log))
from core.ui import kv
kv_ui_data = kv.ui(media.kv_list())
tags = template_tags(blog=blog, media=media, status=status, user=user)
tags.sidebar = sidebar.render_sidebar(panel_set='edit_media',
status_badge=status_badge,
kv_object='Media',
kv_objectid=media.id,
kv_ui=kv_ui_data)
return media_edit_output(tags)
def tag_get(blog_id, tag_name):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_member(user, blog)
tag_name = url_unescape(tag_name)
tag_list = Tag.select().where(Tag.tag.contains(tag_name), Tag.blog == blog)
import json
tag_list_json = json.dumps([{'tag': t.tag, 'id': t.id} for t in tag_list])
return tag_list_json
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
