def do_modify(self):
method = request.method
if method in ['GET', 'HEAD']:
if isinstance(self.content, NonExistentContent):
return render_template(
'modify_select_contenttype.html',
fqname=self.fqname,
item_name=self.name,
itemtype=self.itemtype,
group_names=content_registry.group_names,
groups=content_registry.groups,
)
item = self
if isinstance(self.rev, DummyRev):
template_name = request.values.get('template')
if template_name is None:
return self._do_modify_show_templates()
elif template_name:
item = Item.create(template_name)
form = self.ModifyForm.from_item(item)
elif method == 'POST':
# XXX workaround for *Draw items
if isinstance(self.content, Draw):
try:
self.content.handle_post()
except AccessDenied:
abort(403)
else:
# *Draw Applets POSTs more than once, redirecting would
# break them
return "OK"
form = self.ModifyForm.from_request(request)
meta, data, contenttype_guessed, comment = form._dump(self)
state = dict(fqname=self.fqname,
itemid=meta.get(ITEMID),
meta=meta)
if form.validate(state):
contenttype_qs = request.values.get('contenttype')
try:
self.modify(meta, data, comment, contenttype_guessed,
**{CONTENTTYPE: contenttype_qs})
except AccessDenied:
abort(403)
else:
return redirect(url_for_item(**self.fqname.split))
help = CONTENTTYPES_HELP_DOCS[self.contenttype]
if isinstance(help, tuple):
help = self.doc_link(*help)
return render_template(
self.modify_template,
fqname=self.fqname,
item_name=self.name,
item=self,
rows_meta=str(ROWS_META),
cols=str(COLS),
form=form,
search_form=None,
help=help,
meta=item._meta_info(),
)
def do_modify(self):
method = request.method
if method in ['GET', 'HEAD']:
if isinstance(self.content, NonExistentContent):
return render_template('modify_select_contenttype.html',
fqname=self.fqname,
item_name=self.name,
itemtype=self.itemtype,
group_names=content_registry.group_names,
groups=content_registry.groups,
)
item = self
if isinstance(self.rev, DummyRev):
template_name = request.values.get('template')
if template_name is None:
return self._do_modify_show_templates()
elif template_name:
item = Item.create(template_name)
form = self.ModifyForm.from_item(item)
elif method == 'POST':
# XXX workaround for *Draw items
if isinstance(self.content, Draw):
try:
self.content.handle_post()
except AccessDenied:
abort(403)
else:
# *Draw Applets POSTs more than once, redirecting would
# break them
return "OK"
form = self.ModifyForm.from_request(request)
meta, data, contenttype_guessed, comment = form._dump(self)
state = dict(fqname=self.fqname, itemid=meta.get(ITEMID), meta=meta)
if form.validate(state):
contenttype_qs = request.values.get('contenttype')
try:
self.modify(meta, data, comment, contenttype_guessed, **{CONTENTTYPE: contenttype_qs})
except AccessDenied:
abort(403)
else:
return redirect(url_for_item(**self.fqname.split))
help = CONTENTTYPES_HELP_DOCS[self.contenttype]
if isinstance(help, tuple):
help = self.doc_link(*help)
return render_template(self.modify_template,
fqname=self.fqname,
item_name=self.name,
item=self,
rows_meta=str(ROWS_META), cols=str(COLS),
form=form,
search_form=None,
help=help,
meta=item._meta_info(),
)
def _render_data(self):
try:
from MoinMoin.converter import default_registry as reg
# TODO: Real output format
doc = self.internal_representation()
doc = self._expand_document(doc)
flaskg.clock.start("conv_dom_html")
html_conv = reg.get(type_moin_document, Type("application/x-xhtml-moin-page"))
doc = html_conv(doc)
flaskg.clock.stop("conv_dom_html")
rendered_data = conv_serialize(doc, {html.namespace: ""})
except Exception:
# we really want to make sure that invalid data or a malfunctioning
# converter does not crash the item view (otherwise a user might
# not be able to fix it from the UI).
import time
import uuid
error_id = uuid.uuid4()
logging.exception("An exception happened in _render_data (error_id = %s ):" % error_id)
rendered_data = render_template(
"crash.html", server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"), url=request.url, error_id=error_id
)
return rendered_data
def _select_itemtype(self):
return render_template('modify_select_itemtype.html',
item=self,
item_name=self.name,
fqname=self.fqname,
itemtypes=item_registry.shown_entries,
)
def item_acl_report():
"""
Return a sorted list of all items in the wiki along with the ACL Meta-data.
Item names are prefixed with the namespace, if there is a non-default namespace.
If there are multiple names, the first name is used for sorting.
"""
all_items = flaskg.storage.documents(wikiname=app.cfg.interwikiname)
items_acls = []
for item in all_items:
item_namespace = item.meta.get(NAMESPACE)
item_id = item.meta.get(ITEMID)
if item_namespace:
item_name = [item_namespace + '/' + name for name in item.meta.get(NAME)]
else:
item_name = item.meta.get(NAME)
item_acl = item.meta.get(ACL)
acl_default = item_acl is None
if acl_default:
for namespace, acl_config in app.cfg.acl_mapping:
if item_namespace == namespace:
item_acl = acl_config['default']
items_acls.append({'name': item_name,
'name_old': item.meta['name_old'],
'itemid': item_id,
'fqname': item.rev.fqname,
'fqnames': item.rev.fqnames,
'acl': item_acl,
'acl_default': acl_default})
items_acls = sorted(items_acls, key=lambda k: (k['name'], k['name_old']))
return render_template('admin/item_acl_report.html',
title_name=_('Item ACL Report'),
items_acls=items_acls)
def sitemap():
"""
Google (and others) XML sitemap
"""
def format_timestamp(t):
tm = time.gmtime(t)
return time.strftime("%Y-%m-%dT%H:%M:%S+00:00", tm)
sitemap = []
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
fqnames = rev.fqnames
mtime = rev.meta[MTIME]
# these are the content items:
changefreq = "daily"
priority = "0.5"
sitemap += [((fqname, format_timestamp(mtime), changefreq, priority)) for fqname in fqnames]
# add entries for root urls
root_mapping = [(namespace, app.cfg.root_mapping.get(namespace, app.cfg.default_root)) for namespace, _ in app.cfg.namespace_mapping]
query = Or([And([Term(NAME_EXACT, root), Term(NAMESPACE, namespace)]) for namespace, root in root_mapping])
for rev in flaskg.storage.search(q=query):
mtime = rev.meta[MTIME]
sitemap.append((rev.meta[NAMESPACE], format_timestamp(mtime), "hourly", "1.0"))
sitemap.sort()
content = render_template('misc/sitemap.xml', sitemap=sitemap)
return Response(content, mimetype='text/xml')
def sitemap():
"""
Google (and others) XML sitemap
"""
def format_timestamp(t):
tm = time.gmtime(t)
return time.strftime("%Y-%m-%dT%H:%M:%S+00:00", tm)
sitemap = []
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
name = rev.meta[NAME]
mtime = rev.meta[MTIME]
if False: # was: wikiutil.isSystemItem(name) XXX add back later, when we have that in the index
if not SITEMAP_HAS_SYSTEM_ITEMS:
continue
# system items are rather boring
changefreq = "yearly"
priority = "0.1"
else:
# these are the content items:
changefreq = "daily"
priority = "0.5"
sitemap.append((name, format_timestamp(mtime), changefreq, priority))
# add an entry for root url
root_item = app.cfg.item_root
revs = list(flaskg.storage.documents(wikiname=app.cfg.interwikiname, name=root_item))
if revs:
mtime = revs[0].meta[MTIME]
sitemap.append((u'', format_timestamp(mtime), "hourly", "1.0"))
sitemap.sort()
content = render_template('misc/sitemap.xml', sitemap=sitemap)
return Response(content, mimetype='text/xml')
def item_acl_report():
"""
Return a list of all items in the wiki along with the ACL Meta-data
"""
all_items = flaskg.storage.documents(wikiname=app.cfg.interwikiname)
items_acls = []
for item in all_items:
item_namespace = item.meta.get(NAMESPACE)
item_id = item.meta.get(ITEMID)
item_name = item.meta.get(NAME)
item_acl = item.meta.get(ACL)
acl_default = item_acl is None
fqname = CompositeName(item_namespace, u'itemid', item_id)
if acl_default:
for namespace, acl_config in app.cfg.acl_mapping:
if item_namespace == namespace[:-1]:
item_acl = acl_config['default']
items_acls.append({'name': item_name,
'itemid': item_id,
'fqname': fqname,
'acl': item_acl,
'acl_default': acl_default})
return render_template('admin/item_acl_report.html',
title_name=_('Item ACL Report'),
items_acls=items_acls)
def do_modify(self):
is_new = isinstance(self.content, NonExistentContent)
closed = self.meta.get('closed')
Form = TicketSubmitForm if is_new else TicketUpdateForm
if request.method in ['GET', 'HEAD']:
form = Form.from_item(self)
elif request.method == 'POST':
form = Form.from_request(request)
if form.validate():
meta, data = form._dump(self)
try:
self.modify(meta, data)
except AccessDenied:
abort(403)
else:
return redirect(url_for('.show_item', item_name=self.name))
# XXX When creating new item, suppress the "foo doesn't exist. Create it?" dummy content
data_rendered = None if is_new else Markup(self.content._render_data())
return render_template(self.submit_template if is_new else self.modify_template,
is_new=is_new,
closed=closed,
item_name=self.name,
data_rendered=data_rendered,
form=form,
)
def wikiconfighelp():
def format_default(default):
if isinstance(default, defaultconfig.DefaultExpression):
default_txt = default.text
else:
default_txt = repr(default)
if len(default_txt) > 30:
default_txt = '...'
return default_txt
groups = []
for groupname in defaultconfig.options:
heading, desc, opts = defaultconfig.options[groupname]
opts = sorted([(groupname + '_' + name, format_default(default), description)
for name, default, description in opts])
groups.append((heading, desc, opts))
for groupname in defaultconfig.options_no_group_name:
heading, desc, opts = defaultconfig.options_no_group_name[groupname]
opts = sorted([(name, format_default(default), description)
for name, default, description in opts])
groups.append((heading, desc, opts))
groups.sort()
return render_template('admin/wikiconfighelp.html',
title_name=_(u"Wiki Configuration Help"),
groups=groups)
def _render_data(self):
try:
from MoinMoin.converter import default_registry as reg
# TODO: Real output format
doc = self.internal_representation()
doc = self._expand_document(doc)
flaskg.clock.start('conv_dom_html')
html_conv = reg.get(type_moin_document,
Type('application/x-xhtml-moin-page'))
doc = html_conv(doc)
flaskg.clock.stop('conv_dom_html')
rendered_data = conv_serialize(doc, {html.namespace: ''})
except Exception:
# we really want to make sure that invalid data or a malfunctioning
# converter does not crash the item view (otherwise a user might
# not be able to fix it from the UI).
import time
import uuid
error_id = uuid.uuid4()
logging.exception(
"An exception happened in _render_data (error_id = %s ):" %
error_id)
rendered_data = render_template(
'crash.html',
server_time=time.strftime("%Y-%m-%d %H:%M:%S %Z"),
url=request.url,
error_id=error_id)
return rendered_data
def sitemap():
"""
Google (and others) XML sitemap
"""
def format_timestamp(t):
tm = time.gmtime(t)
return time.strftime("%Y-%m-%dT%H:%M:%S+00:00", tm)
sitemap = []
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
fqnames = rev.fqnames
mtime = rev.meta[MTIME]
# these are the content items:
changefreq = "daily"
priority = "0.5"
sitemap += [(fqname, format_timestamp(mtime), changefreq, priority) for fqname in fqnames]
# add entries for root urls
root_mapping = [(namespace, app.cfg.root_mapping.get(namespace, app.cfg.default_root)) for namespace, _ in app.cfg.namespace_mapping]
query = Or([And([Term(NAME_EXACT, root), Term(NAMESPACE, namespace)]) for namespace, root in root_mapping])
for rev in flaskg.storage.search(q=query):
mtime = rev.meta[MTIME]
sitemap.append((rev.meta[NAMESPACE], format_timestamp(mtime), "hourly", "1.0"))
sitemap.sort()
content = render_template('misc/sitemap.xml', sitemap=sitemap)
return Response(content, mimetype='text/xml')
def userbrowser():
"""
User Account Browser
"""
groups = flaskg.groups
member_groups = {} # {username: [list of groups], ...}
for groupname in groups:
group = groups[groupname]
for member in group.members:
member_groups[member] = member_groups.get(member, []) + [group.name]
revs = user.search_users() # all users
user_accounts = []
for rev in revs:
user_names = rev.meta[NAME]
user_groups = member_groups.get(user_names[0], [])
for name in user_names[1:]:
user_groups = user_groups + member_groups.get(name, [])
user_accounts.append(dict(uid=rev.meta[ITEMID],
name=user_names,
fqname=CompositeName(NAMESPACE_USERS, NAME_EXACT, rev.name),
email=rev.meta[EMAIL] if EMAIL in rev.meta else rev.meta[EMAIL_UNVALIDATED],
disabled=rev.meta[DISABLED],
groups=user_groups))
return render_template('admin/userbrowser.html', user_accounts=user_accounts, title_name=_(u"Users"))
def _select_itemtype(self):
return render_template('modify_select_itemtype.html',
item=self,
item_name=self.name,
fqname=self.fqname,
itemtypes=item_registry.shown_entries,
)
def userbrowser():
"""
User Account Browser
"""
groups = flaskg.groups
revs = user.search_users() # all users
user_accounts = []
for rev in revs:
user_groups = []
user_names = rev.meta[NAME]
for groupname in groups:
group = groups[groupname]
for name in user_names:
if name in group:
user_groups.append(groupname)
user_accounts.append(
dict(uid=rev.meta[ITEMID],
name=user_names,
fqname=CompositeName(NAMESPACE_USERPROFILES, NAME_EXACT,
rev.name),
email=rev.meta[EMAIL]
if EMAIL in rev.meta else rev.meta[EMAIL_UNVALIDATED],
disabled=rev.meta[DISABLED],
groups=user_groups))
return render_template('admin/userbrowser.html',
user_accounts=user_accounts,
title_name=_(u"Users"))
def _do_modify_show_templates(self):
# call this if the item is still empty
rev_ids = []
item_templates = self.content.get_templates(self.contenttype)
if not item_templates:
return redirect(
url_for('frontend.modify_item',
item_name=self.fqname,
itemtype=self.itemtype,
contenttype=self.contenttype,
template=''))
return render_template(
'modify_select_template.html',
item=self,
item_name=self.name,
fqname=self.fqname,
itemtype=self.itemtype,
rev=self.rev,
contenttype=self.contenttype,
templates=item_templates,
first_rev_id=rev_ids and rev_ids[0],
last_rev_id=rev_ids and rev_ids[-1],
meta_rendered='',
data_rendered='',
)
def group_acl_report(group_name):
"""
Display a 2-column table of items and ACLs, where the ACL rule specifies any
WikiGroup or ConfigGroup name.
"""
group = search_group(group_name)
all_items = flaskg.storage.documents(wikiname=app.cfg.interwikiname)
group_items = []
for item in all_items:
acl_iterator = ACLStringIterator(ACL_RIGHTS_CONTENTS,
item.meta.get(ACL, ''))
for modifier, entries, rights in acl_iterator:
if group_name in entries:
item_id = item.meta.get(ITEMID)
fqname = CompositeName(item.meta.get(NAMESPACE), u'itemid',
item_id)
group_items.append(
dict(name=item.meta.get(NAME),
itemid=item_id,
fqname=fqname,
rights=rights))
return render_template('admin/group_acl_report.html',
title_name=_(u'Group ACL Report'),
group_items=group_items,
group_name=group_name)
def wikiconfighelp():
def format_default(default):
if isinstance(default, defaultconfig.DefaultExpression):
default_txt = default.text
else:
default_txt = repr(default)
if len(default_txt) > 30:
default_txt = '...'
return default_txt
groups = []
for groupname in defaultconfig.options:
heading, desc, opts = defaultconfig.options[groupname]
opts = sorted([(groupname + '_' + name, format_default(default),
description) for name, default, description in opts])
groups.append((heading, desc, opts))
for groupname in defaultconfig.options_no_group_name:
heading, desc, opts = defaultconfig.options_no_group_name[groupname]
opts = sorted([(name, format_default(default), description)
for name, default, description in opts])
groups.append((heading, desc, opts))
groups.sort()
return render_template('admin/wikiconfighelp.html',
title_name=_(u"Wiki Configuration Help"),
groups=groups)
def item_acl_report():
"""
Return a list of all items in the wiki along with the ACL Meta-data
"""
all_items = flaskg.storage.documents(wikiname=app.cfg.interwikiname)
items_acls = []
for item in all_items:
item_namespace = item.meta.get(NAMESPACE)
item_id = item.meta.get(ITEMID)
item_name = item.meta.get(NAME)
item_acl = item.meta.get(ACL)
acl_default = item_acl is None
fqname = CompositeName(item_namespace, u'itemid', item_id)
if acl_default:
for namespace, acl_config in app.cfg.acl_mapping:
if item_namespace == namespace[:-1]:
item_acl = acl_config['default']
items_acls.append({
'name': item_name,
'itemid': item_id,
'fqname': fqname,
'acl': item_acl,
'acl_default': acl_default
})
return render_template('admin/item_acl_report.html',
title_name=_('Item ACL Report'),
items_acls=items_acls)
def _select_itemtype(self):
"""
TODO: Here we bypass the code that allows a user to select an itemtype just before
creating a new item:
Default - Wiki item
User profile - User profile item (not implemented yet!)
Blog - Blog item
Blog entry - Blog entry item
Ticket - Ticket item
Blogs and Tickets are broken, why User Profile is here is an undocumented mystery (it is
probably no longer required).
If you want to work on tickets or blogs, create a new branch and revert the change
made on or about 2017-07-04:
"""
# if this is a subitem, verify all parent items exist
try:
_verify_parents(self, self.name, self.meta[NAMESPACE])
except MissingParentError as e:
flash(str(e), "error")
form = CreateItemForm().from_defaults()
TextCha(form).amend_form()
form['target'] = self.fqname.fullname
return render_template(
'create_new_item.html',
fqname=self.fqname,
form=form,
)
return render_template(
'modify_select_contenttype.html',
fqname=self.fqname,
item_name=self.name,
itemtype='default', # create a normal wiki item
group_names=content_registry.group_names,
groups=content_registry.groups,
)
# dead code, see above
return render_template(
'modify_select_itemtype.html',
item=self,
item_name=self.name,
fqname=self.fqname,
itemtypes=item_registry.shown_entries,
)
def _render_data_diff_atom(self, oldrev, newrev):
if PIL is None:
# no PIL, we can't do anything, we just call the base class method
return super(TransformableBitmapImage, self)._render_data_diff_atom(oldrev, newrev)
url = url_for('frontend.diffraw', _external=True, item_name=self.name, rev1=oldrev.revid, rev2=newrev.revid)
return render_template('atom.html',
oldrev=oldrev, newrev=newrev, get='binary',
content=Markup(u'<img src="{0}" />'.format(escape(url))))
def trash(namespace):
"""
Returns the trashed items.
"""
trash = _trashed(namespace)
return render_template('admin/trash.html',
headline=_(u'Trashed Items'),
title_name=_(u'Trashed Items'),
results=trash)
def trash(namespace):
"""
Returns the trashed items.
"""
trash = _trashed(namespace)
return render_template('admin/trash.html',
headline=_(u'Trashed Items'),
title_name=_(u'Trashed Items'),
results=trash)
def interwikihelp():
"""display a table with list of known interwiki names / urls"""
headings = [_('InterWiki name'),
_('URL'),
]
rows = sorted(app.cfg.interwiki_map.items())
return render_template('admin/interwikihelp.html',
title_name=_(u"Interwiki Help"),
headings=headings,
rows=rows)
def _render_data_diff_html(self, oldrev, newrev, template):
""" Render HTML formatted meta and content diff of 2 revisions
:param oldrev: old revision object
:param newrev: new revision object
:param template: name of the template to be rendered
:return: HTML data with meta and content diff
"""
diffs = self._get_data_diff_html(oldrev.data, newrev.data)
return render_template(template, item_name=self.name, oldrev=oldrev, newrev=newrev, diffs=diffs)
def do_show(self, revid):
# First, check if the current user has the required privileges
if flaskg.user.may.create(self.name):
content = self._select_itemtype()
else:
content = render_template('show_nonexistent.html',
item_name=self.name,
fqname=self.fqname,
)
return Response(content, 404)
def do_show(self, revid):
# First, check if the current user has the required privileges
if flaskg.user.may.create(self.name):
content = self._select_itemtype()
else:
content = render_template('show_nonexistent.html',
item_name=self.name,
fqname=self.fqname,
)
return Response(content, 404)
def interwikihelp():
"""display a table with list of known interwiki names / urls"""
headings = [
_('InterWiki name'),
_('URL'),
]
rows = sorted(app.cfg.interwiki_map.items())
return render_template('user/interwikihelp.html',
title_name=_(u"Interwiki Names"),
headings=headings,
rows=rows)
def itemsize():
"""display a table with item sizes"""
headings = [_('Size'),
_('Item name'),
]
rows = [(rev.meta[SIZE], rev.meta[NAME])
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname)]
rows = sorted(rows, reverse=True)
return render_template('admin/itemsize.html',
title_name=_(u"Item Size"),
headings=headings,
rows=rows)
def urls_names():
"""
List of all item URLs and names, e.g. for sisteritems.
This view generates a list of item URLs and item names, so that other wikis
can implement SisterWiki functionality easily.
See: http://usemod.com/cgi-bin/mb.pl?SisterSitesImplementationGuide
"""
# XXX we currently also get deleted items, fix this
item_names = sorted([rev.meta[NAME] for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname)])
content = render_template('misc/urls_names.txt', item_names=item_names)
return Response(content, mimetype='text/plain')
def render_templates(self, content_diff, meta_diff):
""" Render both plain text and HTML templates by providing all the
necessary arguments
:return: tuple consisting of plain text and HTML notification message
"""
meta_diff_txt = list(make_text_diff(meta_diff))
domain = self.app.cfg.interwiki_map[self.app.cfg.interwikiname]
unsubscribe_url = urljoin(
domain, url_for('frontend.subscribe_item', item_name=self.fqname))
diff_url = self.generate_diff_url(domain)
item_url = urljoin(
domain, url_for('frontend.show_item', item_name=self.fqname))
if self.comment is not None:
comment = self.meta["comment"]
else:
comment = self.revs[0].meta["comment"]
txt_template = render_template(
Notification.txt_template,
wiki_name=self.wiki_name,
notification_sentence=self.notification_sentence,
diff_url=diff_url,
item_url=item_url,
comment=comment,
content_diff_=content_diff,
meta_diff_=meta_diff_txt,
unsubscribe_url=unsubscribe_url,
)
html_template = render_template(
Notification.html_template,
wiki_name=self.wiki_name,
notification_sentence=self.notification_sentence,
diff_url=diff_url,
item_url=item_url,
comment=comment,
content_diff_=content_diff,
meta_diff_=meta_diff,
unsubscribe_url=unsubscribe_url,
)
return txt_template, html_template
def urls_names():
"""
List of all item URLs and names, e.g. for sisteritems.
This view generates a list of item URLs and item names, so that other wikis
can implement SisterWiki functionality easily.
See: http://usemod.com/cgi-bin/mb.pl?SisterSitesImplementationGuide
"""
# XXX we currently also get user items, fix this
item_names = [item.name for item in flaskg.storage.iteritems()]
item_names.sort()
content = render_template('misc/urls_names.txt', item_names=item_names)
return Response(content, mimetype='text/plain')
def itemsize():
"""display a table with item sizes"""
headings = [
_('Size'),
_('Item name'),
]
rows = [(rev.meta[SIZE], rev.fqname)
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname)]
rows = sorted(rows, reverse=True)
return render_template('user/itemsize.html',
title_name=_(u"Item Sizes"),
headings=headings,
rows=rows)
def do_modify(self):
is_new = isinstance(self.content, NonExistentContent)
closed = self.meta.get('closed')
Form = TicketSubmitForm if is_new else TicketUpdateForm
if request.method in ['GET', 'HEAD']:
form = Form.from_item(self)
elif request.method == 'POST':
form = Form.from_request(request)
if form.validate():
meta, data, message, data_file = form._dump(self)
try:
if not is_new and message:
create_comment(self.meta, message)
self.modify(meta, data)
if data_file:
file_upload(self, data_file)
except AccessDenied:
abort(403)
else:
try:
fqname = CompositeName(self.meta[NAMESPACE], ITEMID,
self.meta[ITEMID])
except KeyError:
fqname = self.fqname
return redirect(url_for('.show_item', item_name=fqname))
# XXX When creating new item, suppress the "foo doesn't exist. Create it?" dummy content
data_rendered = None if is_new else Markup(self.content._render_data())
files = get_files(self)
comments, roots = get_comments(self)
suggested_tags = get_itemtype_specific_tags(ITEMTYPE_TICKET)
return render_template(
self.submit_template if is_new else self.modify_template,
is_new=is_new,
closed=closed,
item_name=self.name,
data_rendered=data_rendered,
form=form,
suggested_tags=suggested_tags,
item=self,
files=files,
comments=comments,
Markup=Markup,
datetime=datetime,
roots=roots,
build_tree=build_tree,
)
def do_show(self, revid):
"""
Show a blog item and a list of its blog entries below it.
If tag GET-parameter is defined, the list of blog entries consists only
of those entries that contain the tag value in their lists of tags.
"""
# for now it is just one tag=value, later it could be tag=value1&tag=value2&...
tag = request.values.get('tag')
prefix = self.name + u'/'
current_timestamp = int(time.time())
terms = [
Term(WIKINAME, app.cfg.interwikiname),
# Only blog entry itemtypes
Term(ITEMTYPE, ITEMTYPE_BLOG_ENTRY),
# Only sub items of this item
Prefix(NAME_EXACT, prefix),
]
if tag:
terms.append(Term(TAGS, tag))
query = And(terms)
def ptime_sort_key(searcher, docnum):
"""
Compute the publication time key for blog entries sorting.
If PTIME is not defined, we use MTIME.
"""
fields = searcher.stored_fields(docnum)
ptime = fields.get(PTIME, fields[MTIME])
return ptime
ptime_sort_facet = FunctionFacet(ptime_sort_key)
revs = flaskg.storage.search(query,
sortedby=ptime_sort_facet,
reverse=True,
limit=None)
blog_entry_items = [
Item.create(rev.name, rev_id=rev.revid) for rev in revs
]
return render_template(
'blog/main.html',
item_name=self.name,
fqname=split_fqname(self.name),
blog_item=self,
blog_entry_items=blog_entry_items,
tag=tag,
item=self,
)
def urls_names():
"""
List of all item URLs and names, e.g. for sisteritems.
This view generates a list of item URLs and item names, so that other wikis
can implement SisterWiki functionality easily.
See: http://usemod.com/cgi-bin/mb.pl?SisterSitesImplementationGuide
"""
# XXX we currently also get deleted items, fix this
fq_names = []
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
fq_names += [fqname for fqname in rev.fqnames]
content = render_template('misc/urls_names.txt', fq_names=fq_names)
return Response(content, mimetype='text/plain')
def urls_names():
"""
List of all item URLs and names, e.g. for sisteritems.
This view generates a list of item URLs and item names, so that other wikis
can implement SisterWiki functionality easily.
See: http://usemod.com/cgi-bin/mb.pl?SisterSitesImplementationGuide
"""
# XXX we currently also get deleted items, fix this
fq_names = []
for rev in flaskg.storage.documents(wikiname=app.cfg.interwikiname):
fq_names += [fqname for fqname in rev.fqnames]
content = render_template("misc/urls_names.txt", fq_names=fq_names)
return Response(content, mimetype="text/plain")
def userbrowser():
"""
User Account Browser
"""
groups = flaskg.groups
revs = user.search_users() # all users
user_accounts = [dict(uid=rev.meta[ITEMID],
name=rev.meta[NAME],
email=u'', # rev.meta[EMAIL], # TODO: fix KeyError
disabled=False, # TODO: add to index
groups=[groupname for groupname in groups if rev.meta[NAME] in groups[groupname]],
)
for rev in revs]
return render_template('admin/userbrowser.html', user_accounts=user_accounts, title_name=_(u"User Browser"))
def userbrowser():
"""
User Account Browser
"""
groups = flaskg.groups
revs = user.search_users() # all users
user_accounts = [dict(uid=rev.meta[ITEMID],
name=rev.meta[NAME],
fqname=CompositeName(NAMESPACE_USERPROFILES, NAME_EXACT, rev.name),
email=rev.meta[EMAIL],
disabled=rev.meta[DISABLED],
groups=[groupname for groupname in groups if rev.meta[NAME] in groups[groupname]],
) for rev in revs]
return render_template('admin/userbrowser.html', user_accounts=user_accounts, title_name=_(u"Users"))
def render_templates(self, content_diff, meta_diff):
""" Render both plain text and HTML templates by providing all the
necessary arguments
:return: tuple consisting of plain text and HTML notification message
"""
meta_diff_txt = list(make_text_diff(meta_diff))
domain = self.app.cfg.interwiki_map[self.app.cfg.interwikiname]
unsubscribe_url = urljoin(domain, url_for('frontend.subscribe_item',
item_name=self.item_name))
diff_url = self.generate_diff_url(domain)
item_url = urljoin(domain, url_for('frontend.show_item', item_name=self.item_name))
if self.comment is not None:
comment = self.meta["comment"]
else:
comment = self.revs[0].meta["comment"]
txt_template = render_template(Notification.txt_template,
wiki_name=self.wiki_name,
notification_sentence=self.notification_sentence,
diff_url=diff_url,
item_url=item_url,
comment=comment,
content_diff_=content_diff,
meta_diff_=meta_diff_txt,
unsubscribe_url=unsubscribe_url,
)
html_template = render_template(Notification.html_template,
wiki_name=self.wiki_name,
notification_sentence=self.notification_sentence,
diff_url=diff_url,
item_url=item_url,
comment=comment,
content_diff_=content_diff,
meta_diff_=meta_diff,
unsubscribe_url=unsubscribe_url,
)
return txt_template, html_template
def do_modify(self):
is_new = isinstance(self.content, NonExistentContent)
closed = self.meta.get('closed')
Form = TicketSubmitForm if is_new else TicketUpdateForm
if request.method in ['GET', 'HEAD']:
form = Form.from_item(self)
elif request.method == 'POST':
form = Form.from_request(request)
if form.validate():
meta, data, message, data_file = form._dump(self)
try:
if not is_new and message:
create_comment(self.meta, message)
self.modify(meta, data)
if data_file:
file_upload(self, data_file)
except AccessDenied:
abort(403)
else:
try:
fqname = CompositeName(self.meta[NAMESPACE], ITEMID, self.meta[ITEMID])
except KeyError:
fqname = self.fqname
return redirect(url_for('.show_item', item_name=fqname))
# XXX When creating new item, suppress the "foo doesn't exist. Create it?" dummy content
data_rendered = None if is_new else Markup(self.content._render_data())
files = get_files(self)
comments, roots = get_comments(self)
suggested_tags = get_itemtype_specific_tags(ITEMTYPE_TICKET)
return render_template(self.submit_template if is_new else self.modify_template,
is_new=is_new,
closed=closed,
item_name=self.name,
data_rendered=data_rendered,
form=form,
suggested_tags=suggested_tags,
item=self,
files=files,
comments=comments,
Markup=Markup,
datetime=datetime,
roots=roots,
build_tree=build_tree,
)
def highlighterhelp():
"""display a table with list of available Pygments lexers"""
import pygments.lexers
headings = [_('Lexer description'),
_('Lexer names'),
_('File patterns'),
_('Mimetypes'),
]
lexers = pygments.lexers.get_all_lexers()
rows = sorted([[desc, ' '.join(names), ' '.join(patterns), ' '.join(mimetypes), ]
for desc, names, patterns, mimetypes in lexers])
return render_template('admin/highlighterhelp.html',
title_name=_(u"Highlighter Help"),
headings=headings,
rows=rows)
def do_show(self, revid):
show_revision = revid != CURRENT
show_navigation = False # TODO
first_rev = last_rev = None # TODO
return render_template(self.show_template,
item=self, item_name=self.name,
fqname=self.fqname,
rev=self.rev,
contenttype=self.contenttype,
first_rev_id=first_rev,
last_rev_id=last_rev,
data_rendered=Markup(self.content._render_data()),
show_revision=show_revision,
show_navigation=show_navigation,
)
def do_show(self, revid):
blog_item_name = self.name.rsplit('/', 1)[0]
try:
blog_item = Item.create(blog_item_name)
except AccessDenied:
abort(403)
if not isinstance(blog_item, Blog):
# The parent item of this blog entry item is not a Blog item.
abort(403)
return render_template('blog/entry.html',
item_name=self.name,
fqname=blog_item.fqname,
blog_item=blog_item,
blog_entry_item=self,
)
def do_show(self, revid):
show_revision = revid != CURRENT
show_navigation = False # TODO
first_rev = last_rev = None # TODO
return render_template(self.show_template,
item=self, item_name=self.name,
fqname=self.fqname,
rev=self.rev,
contenttype=self.contenttype,
first_rev_id=first_rev,
last_rev_id=last_rev,
data_rendered=Markup(self.content._render_data()),
show_revision=show_revision,
show_navigation=show_navigation,
)
def highlighterhelp():
"""display a table with list of available Pygments lexers"""
import pygments.lexers
headings = [
_('Lexer description'),
_('Lexer names'),
_('File patterns'),
_('Mimetypes'),
]
lexers = pygments.lexers.get_all_lexers()
rows = sorted([[desc, ' '.join(names), ' '.join(patterns), ' '.join(mimetypes), ]
for desc, names, patterns, mimetypes in lexers])
return render_template('user/highlighterhelp.html',
title_name=_(u"Highlighters"),
headings=headings,
rows=rows)
def _render_data_diff_html(self, oldrev, newrev, template):
""" Render HTML formatted meta and content diff of 2 revisions
:param oldrev: old revision object
:param newrev: new revision object
:param template: name of the template to be rendered
:return: HTML data with meta and content diff
"""
diffs = self._get_data_diff_html(oldrev.data, newrev.data)
return render_template(
template,
item_name=self.name,
oldrev=oldrev,
newrev=newrev,
diffs=diffs,
)
def _render_data_diff_atom(self, oldrev, newrev):
if PIL is None:
# no PIL, we can't do anything, we just call the base class method
return super(TransformableBitmapImage,
self)._render_data_diff_atom(oldrev, newrev)
url = url_for('frontend.diffraw',
_external=True,
item_name=self.name,
rev1=oldrev.revid,
rev2=newrev.revid)
return render_template('atom.html',
oldrev=oldrev,
newrev=newrev,
get='binary',
content=Markup(u'<img src="{0}" />'.format(
escape(url))))
def wikiconfig():
settings = {}
for groupname in defaultconfig.options:
heading, desc, opts = defaultconfig.options[groupname]
for name, default, description in opts:
name = groupname + '_' + name
if isinstance(default, defaultconfig.DefaultExpression):
default = default.value
settings[name] = default
for groupname in defaultconfig.options_no_group_name:
heading, desc, opts = defaultconfig.options_no_group_name[groupname]
for name, default, description in opts:
if isinstance(default, defaultconfig.DefaultExpression):
default = default.value
settings[name] = default
def iter_vnames(cfg):
dedup = {}
for name in cfg.__dict__:
dedup[name] = True
yield name, cfg.__dict__[name]
for cls in cfg.__class__.mro():
if cls == defaultconfig.ConfigFunctionality:
break
for name in cls.__dict__:
if name not in dedup:
dedup[name] = True
yield name, cls.__dict__[name]
found = []
found_default = []
for vname, value in iter_vnames(app.cfg):
if hasattr(defaultconfig.ConfigFunctionality, vname):
continue
if vname in settings and settings[vname] == value:
found_default.append((vname, value))
continue
found.append((vname, value))
found.sort()
found_default.sort()
return render_template('admin/wikiconfig.html',
title_name=_(u"Show Wiki Configuration"),
len=len,
found=found,
found_default=found_default,
settings=settings)
def sysitems_upgrade():
from MoinMoin.storage.backends import upgrade_sysitems
from MoinMoin.storage.error import BackendError
if request.method == 'GET':
action = 'syspages_upgrade'
label = 'Upgrade System Pages'
return render_template('admin/sysitems_upgrade.html',
title_name=_(u"System items upgrade"))
if request.method == 'POST':
xmlfile = request.files.get('xmlfile')
try:
upgrade_sysitems(xmlfile)
except BackendError as e:
flash(_('System items upgrade failed due to the following error: %(error)s.', error=e), 'error')
else:
flash(_('System items have been upgraded successfully!'))
return redirect(url_for('.index'))
def do_show(self, revid):
"""
Display an item. If this is not the current revision, page content will be
prefaced with links to the next-rev and prior-rev.
"""
rev_navigation_ids_dates = rev_navigation.prior_next_revs(
revid, self.fqname)
return render_template(
'show.html',
item=self,
item_name=self.name,
fqname=self.fqname,
rev=self.rev,
contenttype=self.contenttype,
rev_navigation_ids_dates=rev_navigation_ids_dates,
data_rendered=Markup(self.content._render_data()),
)
def do_show(self, revid):
blog_item_name = self.name.rsplit('/', 1)[0]
try:
blog_item = Item.create(blog_item_name)
except AccessDenied:
abort(403)
if not isinstance(blog_item, Blog):
# The parent item of this blog entry item is not a Blog item.
abort(403)
return render_template(
'blog/entry.html',
item_name=self.name,
fqname=blog_item.fqname,
blog_item=blog_item,
blog_entry_item=self,
item=self,
)
def _do_modify_show_templates(self):
# call this if the item is still empty
rev_ids = []
item_templates = self.content.get_templates(self.contenttype)
return render_template('modify_select_template.html',
item=self,
item_name=self.name,
fqname=self.fqname,
itemtype=self.itemtype,
rev=self.rev,
contenttype=self.contenttype,
templates=item_templates,
first_rev_id=rev_ids and rev_ids[0],
last_rev_id=rev_ids and rev_ids[-1],
meta_rendered='',
data_rendered='',
)
def groupbrowser():
"""
Display list of all groups and their members
"""
all_groups = flaskg.groups
groups = []
for group in all_groups:
group_type = ''
if isinstance(all_groups[group], WikiGroup):
group_type = 'WikiGroup'
else:
group_type = 'ConfigGroup'
groups.append(dict(name=all_groups[group].name,
member_users=all_groups[group].members,
member_groups=all_groups[group].member_groups,
grouptype=group_type))
return render_template('admin/groupbrowser.html',
title_name=_(u'Groups'),
groups=groups)
def sysitems_upgrade():
from MoinMoin.storage.backends import upgrade_sysitems
from MoinMoin.storage.error import BackendError
if request.method == 'GET':
action = 'syspages_upgrade'
label = 'Upgrade System Pages'
return render_template('admin/sysitems_upgrade.html',
item_name="+admin/System items upgrade")
if request.method == 'POST':
xmlfile = request.files.get('xmlfile')
try:
upgrade_sysitems(xmlfile)
except BackendError, e:
flash(
_('System items upgrade failed due to the following error: %(error)s.',
error=e), 'error')
else:
flash(_('System items have been upgraded successfully!'))
return redirect(url_for('admin.index'))
def groupbrowser():
"""
Display list of all groups and their members
"""
all_groups = flaskg.groups
groups = []
for group in all_groups:
group_type = ''
if isinstance(all_groups[group], WikiGroup):
group_type = 'WikiGroup'
else:
group_type = 'ConfigGroup'
groups.append(dict(name=all_groups[group].name,
member_users=all_groups[group].members,
member_groups=all_groups[group].member_groups,
grouptype=group_type))
return render_template('admin/groupbrowser.html',
title_name=_(u'Groups'),
groups=groups)
def user_acl_report(uid):
all_items = flaskg.storage.documents(wikiname=app.cfg.interwikiname)
groups = flaskg.groups
theuser = user.User(uid=uid)
itemwise_acl = []
for item in all_items:
fqname = CompositeName(item.meta.get(NAMESPACE), u'itemid', item.meta.get(ITEMID))
itemwise_acl.append({'name': item.meta.get(NAME),
'itemid': item.meta.get(ITEMID),
'fqname': fqname,
'read': theuser.may.read(fqname),
'write': theuser.may.write(fqname),
'create': theuser.may.create(fqname),
'admin': theuser.may.admin(fqname),
'destroy': theuser.may.destroy(fqname)})
return render_template('admin/user_acl_report.html',
title_name=_(u'User ACL Report'),
user_names=theuser.name,
itemwise_acl=itemwise_acl)
