def delete_post(num):
"""
Delete a post
"""
if num is None:
return render_template('noink_message.html', state=get_state(),
title=_('No entry specified!'),
message=_('You have not supplied an entry to delete.'))
entry_db = EntryDB()
entry = entry_db.find_by_id(num)
if entry is None:
return render_template('noink_message.html', state=get_state(),
title=_('Entry not found!'),
message=_('The entry "{0}" was not found!'.format(num)))
if not is_deletable(entry):
return render_template('noink_message.html', state=get_state(),
title=_('Unable to delete entry!'),
message=_('You do not have permission to delete this entry!'))
if request.method == 'POST':
if "delete" in request.form:
entry_db.delete(entry)
flash(_('Entry "{0}" deleted!'.format(num)))
return redirect(url_for('list_entries.show'))
elif "cancel" in request.form:
return redirect(url_for("node.show_node", num=num))
return render_template('delete_post.html', state=get_state(),
entry=entry, is_edit=True)
def show(tag):
'''
Renders a page containing those entries defined by tag. If tag is None,
will yield all entries.
'''
page_num = int(request.args.get('page', 0))
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
entryDB = EntryDB()
if tag:
entries = entryDB.find_by_tags([tag])
static_entries = None
count = per_page
else:
entries = entryDB.find_recent_by_num(per_page, page_num * per_page)
static_entries = None
if page_num == 0:
static_entries = entryDB.find_static()
count = entryDB.count()
total_pages = 0
if count > per_page:
total_pages = int(ceil(float(count) / float(per_page)))
return render_template('list_entries.html', entries=entries,
state=get_state(), page_num=page_num, total_pages=total_pages,
static_entries=static_entries)
class SimpleEntries:
def __init__(self):
self.testMain = testMain()
self.userDB = UserDB()
self.entryDB = EntryDB()
self.roleDB = RoleDB()
u = self.userDB.add("criswell", "password", "Sam Hart")
u1 = self.userDB.add("charles", "password", "Charles Xavier")
u2 = self.userDB.add("leif", "password", "Lief Ericsson")
u3 = self.userDB.add("barf", "password", "Barfy Barferson")
u4 = self.userDB.add("squiddy", "password", "Squidward Tentacles")
editors = ['charles', 'leif', 'barf', 'squiddy']
all_groups = ['junkbar', 'dollarbillyall', 'coldnwet']
for g in all_groups:
self.userDB.add_group(g)
role_names = ['tomato', 'spaghetti', 'nuts']
role_desc = ['Tomato Paste', 'Swirly Cheesy', 'Hardcore Nuts']
for x in range(len(role_names)):
self.roleDB.add_role(
role_names[x],
role_desc[x])
parents = []
for e in entries:
parent = None
if randint(0,5) > 3 and len(parents) > 1:
parent = parents[randint(0,len(parents)-1)]
print("A parent is {0}".format(parent))
try:
entry = self.entryDB.add(e[0], e[1], u, None, e[2], e[3], e[5], parent)
if e[4]:
self.entryDB.add_tag(e[4], entry)
if randint(0,5) > 2:
parents.append(entry)
if randint(0,5) > 2:
for ed in sample(editors, randint(1,len(editors)-1)):
self.entryDB.update_editor(ed, entry)
except:
print("Dropping an entry due to some entryDB problem (likely duplicate URL")
print("because of random URL generation- Should be safe to ignore)\n")
pass # stupid, but for our tests we don't care we just may get duplicate URLs
def __del__(self):
del(self.testMain)
def run(self, debug):
print("mainApp.jinja_env")
print("-----------------")
print("\nmainApp.jinja_loader")
print("___________________")
print("\n%s" % mainApp.jinja_loader.searchpath)
mainApp.run(host="0.0.0.0", debug=debug)
def test_AddEntry(self):
userDB = UserDB()
entryDB = EntryDB()
u = userDB.add("jontest", "pass", "Jon Q. Testuser")
title = 'Little Buttercup'
entry = 'There once was a man from Nantucket,' + \
'who kept his wife in a Bucket.' + \
"Wait... how'd she fit in that bucket anyway?"
e = entryDB.add(copy.deepcopy(title), entry, u)
self.assertTrue(e.title == title)
def process_entry_object(parent):
'''
Return an entry object. Does not add to db
'''
user_db = UserDB()
entry_db = EntryDB()
group_used = user_db.get_group(request.form.get('group', None))
purl = request.form.get('url', None)
if purl is not None:
t = entry_db.find_by_URL(purl)
if len(t) > 0:
flash(_("'{0}' URL is already in use!".format(purl)))
purl = None
return entry_db.create_temp_entry(
request.form.get('title', ''),
request.form.get('entry', ''),
current_user,
group_used,
int(request.form.get('weight', 0)),
purl,
bool(request.form.get('html', False)),
parent,
bool(request.form.get('static', False)))
def __init__(self):
self.__dict__ = self.__borg_state
try:
self._setup
except AttributeError:
self._setup = False
if not self._setup:
self.event_log = EventLog()
self.entry_db = EntryDB()
self.icebox_path = abspath(mainApp.config['ICEBOX_PATH'])
if mainApp.config['ICEBOX_STATIC_PATH'] is not None:
self.static_path = abspath(mainApp.config['ICEBOX_STATIC_PATH'])
else:
self.static_path = None
self.client = mainApp.test_client()
self._setup = True
def show_node(num, name):
"""
Renders a page given it's entry id
"""
entry = None
url = None
editors = None
if num < 0 and name:
entry_db = EntryDB()
try:
entry = entry_db.find_by_URL(name)[0]
except:
abort(404)
else:
entry_db = EntryDB()
entry = entry_db.find_by_id(num)
if entry == None and url == None:
abort(404)
children = []
try:
if entry is not None:
es = entry_db.find_editors_by_entry(entry.id)
if len(es) > 0:
editors = es
if entry.children:
children.append(entry)
children.extend(sorted(entry.children, key=lambda e: e.weight))
elif entry.parent_id is not None:
te = entry_db.find_by_id(entry.parent_id)
children.append(te)
children.extend(sorted(te.children, key=lambda e: e.weight))
except:
editors = None
#import ipdb; ipdb.set_trace()
return render_template('node.html', entry=entry, editors=editors,
state=get_state(), children=children)
def _edit_post(eid=None):
"""
Edit a post
"""
# FIXME - This method has kind of gotten monsterous. Refactor.
user_db = UserDB()
role_db = RoleDB()
entry_db = EntryDB()
if current_user.is_authenticated() and current_user.is_active():
all_groups = set(user_db.get_users_groups(current_user))
all_roles = role_db.get_roles(current_user)
role_groups = set(m.group for m in all_roles)
role_by_groups = dict(((m.group, role_db.get_activities(m.role))
for m in all_roles))
# The available groups are ones which they are both a part of AND which
# they have a role in!
avail_groups = all_groups & role_groups
groups = []
if current_user.primary_group in avail_groups:
# Make sure primary group is first in the list, if it's there
#avail_groups.remove(current_user.primary_group)
groups.append(current_user.primary_group)
groups.extend(avail_groups)
parent_group = None
parent = None
if 'parent' in request.values:
parent = entry_db.find_by_id(request.values['parent'])
parent_group = parent.group
# If everything else fails, we default to the top level
if parent_group is None:
parent_group = user_db.get_group(mainApp.config['TOP_LEVEL_GROUP'])
if parent_group in avail_groups and parent_group in role_by_groups:
if role_by_groups[parent_group].get('new_post', False):
entry = None
tags = []
if eid is None:
if request.method == "POST":
entry = process_entry_object(parent)
if "tags" in request.form:
tags = [x.strip() for x in
request.form['tags'].split(',') if x != '']
if "submit" in request.form:
entry_db.add_entry_object(entry)
if len(tags) > 0:
entry_db.add_tag(tags, entry)
return redirect(url_for('node.show_node',
num=entry.id))
else:
entry = entry_db.find_by_id(eid)
if entry is None:
return render_template('noink_message.html',
state=get_state(),
title=_('Entry not found!'),
message=_(
'The entry "{0}" was not found!'.format(eid)))
if request.method == "POST":
entry = update_entry_object(entry)
if "tags" in request.form:
tags = [x.strip() for x in
request.form['tags'].split(',') if x != '']
if "submit" in request.form:
entry_db.update_entry(entry)
entry_db.update_editor(current_user, entry)
if len(tags) > 0:
entry_db.add_tag(tags, entry)
return redirect(url_for('node.show_node',
num=entry.id))
else:
for tm in entry.tagmap:
tags.append(tm.tag.tag)
return render_template('new_post.html', state=get_state(),
groups=groups, entry=entry, tags=tags, is_edit=True,
title=_('New Post'), submit_button=_('Submit'),
preview_button=_('Preview'))
else:
return not_authorized()
else:
return not_authorized()
return render_template('noink_message.html', state=get_state(),
title=_('Not authorized'),
message=_('You must be logged in as a user to access this page!'))
class Icebox:
__borg_state = {}
def __init__(self):
self.__dict__ = self.__borg_state
try:
self._setup
except AttributeError:
self._setup = False
if not self._setup:
self.event_log = EventLog()
self.entry_db = EntryDB()
self.icebox_path = abspath(mainApp.config['ICEBOX_PATH'])
if mainApp.config['ICEBOX_STATIC_PATH'] is not None:
self.static_path = abspath(mainApp.config['ICEBOX_STATIC_PATH'])
else:
self.static_path = None
self.client = mainApp.test_client()
self._setup = True
def generate_pages(self, all_pages=False):
"""
Generate the pages.
If all_pages is True, will regenerate the entire site.
"""
if not isdir(self.icebox_path):
makedirs(self.icebox_path)
state = State()
state.icebox = True
if all_pages:
self._rebuild_site()
else:
for e in self.event_log.get_unprocessed():
if e.event in ('add_entry', 'update_entry'):
pe = depickle(e.blob)
entry = self.entry_db.find_by_id(pe.id)
if entry is not None:
self._generate_page(entry)
elif e.event == 'rebuild_static':
self._rebuild_site()
elif e.event == 'del_entry':
pe = depickle(e.blob)
self._remove_page(pe.id, pe.url)
self.event_log.mark_as_processed(e)
# Regenerate index
self._generate_index()
# Regenerate tags
self._generate_tags()
# Sync static pages
if self.static_path:
self.sync_static()
def _rebuild_site(self):
"""
Rebuild the entire site
"""
self.clear_icebox_path()
count = self.entry_db.count()
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
total_pages = int(ceil(float(count) / float(per_page)))
for i in range(total_pages):
entries = self.entry_db.find_recent_by_num(per_page,
i * per_page)
for e in entries:
self._generate_page(e)
def _generate_tags(self):
"""
Generate the tag pages.
"""
# Clean up old tags
rmfiles = glob('{0}/tag/*'.format(self.icebox_path))
for f in rmfiles:
if isfile(f):
remove(f)
all_tags = self.entry_db.get_tags()
for t in all_tags:
response = self.client.get("/tag/{0}".format(t.id),
follow_redirects=True)
html = response.data
filename = 'tag/{0}.html'.format(t.id)
self._write_page(html, filename)
def sync_static(self):
"""
Synchronize static content
"""
base_dir = "{0}/s".format(self.icebox_path)
if not isdir(base_dir):
makedirs(base_dir)
for root, dummy, files in walk(join(self.icebox_path, 's')):
for f in files:
if isfile(join(root, f)):
remove(join(root, f))
for root, dummy, files in walk(self.static_path):
for f in files:
source_name = join(root, f)
dest_name = join(join(
'{0}/s'.format(self.icebox_path),
relpath(root, self.static_path)), f)
base_dest = dirname(dest_name)
if not isdir(base_dest):
makedirs(base_dest)
link(source_name, dest_name)
def clear_icebox_path(self):
"""
Will clear the icebox path.
WARNING: This is destructive, and should only be used when you know
what you're doing. This will nuke the contents of the icebox path.
"""
rmfiles = []
for root, dirs, files in walk(self.icebox_path):
for d in dirs:
rmfiles.append(join(root, d))
for f in files:
rmfiles.append(join(root, f))
rmfiles.sort(key=len)
rmfiles.reverse()
for f in rmfiles:
if isfile(f):
remove(f)
elif isdir(f):
rmdir(f)
def _convert_url_to_path(self, url):
"""
Given a URL, convert it to a filepath.
Return filepath.
"""
if url.endswith('/'):
url += 'index.html'
else:
url += '.html'
if url.startswith('/'):
return url[1:]
else:
return url
def _generate_page(self, entry):
"""
Given an entry, will generate the page for it (including any
aliases).
"""
response = self.client.get('/node/{0}'.format(entry.id),
follow_redirects=True)
html = response.data
# First, generate the node
filename = 'node/{0}.html'.format(entry.id)
self._write_page(html, filename)
if entry.url:
filename = self._convert_url_to_path(entry.url)
self._write_page(html, filename)
def _generate_index(self):
"""
Generate the main index
"""
# First clear the old indexes out of the way
rmfiles = ['{0}/index.html'.format(self.icebox_path)]
rmfiles.extend(glob('{0}/index_page_*'.format(self.icebox_path)))
for f in rmfiles:
if isfile(f):
remove(f)
per_page = mainApp.config['NUM_ENTRIES_PER_PAGE'][0]
count = self.entry_db.count()
total_pages = 0
if count > per_page:
total_pages = int(ceil(float(count) / float(per_page)))
response = self.client.get('/', follow_redirects=True)
html = response.data
filename = 'index.html'
self._write_page(html, filename)
for i in range(total_pages):
response = self.client.get('/?page={0}'.format(i),
follow_redirects=True)
html = response.data
filename = 'index_page_{0}.html'.format(i)
self._write_page(html, filename)
def _write_page(self, html, filename):
"""
Write the actual page to filename
"""
fullname = "{0}/{1}".format(self.icebox_path, filename)
base_dir = dirname(fullname)
if not isdir(base_dir):
makedirs(base_dir)
with open(fullname, 'wb') as fd:
fd.write(html)
def _remove_page(self, entry_id, entry_url):
"""
Given an entry, will remove the page for it.
"""
node_fn = 'node/{0}.html'.format(entry_id)
if isfile(node_fn):
remove(node_fn)
if entry_url:
filename = self._convert_url_to_path(entry_url)
if isfile(filename):
remove(filename)
