def create_basename(input_string, blog):
'''
Generate a basename from a given input string.
Checks across the entire blog in question for a basename collision.
Basenames need to be unique to the filesystem for where the target files
are to be written. By default this is enforced in the database by way of a
unique column constraint.
'''
if not input_string:
input_string = "page"
basename = input_string
basename_test = create_basename_core(basename)
from core.models import Page
n = 0
while True:
try:
Page.get(Page.basename == basename_test, Page.blog == blog)
except Page.DoesNotExist:
return (basename_test[:MAX_BASENAME_LENGTH])
n += 1
basename_test = basename + "-" + str(n)
def api_hi():
from core.models import PageRevision, Page
pages = []
for n in PageRevision.select():
try:
Page.get(Page.id == n.page)
except:
pages.append(n.page)
n.delete()
return "Deleted: {}".format(pages)
def api_hi():
from core.models import PageRevision, Page
pages = []
for n in PageRevision.select():
try:
Page.get(Page.id == n.page)
except:
pages.append(n.page)
n.delete()
return "Deleted: {}".format(pages)
def _load_page(self, doc, div, issue):
dmdid = div.attrib['DMDID']
mods = dmd_mods(doc, dmdid)
page = Page()
seq_string = mods.xpath(
'string(.//mods:extent/mods:start)', namespaces=ns)
try:
page.sequence = int(seq_string)
except ValueError, e:
raise BatchLoaderException("could not determine sequence number for page from '%s'" % seq_string)
def _load_page(self, doc, div, issue):
dmdid = div.attrib['DMDID']
mods = dmd_mods(doc, dmdid)
page = Page()
seq_string = mods.xpath(
'string(.//mods:extent/mods:start)', namespaces=ns)
try:
page.sequence = int(seq_string)
except ValueError, e:
raise BatchLoaderException("could not determine sequence number for page from '%s'" % seq_string)
def create_pages(page_ids=None, count=0):
if not page_ids:
page_ids = []
count += 1
new_page_ids = []
if count >= 4:
return False
if not page_ids:
for i in range(randint(1, 2)):
page = Page(name='Page %s' % i, content='Page content %s' % i)
page.save()
new_page_ids.append(page.id)
for page_id in page_ids:
for i in range(randint(1, 3)):
page = Page(name='Page %s %s' % (page_id, i),
content='Page content %s %s' % (page_id, i),
parent_id=page_id)
page.save()
new_page_ids.append(page.id)
for i in range(3):
create_pages(page_ids=new_page_ids, count=count)
return True
def make_page(self):
root = User.objects.filter(username="******").first()
if not self.page:
club_root = Page.objects.filter(
name=settings.SITH_CLUB_ROOT_PAGE).first()
if root and club_root:
public = Group.objects.filter(
id=settings.SITH_GROUP_PUBLIC_ID).first()
p = Page(name=self.unix_name)
p.parent = club_root
p.save(force_lock=True)
if public:
p.view_groups.add(public)
p.save(force_lock=True)
if self.parent and self.parent.page:
p.parent = self.parent.page
self.page = p
self.save()
elif self.page and self.page.name != self.unix_name:
self.page.unset_lock()
self.page.name = self.unix_name
self.page.save(force_lock=True)
elif (self.page and self.parent and self.parent.page
and self.page.parent != self.parent.page):
self.page.unset_lock()
self.page.parent = self.parent.page
self.page.save(force_lock=True)
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 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 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 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 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 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_search(self, search_terms_enc, blog):
from core.models import Page
# ct = 0
if blog is not None:
blog_to_search = blog.pages.select(Page.id)
try:
search_results = (Page_Search.select(Page_Search.id).where(
Page_Search.id << blog_to_search,
Page_Search.title.contains(search_terms_enc)
| Page_Search.text.contains(search_terms_enc)).order_by(
Page_Search.id.desc()))
# .tuples())
search_results.count(
) # This statement is used to trap FTS4 errors
except Exception:
# pass
# except OperationalError as e:
# raise e
# if ct == 0:
search_results = (Page.select(Page.id).where(
Page.blog == blog,
Page.title.contains(search_terms_enc)
| Page.text.contains(search_terms_enc)).order_by(
Page.id.desc()))
# .tuples())
return search_results
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 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 site_search(self, search_terms_enc, site):
from core.models import Page, Site
# ct = 0
if site is not None:
site_to_search = Site.load(site).pages.select(Page.id).tuples()
try:
search_results = (Page_Search.select(Page_Search.id).where(
Page_Search.id << site_to_search,
Page_Search.title.contains(search_terms_enc)
| Page_Search.text.contains(search_terms_enc)).order_by(
Page_Search.id.desc()).tuples())
search_results.count(
) # This statement is used to trap FTS4 errors
except Exception:
# pass
# if ct == 0:
search_results = (Page.select(Page.id).where(
Page.blog.site == site,
Page.title.contains(search_terms_enc)
| Page.text.contains(search_terms_enc)).order_by(
Page.id.desc()).tuples())
return search_results
def blog_search(self, search_terms_enc, blog):
from core.models import Page
# ct = 0
if blog is not None:
blog_to_search = blog.pages.select(Page.id)
try:
search_results = (Page_Search.select(Page_Search.id)
.where(Page_Search.id << blog_to_search,
Page_Search.title.contains(search_terms_enc) | Page_Search.text.contains(search_terms_enc))
.order_by(Page_Search.id.desc()))
# .tuples())
search_results.count() # This statement is used to trap FTS4 errors
except Exception:
# pass
# except OperationalError as e:
# raise e
# if ct == 0:
search_results = (Page.select(Page.id)
.where(Page.blog == blog,
Page.title.contains(search_terms_enc) | Page.text.contains(search_terms_enc))
.order_by(Page.id.desc()))
# .tuples())
return search_results
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 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_search(search_terms_enc, blog):
ct = 0
if blog is not None:
blog_to_search = blog.pages().select(Page.id).tuples()
try:
search_results = (Page_Search.select(Page_Search.id).where(
Page_Search.id << blog_to_search,
Page_Search.title.contains(search_terms_enc)
| Page_Search.text.contains(search_terms_enc)).order_by(
Page_Search.id.desc()).tuples())
ct = search_results.count(
) # This statement is used to trap FTS4 errors
except OperationalError:
pass
if ct == 0:
search_results = (Page.select(Page.id).where(
Page.blog == blog,
Page.title.contains(search_terms_enc)
| Page.text.contains(search_terms_enc)).order_by(
Page.id.desc()).tuples())
return search_results
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 get_initial(self):
init = {}
if "page" in self.request.GET.keys():
page_name = self.request.GET["page"]
parent_name = "/".join(page_name.split("/")[:-1])
parent = Page.get_page_by_full_name(parent_name)
if parent is not None:
init["parent"] = parent.id
init["name"] = page_name.split("/")[-1]
return init
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 create_basename(input_string, blog):
'''
Generate a basename from a given input string.
Checks across the entire blog in question for a basename collision.
Basenames need to be unique to the filesystem for where the target files
are to be written. By default this is enforced in the database by way of a
unique column constraint.
'''
from core.models import Page
if not input_string:
input_string = "page"
basename = input_string.replace(' ', '-')
try:
basename = basename.casefold()
except BaseException:
basename = basename.lower()
basename = re.sub(r'[^a-z0-9\-]', r'', basename)
basename = re.sub(r'\-\-', r'-', basename)
basename = urllib.parse.quote_plus(basename)
basename_test = basename
n = 0
while True:
try:
Page.get(Page.basename == basename_test, Page.blog == blog)
except Page.DoesNotExist:
return (basename_test[:MAX_BASENAME_LENGTH])
n += 1
basename_test = basename + "-" + str(n)
def month_context(fileinfo, original_page, tag_context, date_counter):
if date_counter["year"] is False:
raise ArchiveMappingFormatException("An archive mapping was encountered that had a month value before a year value.", Exception)
if fileinfo is None:
month_context = original_page.publication_date_tz.month
blog = original_page.blog
else:
month_context = fileinfo.month
blog = fileinfo.template_mapping.template.blog
month_start = datetime.datetime(
year=date_counter["year"],
month=month_context,
day=1)
month_start_tz = Page._date_to_utc(None, blog.timezone,
month_start)
month_end = datetime.datetime(
year=date_counter["year"],
month=month_context,
day=last_day_of_month(month_start).day,
hour=23,
minute=59,
second=59)
month_end_tz = Page._date_to_utc(None, blog.timezone,
month_end)
tag_context_next = tag_context.select().where(
Page.publication_date >= month_start_tz,
Page.publication_date <= month_end_tz
)
date_counter["month"] = month_context
return tag_context_next, date_counter
def year_context(fileinfo, original_page, tag_context, date_counter):
if fileinfo is None:
year_context = original_page.publication_date_tz.year
blog = original_page.blog
else:
year_context = fileinfo.year
blog = fileinfo.template_mapping.template.blog
year_start = datetime.datetime(
year=year_context,
month=1,
day=1,
)
year_start_tz = Page._date_to_utc(None, blog.timezone,
year_start)
year_end = datetime.datetime(
year=year_context,
month=12,
day=31,
hour=23,
minute=59,
second=59,
)
year_end_tz = Page._date_to_utc(None, blog.timezone,
year_end)
tag_context_next = tag_context.select().where(
Page.publication_date >= year_start_tz,
Page.publication_date <= year_end_tz
)
date_counter["year"] = year_context
return tag_context_next, date_counter
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 page_preview_core(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
preview_fileinfo = page.default_fileinfo
preview_file_path, preview_url = preview_fileinfo.make_preview()
page_tags = fileinfo.generate_page_tags(preview_fileinfo, page.blog)
file_page_text = generate_page_text(preview_fileinfo, page_tags)
queue.write_file(file_page_text, page.blog.path, preview_file_path)
return preview_url, page
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_preview_core(page_id):
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
preview_fileinfo = page.default_fileinfo
preview_file_path, preview_url = preview_fileinfo.make_preview()
page_tags = fileinfo.generate_page_tags(preview_fileinfo, page.blog)
file_page_text = generate_page_text(preview_fileinfo, page_tags)
queue.write_file(file_page_text, page.blog.path, preview_file_path)
return preview_url, page
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_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 test_access_child_page_ok(self):
"""
Should display a page correctly
"""
parent = Page(name="guy", owner_group=Group.objects.filter(id=1).first())
parent.save(force_lock=True)
page = Page(
name="bibou", owner_group=Group.objects.filter(id=1).first(), parent=parent
)
page.save(force_lock=True)
response = self.client.get(
reverse("core:page", kwargs={"page_name": "guy/bibou"})
)
self.assertTrue(response.status_code == 200)
self.assertTrue(
'<a href="/page/guy/bibou/edit">\\xc3\\x89diter</a>'
in str(response.content)
)
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 page_add_media_with_template(page_id, media_id, template_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_template = Template.get(Template.id == template_id)
from core.template import tpl
generated_template = tpl(media_template.body, blog=page.blog, media=media)
if media not in page.media:
media.associate(page)
return generated_template
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 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_add_media_with_template(page_id, media_id, template_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_template = Template.get(
Template.id == template_id)
from core.template import tpl
generated_template = tpl(media_template.body,
blog=page.blog,
media=media)
if media not in page.media:
media.associate(page)
return generated_template
def reparent_page(page_id, blog_id):
with db.atomic():
page = Page.load(page_id)
blog = Blog.load(blog_id)
page.blog = blog.id
page.text += "\n" # stupid hack, we should have a force-save option
# also, have .save options kw, not args
# Reparent any existing media
# Delete any existing categories
# Migrate/re-add any existing tags
# Remove and regenerate basename, permalink, etc.
# Create new fileinfo
from core.error import PageNotChanged
try:
page.save(page.user)
except PageNotChanged:
pass
return "OK"
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 reparent_page(page_id, blog_id):
with db.atomic():
page = Page.load(page_id)
blog = Blog.load(blog_id)
page.blog = blog.id
page.text += "\n" # stupid hack, we should have a force-save option
# also, have .save options kw, not args
# Reparent any existing media
# Delete any existing categories
# Migrate/re-add any existing tags
# Remove and regenerate basename, permalink, etc.
# Create new fileinfo
from core.error import PageNotChanged
try:
page.save(page.user)
except PageNotChanged:
pass
return "OK"
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 site_search(self, search_terms_enc, site):
from core.models import Page, Site
# ct = 0
if site is not None:
site_to_search = Site.load(site).pages.select(Page.id).tuples()
try:
search_results = (Page_Search.select(Page_Search.id)
.where(Page_Search.id << site_to_search,
Page_Search.title.contains(search_terms_enc) | Page_Search.text.contains(search_terms_enc))
.order_by(Page_Search.id.desc()).tuples())
search_results.count() # This statement is used to trap FTS4 errors
except Exception:
# pass
# if ct == 0:
search_results = (Page.select(Page.id)
.where(Page.blog.site == site,
Page.title.contains(search_terms_enc) | Page.text.contains(search_terms_enc))
.order_by(Page.id.desc()).tuples())
return search_results
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_import (blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
reason = auth.check_template_lock(blog, True)
tags = template_tags(blog=blog,
user=user)
import os, settings
import_path = os.path.join(
settings.APPLICATION_PATH,
"data",
"import.json")
tags.status = reason
if request.method == "POST":
from core.models import db
tpl = ''
with db.atomic() as txn:
import json
from core.utils import string_to_date
import_path = request.forms.getunicode('import_path')
with open(import_path, 'r', encoding='utf8') as f:
json_data = json.load(f)
from core.models import page_status, MediaAssociation, Category
from core.error import PageNotChanged
from core.libs.peewee import InterfaceError
from core.cms import media_filetypes
format_str = "<b>{}</b> / (<i>{}</i>)"
# TODO: go in chunks of 50 or something?
# allow graceful disconnection?
for n in json_data:
q = []
n_id = n['id']
q.append("Checking {}".format(n_id))
changed = False
found = False
match = Page.kv_get('legacy_id', n_id)
if match.count() > 0:
if match[0].object_ref.blog == blog:
found = True
q.append(match[0].key + "/" + match[0].value + " / Exists: " + format_str.format(n['title'], n_id))
existing_entry = Page.load(match[0].objectid)
update = existing_entry.kv_get('update').count()
# raise Exception(update)
q.append('{} / {}'.format(string_to_date(n['modified_date']).replace(tzinfo=None), existing_entry.modified_date
))
if string_to_date(n['modified_date']).replace(tzinfo=None) <= existing_entry.modified_date and update == 0:
q.append('Existing page {} not changed.'.format(existing_entry.id))
else:
changed = True
q.append('Updating data for existing page {}.'.format(existing_entry.id))
existing_entry.title = n['title']
existing_entry.text = n['text']
existing_entry.basename = n['basename']
existing_entry.excerpt = n['excerpt']
existing_entry.created_date = string_to_date(n['created_date']).replace(tzinfo=None)
existing_entry.modified_date = string_to_date(n['modified_date']).replace(tzinfo=None)
existing_entry.publication_date = string_to_date(n['publication_date']).replace(tzinfo=None)
try:
existing_entry.save(user, False, False, 'New revision from import')
except PageNotChanged:
pass
except InterfaceError:
raise Exception("Error saving {}. Check the JSON to make sure it's valid.".format(n_id))
for media in existing_entry.media:
media.kv_del()
existing_entry.clear_categories()
existing_entry.clear_kvs()
existing_entry.clear_tags()
existing_entry.clear_media()
entry = existing_entry
if found is False:
q.append("Creating: " + format_str.format(n['title'], n_id))
changed = True
new_entry = Page(
title=n['title'],
text=n['text'],
basename=n['basename'],
excerpt=n['excerpt'],
user=user,
blog=blog,
created_date=string_to_date(n['created_date']),
publication_date=string_to_date(n['publication_date']),
modified_date=string_to_date(n['modified_date']),
)
new_entry.modified_date = new_entry.publication_date
if n['status'] in ('Publish', 'Published', 'Live'):
new_entry.status = page_status.published
new_entry.save(user)
entry = new_entry
q.append("New ID: {}".format(entry.id))
# Everything from here on out is
if changed:
# Register a legacy ID for the page
entry.kv_set("legacy_id", n["id"])
entry.kv_set("legacy_user", n["user_id"])
# Category assignments
categories = n['categories']
if categories == []:
saved_page_category = PageCategory.create(
page=entry,
category=blog.default_category,
primary=True).save()
else:
primary = True
for category in categories:
cat_exists = False
category_id = category['id']
existing_category = Category.kv_get('legacy_id', category_id)
if existing_category.count() > 0:
if existing_category[0].object_ref.blog == blog:
cat_exists = True
if cat_exists is False:
q.append('Created new category {}/{}'.format(
category_id, category['name']
))
new_category = Category.create(
blog=blog,
title=category['name'],
parent_category=getattr(category, 'parent', None)
)
new_category.save()
new_category.kv_set('legacy_id',
category_id
)
else:
new_category = Category.load(existing_category[0].objectid)
q.append('Added to existing category {}/{}'.format(
new_category.id, category['name']
))
saved_page_category = PageCategory.create(
page=entry,
category=new_category,
primary=primary
).save()
primary = False
# Check to make sure a default category exists for the whole blog.
# If not, assign one based on the lowest ID.
# This can always be reassigned later.
# Register tags
tags_added, tags_existing, _ = Tag.add_or_create(
n['tags'], page=entry)
q.append('Tags added: {}'.format(','.join(n.tag for n in tags_added)))
q.append('Tags existing: {}'.format(','.join(n.tag for n in tags_existing)))
# Register KVs
kvs = n['kvs']
for key in kvs:
if key != "":
value = kvs[key]
entry.kv_set(key, value)
q.append('KV: {}:{}'.format(key, value))
# Register media
media = n['media']
for m in media:
if 'path' not in m:
continue
path = os.path.split(m['path'])
try:
new_media = Media.get(Media.url == m['url'])
except:
new_media = Media(
filename=path[1],
path=m['path'],
url=m['url'],
type=media_filetypes.image,
created_date=string_to_date(m['created_date']),
modified_date=string_to_date(m['modified_date']),
friendly_name=m['friendly_name'],
user=user,
blog=blog,
site=blog.site
)
# TODO: RBF
try:
new_media.save()
except Exception:
continue
media_association = MediaAssociation(
media=new_media,
page=entry)
media_association.save()
# Save legacy ID to KV on media
if 'id' in m:
new_media.kv_set('legacy_id', m['id'])
q.append('IMG: {}'.format(new_media.url))
# add tags for media
q.append('Tags: {}'.format(m['tags']))
new_tags = Tag.add_or_create(m['tags'], media=new_media)
kvs = m['kvs']
for key in kvs:
value = kvs[key]
new_media.kv_set(key, value)
q.append('KV: {}:{}'.format(key, value))
fileinfo.build_pages_fileinfos((entry,))
fileinfo.build_archives_fileinfos((entry,))
tpl += ('<p>'.join(q)) + '<hr/>'
return tpl
# TODO:
# Import or create categories as needed
# Categories in export will need to have parent-child data
# categories should have legacy identifiers where possible too
# Import image files, assign those legacy KV identifiers
# Modify URLs for imported images in posts
# Make importing of image assets optional
else:
tpl = template('ui/ui_blog_import',
menu=generate_menu('blog_import', blog),
# search_context=(search_context['blog'], blog),
import_path=import_path,
**tags.__dict__)
return tpl
product_id = '{}, running in {}'.format(settings.PRODUCT_NAME, settings.APPLICATION_PATH)
print ('{}\nScheduled tasks script.'.format(product_id))
if nowait:
print('Ignoring insert wait.')
print ('Looking for scheduled tasks...')
from core.models import Page, page_status, Queue
blogs_to_check = {}
scheduled_page_report = []
scheduled_pages = Page.select().where(
Page.status == page_status.scheduled,
Page.publication_date <= datetime.datetime.utcnow()).order_by(
Page.publication_date.desc())
total_pages = scheduled_pages.count()
print ('{} pages scheduled'.format(total_pages))
if total_pages > 0:
for p in scheduled_pages.select(Page.blog).distinct():
b = p.blog
blogs_to_check[b.id] = b
queue_count = Queue.select(Queue.blog).distinct()
if queue_count.count() > 0:
for n in queue_count:
def save_page(page, user, blog=None):
'''
Saves edits to a page in the CMS.
Note that this function does _not_ perform permission checking. In other words, it doesn't
verify if the user described in the `user` parameter does in fact have permissions to
edit the page in question.
:param page:
Page object whose data is to be saved. If this is None, then it is assumed that we are
creating a new page.
:param user:
The user object associated with the save action for this page. If this is a newly-created page,
the page's user will be set to this.
:param blog:
The blog object under which the page will be created, if this is a newly-created page.
'''
getunicode = request.forms.getunicode
# invalidate_cache()
save_action = int(request.forms.get('save'))
original_page_status = page_status.unpublished
new_basename = getunicode('basename')
if page is None:
# CREATE NEW PAGE ENTRY
page = Page()
page.user = user.id
page.blog = blog.id
page.basename = create_basename(getunicode('page_title'),
page.blog)
original_page_basename = page.basename
time_now = datetime.datetime.utcnow()
page.publication_date = time_now
page.created_date = time_now
else:
# UPDATE EXISTING ENTRY
# Queue neighbor actions for page BEFORE modification
if page.status == page_status.published:
if not (save_action & save_action_list.UNPUBLISH_PAGE):
queue_page_actions((page.next_page, page.previous_page),no_neighbors=True, no_archive=True)
queue_page_archive_actions(page)
original_page_status = page.status
original_page_basename = page.basename
page.modified_date = datetime.datetime.utcnow()
change_basename = False
if new_basename is not None:
if new_basename == "":
change_basename = True
new_basename = create_basename(getunicode('page_title'),
page.blog)
if new_basename != original_page_basename:
change_basename = True
new_publication_date = datetime.datetime.strptime(
request.forms.get('publication_date'), DATE_FORMAT)
if change_basename:
page.basename = create_basename(new_basename, page.blog)
page.publication_date = page._date_to_utc(page.blog.timezone, new_publication_date).replace(tzinfo=None)
page.title = getunicode('page_title')
page.text = getunicode('page_text')
page.status = page_status.modes[int(request.forms.get('publication_status'))]
page.tag_text = getunicode('page_tag_text')
page.excerpt = getunicode('page_excerpt')
change_note = getunicode('change_note')
msg = []
# UNPUBLISH
if (
(save_action & save_action_list.UNPUBLISH_PAGE and page.status == page_status.published) or # unpublished a published page
(original_page_status == page_status.published and page.status == page_status.unpublished) # set a published page to draft
):
unpublish_page(page)
msg.append("Page <b>{}</b> unpublished successfully.")
# SET UNPUBLISHED TO PUBLISHED
elif original_page_status == page_status.unpublished and (save_action & save_action_list.UPDATE_LIVE_PAGE):
page.status = page_status.published
msg.append("Set to publish.")
# SAVE DRAFT
if (save_action & save_action_list.SAVE_TO_DRAFT):
try:
save_result = page.save(user, False, False, change_note)
except PageNotChanged:
save_result = (None, None)
msg.append("Page <b>{}</b> saved successfully.")
# Assign categories for page
categories = []
for n in request.forms.allitems():
if n[0][:8] == 'cat-sel-':
try:
category_id = int(n[0][8:])
except ValueError:
category_id = None
else:
categories.append(category_id)
if not categories:
categories.append(blog.default_category.id)
msg.append(" Default category auto-assigned for page.")
page_categories = []
primary = None
for n in page.categories:
if n.category.id not in categories:
delete_category = PageCategory.delete().where(
PageCategory.id == n.id)
delete_category.execute()
else:
page_categories.append(n.category.id)
if n.primary is True:
primary = n
for n in categories:
if n not in page_categories:
new_page_category = PageCategory.create(
page=page,
category=Category.load(n, blog_id=page.blog.id),
primary=False)
if primary is None:
n = page.categories[0]
n.primary = True
n.save()
delete_page_fileinfo(page)
build_archives_fileinfos((page,))
build_pages_fileinfos((page,))
# UPDATE TAGS
if getunicode('tag_text') is not None:
import json
tag_text = json.loads(getunicode('tag_text'))
add_tags_to_page(tag_text, page)
delete_orphaned_tags(page.blog)
# QUEUE CHANGES FOR PUBLICATION (if any)
if ((save_action & save_action_list.UPDATE_LIVE_PAGE)
and (page.status == page_status.published)):
queue_ssi_actions(page.blog)
queue_page_actions((page,))
queue_index_actions(page.blog)
msg.append(" Live page updated.")
# DETECT ANY PAGE CHANGES
if (
(save_action & (save_action_list.SAVE_TO_DRAFT + save_action_list.UPDATE_LIVE_PAGE))
and (save_result[1]) is None):
msg.append(" (Page unchanged.)")
# RETURN REPORT
tags = template_tags(page=page, user=user)
status = Status(
type='success',
message=' / '.join(msg),
vals=(page.for_log,)
)
tags.status = status
tags._save_action = save_action
tags._save_action_list = save_action_list
return tags
def page_delete(page_id, confirm):
'''
Deletes a selected page -- no confirmation yet
Returns user to list of pages in blog with a notice about the deleted file
'''
user = auth.is_logged_in(request)
page = Page.load(page_id)
permission = auth.is_page_editor(user, page)
blog = page.blog
from core.utils import Status
tags = template_tags(
page=page,
user=user)
from core.models import page_status
if page.status != page_status.unpublished:
message = 'Page <b>{}</b> is not set to unpublished and cannot be deleted. Unpublish this page before deleting it.'.format(
page.for_display)
url = '{}/blog/{}'.format(BASE_URL, blog.id)
action = 'Return to the page listing'
tags.status = Status(
type='danger',
no_sure=True,
message=message,
action=action,
url=url,
close=False)
else:
if request.forms.getunicode('confirm') == user.logout_nonce:
p = page.for_log
from core.cms.cms import delete_page
delete_page(page)
message = 'Page {} successfully deleted'.format(
p)
url = '{}/blog/{}'.format(BASE_URL, blog.id)
action = 'Return to the page listing'
tags.status = Status(
type='success',
message=message,
action=action,
url=url,
close=False)
logger.info("Page {} deleted by user {}.".format(
p,
user.for_log))
else:
message = ('You are about to delete page <b>{}</b> from blog <b>{}</b>.'.format(
page.for_display,
blog.for_display))
yes = {
'label':'Yes, delete this page',
'id':'delete',
'name':'confirm',
'value':user.logout_nonce}
no = {
'label':'No, return to blog page listing',
'url':'{}/blog/{}'.format(
BASE_URL, blog.id)
}
tags.status = Status(
message=message,
type='warning',
close=False,
yes=yes,
no=no
)
return report(tags, 'blog_delete_page', page)
