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):
        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 _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 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 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 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 _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 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('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 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 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
    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],
                          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 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 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,
                              )