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 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 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 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 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 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 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)