def render(self): """ Redirect to the new page, using edit action and template """ error = self.checkAndCombineArguments() or self.checkPermissions() if error: # Send back to the page you came from, with an error msg page = Page(self.request, self.referrer) page.send_page(self.request, msg=error) else: # Redirect to new page using edit action. No error checking # is needed because it is done later in new request. pagename = self.pagename query = {'action': 'edit', 'backto': self.referrer} template = self.request.form.get('template', [''])[0] if template: from MoinMoin.wikiutil import quoteWikinameURL query['template'] = quoteWikinameURL(template) parent = self.request.form.get('parent', [''])[0] if parent: pagename = "%s/%s" % (parent, pagename) url = Page(self.request, pagename).url(self.request, query, 0) self.request.http_redirect(url) raise MoinMoinNoFooter return ''
def render(self): """ Redirect to the new page, using edit action and template """ error = self.checkAndCombineArguments() or self.checkPermissions() if error: # Send back to the page you came from, with an error msg page = Page(self.request, self.referrer) self.request.theme.add_msg(error, "error") page.send_page() else: # Redirect to new page using edit action. No error checking # is needed because it is done later in new request. pagename = self.pagename query = {'action': 'edit', 'backto': self.referrer} template = self.request.form.get('template', [''])[0] if template: query['template'] = template parent = self.request.form.get('parent', [''])[0] if parent: pagename = "%s/%s" % (parent, pagename) url = Page(self.request, pagename).url(self.request, query) self.request.http_redirect(url) return ''
def render(self): """ Redirect to the new page, using edit action and template """ error = self.checkAndCombineArguments() or self.checkPermissions() if error: # Send back to the page you came from, with an error msg page = Page(self.request, self.referrer) self.request.theme.add_msg(error, "error") page.send_page() else: # Redirect to new page using edit action. No error checking # is needed because it is done later in new request. pagename = self.pagename query = {'action': 'edit', 'backto': self.referrer} template = self.request.values.get('template', '') if template: query['template'] = template parent = self.request.values.get('parent', '') if parent: pagename = "%s/%s" % (parent, pagename) url = Page(self.request, pagename).url(self.request, query) self.request.http_redirect(url) return ''
class PackagePages: def __init__(self, pagename, request): self.request = request self.pagename = pagename self.page = Page(request, pagename) def allowed(self): """ Check if user is allowed to do this. """ return not self.__class__.__name__ in self.request.cfg.actions_excluded def render(self): """ Render action This action returns a wiki page with optional message, or redirects to new page. """ _ = self.request.getText if 'cancel' in self.request.values: # User canceled return self.page.send_page() try: if not self.allowed(): self.request.theme.add_msg( _('You are not allowed to edit this page.'), "error") raise ActionError elif not self.page.exists(): self.request.theme.add_msg( _('This page is already deleted or was never created!')) raise ActionError self.package() except ActionError, e: return self.page.send_page()
def _retrieve_members(self, group_name): """ MoinMoin.formatter.groups is used to extract group members from a page. """ formatter = Formatter(self.request) page = Page(self.request, group_name, formatter=formatter) request_page = getattr(self.request, "page", None) self.request.page = page # send_special is set to True because acl of the page should # not be processed to avoid infinite recursion in the # following case. # # Consider page UserGroup content: # # #acl UserGroup:read,write,admin All:read # # * ExampleUser # * TestGroup # page.send_page(content_only=True, send_special=True) if request_page: self.request.page = request_page else: del self.request.page return formatter.members
def execute(macro, args): _ = macro.request.getText pagename = args or 'FortuneCookies' if macro.request.user.may.read(pagename): page = Page(macro.request, pagename) raw = page.get_raw_body() else: raw = "" # this selects lines looking like a list item # !!! TODO: make multi-line quotes possible (optionally split by "----" or something) quotes = raw.splitlines() quotes = [quote.strip() for quote in quotes] quotes = [quote[2:] for quote in quotes if quote.startswith('* ')] if not quotes: return (macro.formatter.highlight(1) + _('No quotes on %(pagename)s.') % {'pagename': pagename} + macro.formatter.highlight(0)) quote = random.choice(quotes) page.set_raw_body(quote, 1) out = StringIO.StringIO() macro.request.redirect(out) page.send_page(macro.request, content_only=1, content_id="RandomQuote_%s" % wikiutil.quoteWikinameFS(page.page_name) ) quote = out.getvalue() macro.request.redirect() return quote
def _retrieve_members(self, group_name): """ MoinMoin.formatter.groups is used to extract group members from a page. """ formatter = Formatter(self.request) page = Page(self.request, group_name, formatter=formatter) request_page = getattr(self.request, "page", None) self.request.page = page # send_special is set to True because acl of the page should # not be processed to avoid infinite recursion in the # following case. # # Consider page UserGroup content: # # #acl UserGroup:read,write,admin All:read # # * ExampleUser # * TestGroup # page.send_page(content_only=True, send_special=True) if request_page: self.request.page = request_page else: del self.request.page return formatter.members
class PackagePages: def __init__(self, pagename, request): self.request = request self.pagename = pagename self.page = Page(request, pagename) def allowed(self): """ Check if user is allowed to do this. """ return not self.__class__.__name__ in self.request.cfg.actions_excluded def render(self): """ Render action This action returns a wiki page with optional message, or redirects to new page. """ _ = self.request.getText if 'cancel' in self.request.values: # User canceled return self.page.send_page() try: if not self.allowed(): self.request.theme.add_msg(_('You are not allowed to edit this page.'), "error") raise ActionError elif not self.page.exists(): self.request.theme.add_msg(_('This page is already deleted or was never created!')) raise ActionError self.package() except ActionError, e: return self.page.send_page()
def testSendPage(self): page = Page(self.request, u"FrontPage") import StringIO out = StringIO.StringIO() self.request.redirect(out) page.send_page(msg=u'Done', emit_headers=False) result = out.getvalue() self.request.redirect() del out assert result.strip().endswith('</html>') assert result.strip().startswith('<!DOCTYPE HTML PUBLIC')
def get_members(self, text): request = self.request formatter = Formatter(self.request) become_trusted(request) create_page(request, u'TestPageGroup', text) page = Page(request, 'TestPageGroup', formatter=formatter) page.send_page(content_only=True) nuke_page(request, u'TestPageGroup') return formatter.members
def get_members(self, text): request = self.request formatter = Formatter(self.request) become_trusted(request) create_page(request, u'TestPageGroup', text) page = Page(request, 'TestPageGroup', formatter=formatter) page.send_page(content_only=True) nuke_page(request, u'TestPageGroup') return formatter.members
def testSendPage(self): page = Page(self.request, u"FrontPage") import StringIO out = StringIO.StringIO() self.request.redirect(out) page.send_page(msg=u'Done', emit_headers=False) result = out.getvalue() self.request.redirect() del out assert result.strip().endswith('</html>') assert result.strip().startswith('<!DOCTYPE HTML PUBLIC')
def sidebar(self, d): """ Assemble wiki sidebar """ name = u'サイドバー' page = Page(self.request, name) if not page.exists(): return u'' buff = StringIO() self.request.redirect(buff) page.send_page(content_only=1) self.request.redirect() return u'<div id="sidebar">%s</div>' % buff.getvalue()
def execute(pagename, request): _ = request.getText page = Page(request, pagename) if request.user.may.read(pagename): badwords, badwords_re, msg = checkSpelling(page, request) else: badwords = [] msg = _("You can't check spelling on a page you can't read.") if badwords: page.send_page(request, msg=msg, hilite_re=badwords_re) else: page.send_page(request, msg=msg)
class LoginHandler: def __init__(self, pagename, request): self.request = request self._ = request.getText self.cfg = request.cfg self.pagename = pagename self.page = Page(request, pagename) def handle(self): _ = self._ request = self.request form = request.form error = None islogin = form.get('login', [''])[0] if islogin: # user pressed login button return self.page.send_page(request, msg=error) else: # show login form request.http_headers() wikiutil.send_title(request, _("Login"), pagename=self.pagename) # Start content (important for RTL support) request.write(request.formatter.startContent("content")) request.write(userform.getLogin(request)) # End content and send footer request.write(request.formatter.endContent()) wikiutil.send_footer(request, self.pagename)
def execute(pagename, request): found = False for auth in request.cfg.auth: if isinstance(auth, MoinAuth): found = True break if not found: # we will not have linked, so forbid access request.makeForbidden(403, 'No MoinAuth in auth list') return page = Page(request, pagename) _ = request.getText form = request.form submitted = form.has_key('create') if submitted: # user pressed create button request.theme.add_msg(_create_user(request), "dialog") return page.send_page() else: # show create form request.theme.send_title(_("Create Account"), pagename=pagename) request.write(request.formatter.startContent("content")) # THIS IS A BIG HACK. IT NEEDS TO BE CLEANED UP request.write(_create_form(request)) request.write(request.formatter.endContent()) request.theme.send_footer(pagename) request.theme.send_closing_html()
def execute(pagename, request): found = False for auth in request.cfg.auth: if isinstance(auth, MoinAuth): found = True break if not found: # we will not have linked, so forbid access request.makeForbidden(403, 'No MoinAuth in auth list') return page = Page(request, pagename) _ = request.getText form = request.form submitted = form.has_key('create') if submitted: # user pressed create button request.theme.add_msg(_create_user(request), "dialog") return page.send_page() else: # show create form request.theme.send_title(_("Create Account"), pagename=pagename) request.write(request.formatter.startContent("content")) # THIS IS A BIG HACK. IT NEEDS TO BE CLEANED UP request.write(_create_form(request)) request.write(request.formatter.endContent()) request.theme.send_footer(pagename) request.theme.send_closing_html()
def main(): args = parseOptions() tmpdir = None cwd = os.getcwd() try: if args.directory is None: tmpdir = tempfile.mkdtemp() create_temp_wiki(args, args.page, tmpdir) args.page = "SomePage" # Needed so relative paths in configuration are found os.chdir(args.directory) # Needed to load configuration sys.path = [ os.getcwd(), ] + sys.path url = re.sub("%", re.escape(args.page), args.url_template) if MOIN_VERSION >= "1.9": from MoinMoin.web.contexts import ScriptContext as Request else: from MoinMoin.request.request_cli import Request class MyRequest(Request): def normalizePagename(self, name): return name def normalizePageURL(self, name, url): return args.url_template.replace('%', name) request = MyRequest(url=url, pagename=args.page) Formatter = wikiutil.importPlugin(request.cfg, "formatter", "text_x-rst", "Formatter") formatter = Formatter(request) request.formatter = formatter page = Page(request, args.page, rev=args.revision, formatter=formatter) if not page.exists(): raise RuntimeError("No page named %r" % ( args.page, )) page.send_page() finally: if tmpdir is not None: shutil.rmtree(tmpdir) os.chdir(cwd)
def execute(pagename, request): _ = request.getText if not request.user.may.admin(pagename): thispage = Page(request, pagename) request.theme.add_msg(_("You are not allowed to perform this action."), "error") return thispage.send_page() elif 'users' not in request.form: show_form(pagename, request) else: show_result(pagename, request)
class LogoutHandler: def __init__(self, pagename, request): self.request = request self._ = request.getText self.page = Page(request,pagename) def handle(self): _ = self._ message = _("You are now logged out.") return self.page.send_page(self.request, msg=message)
def execute(pagename, request): from MoinMoin import wikiutil from MoinMoin.Page import Page _ = request.getText thispage = Page(request, pagename) siocPage = "SiocSpecTemplate" specPath = "/var/www/html/spec/" specURL = "http://sparql.captsolo.net/spec/" if pagename != siocPage: return thispage.send_page( request, msg=_('This action only works for SIOC template.')) # 1) get template (HTML) # = page contents template = thispage.get_raw_body() myMsg = '<p><b>Regenerated SIOC specification the template.</b></p>' # 2) run SpecGen code import sys sys.path.insert(0, specPath) import specgen4 specgen4.setTermDir(specPath + 'doc') spec = specgen4.main('http://sw.deri.org/svn/sw/2005/08/sioc/ns/sioc', template) # 3) save file # file = open(specPath + 'sioc.html', 'wt') file.write(spec.encode('utf-8')) file.close() # 5) display message - OK myMsg += '<p>Check it out: <b><a href="' + specURL + '">SIOC specification</a></b> [draft]</p><p> </p>' return thispage.send_page(request, msg=_(myMsg))
def execute(pagename, request): """ save images to attachments """ #TODO add auth control _ = request.getText page = Page(request, pagename) image2attach = Image2Attach(pagename, request) image2attach.process() request.theme.add_msg( _( "Images saved successful: %d, Failed: %d" % ( image2attach.process_success, image2attach.process_fail, ) ), "info" ) page.send_page()
def execute(pagename, request): from MoinMoin import wikiutil from MoinMoin.Page import Page _ = request.getText thispage = Page(request, pagename) siocPage = "SiocSpecTemplate" specPath = "/var/www/html/spec/" specURL = "http://sparql.captsolo.net/spec/" if pagename != siocPage: return thispage.send_page(request, msg = _('This action only works for SIOC template.')) # 1) get template (HTML) # = page contents template = thispage.get_raw_body() myMsg = '<p><b>Regenerated SIOC specification the template.</b></p>' # 2) run SpecGen code import sys sys.path.insert(0, specPath) import specgen4 specgen4.setTermDir( specPath+'doc' ) spec = specgen4.main( 'http://sw.deri.org/svn/sw/2005/08/sioc/ns/sioc', template ) # 3) save file # file = open( specPath+'sioc.html', 'wt' ) file.write(spec.encode('utf-8')) file.close() # 5) display message - OK myMsg += '<p>Check it out: <b><a href="' + specURL + '">SIOC specification</a></b> [draft]</p><p> </p>' return thispage.send_page(request, msg = _(myMsg))
def execute(pagename, request): _ = request.getText if not request.user.may.admin(pagename): thispage = Page(request, pagename) request.theme.add_msg(_("You are not allowed to perform this action."), "error") return thispage.send_page() elif 'users' not in request.form: show_form(pagename, request) else: show_result(pagename, request)
def execute(pagename, request): found = False for auth in request.cfg.auth: if isinstance(auth, MoinAuth): found = True break if not found: # we will not have linked, so forbid access request.makeForbidden(403, 'No MoinAuth in auth list') return page = Page(request, pagename) _ = request.getText form = request.form submitted = form.has_key('create') if submitted: # user pressed create button ## !!! This if is to only allow super user to create accounts: print "submitted!" if not request.user.isSuperUser(): print "not superuser" request.theme.add_msg(_('You are not allowed to use this action.'), "error") return page.send_page() print "superuser" request.theme.add_msg(_create_user(request), "dialog") return page.send_page() else: # show create form request.theme.send_title(_("Create Account"), pagename=pagename) request.write(request.formatter.startContent("content")) # THIS IS A BIG HACK. IT NEEDS TO BE CLEANED UP request.write(_create_form(request)) request.write(request.formatter.endContent()) request.theme.send_footer(pagename) request.theme.send_closing_html()
def _do_move(pagename, request): _ = request.getText pagename, filename, fpath = _access_file(pagename, request) if not request.user.may.delete(pagename): return _('You are not allowed to move attachments from this page.') if not filename: return # error msg already sent in _access_file # move file d = {'action': action_name, 'baseurl': request.getScriptname(), 'do': 'attachment_move', 'ticket': wikiutil.createTicket(request), 'pagename': pagename, 'pagename_quoted': wikiutil.quoteWikinameURL(pagename), 'attachment_name': filename, 'move': _('Move'), 'cancel': _('Cancel'), 'newname_label': _("New page name"), 'attachment_label': _("New attachment name"), } formhtml = ''' <form action="%(baseurl)s/%(pagename_quoted)s" method="POST"> <input type="hidden" name="action" value="%(action)s"> <input type="hidden" name="do" value="%(do)s"> <input type="hidden" name="ticket" value="%(ticket)s"> <table> <tr> <td class="label"><label>%(newname_label)s</label></td> <td class="content"> <input type="text" name="newpagename" value="%(pagename)s" size="80"> </td> </tr> <tr> <td class="label"><label>%(attachment_label)s</label></td> <td class="content"> <input type="text" name="newattachmentname" value="%(attachment_name)s" size="80"> </td> </tr> <tr> <td></td> <td class="buttons"> <input type="hidden" name="oldattachmentname" value="%(attachment_name)s"> <input type="submit" name="move" value="%(move)s"> <input type="submit" name="cancel" value="%(cancel)s"> </td> </tr> </table> </form>''' % d thispage = Page(request, pagename) request.theme.add_msg(formhtml, "dialog") return thispage.send_page()
def _do_move(pagename, request): _ = request.getText pagename, filename, fpath = _access_file(pagename, request) if not request.user.may.delete(pagename): return _('You are not allowed to move attachments from this page.') if not filename: return # error msg already sent in _access_file # move file d = { 'action': action_name, 'url': request.href(pagename), 'do': 'attachment_move', 'ticket': wikiutil.createTicket(request), 'pagename': wikiutil.escape(pagename, 1), 'attachment_name': wikiutil.escape(filename, 1), 'move': _('Move'), 'cancel': _('Cancel'), 'newname_label': _("New page name"), 'attachment_label': _("New attachment name"), } formhtml = ''' <form action="%(url)s" method="POST"> <input type="hidden" name="action" value="%(action)s"> <input type="hidden" name="do" value="%(do)s"> <input type="hidden" name="ticket" value="%(ticket)s"> <table> <tr> <td class="label"><label>%(newname_label)s</label></td> <td class="content"> <input type="text" name="newpagename" value="%(pagename)s" size="80"> </td> </tr> <tr> <td class="label"><label>%(attachment_label)s</label></td> <td class="content"> <input type="text" name="newattachmentname" value="%(attachment_name)s" size="80"> </td> </tr> <tr> <td></td> <td class="buttons"> <input type="hidden" name="oldattachmentname" value="%(attachment_name)s"> <input type="submit" name="move" value="%(move)s"> <input type="submit" name="cancel" value="%(cancel)s"> </td> </tr> </table> </form>''' % d thispage = Page(request, pagename) request.theme.add_msg(formhtml, "dialog") return thispage.send_page()
def sidebar(self, d, **keywords): """ Display page called SideBar as an additional element on every page @param d: parameter dictionary @rtype: string @return: sidebar html """ request = self.request _ = self.request.getText sidebar = request.getPragma('sidebar') or u'SideBar'; page = Page(request, sidebar) if not page.exists(): return u"" import StringIO buff = StringIO.StringIO() request.redirect(buff) try: page.send_page(content_only=1, content_id="sidebar") finally: request.redirect() return u'<div class="sidebar">%s</div>' % buff.getvalue()
def sidebar(self, d, **keywords): """ Display page called SideBar as an additional element on every page content_id has been changed from the original @param d: parameter dictionary @rtype: string @return: sidebar html """ # Check which page to display, return nothing if doesn't exist. sidebar = self.request.getPragma('sidebar', u'SideBar') page = Page(self.request, sidebar) if not page.exists(): return u"" # Capture the page's generated HTML in a buffer. buffer = StringIO.StringIO() self.request.redirect(buffer) try: page.send_page(content_only=1, content_id="sidebar-content") finally: self.request.redirect() return u'<div class="sidebar clearfix">%s</div>' % buffer.getvalue()
class LogoutHandler: def __init__(self, pagename, request): self.request = request self._ = request.getText self.page = Page(request, pagename) def handle(self): _ = self._ # if the user really was logged out say so, # but if the user manually added ?action=logout # and that isn't really supported, then don't if not self.request.user.valid: self.request.theme.add_msg(_("You are now logged out."), "info") return self.page.send_page()
def sidebar(self, d, **keywords): """ Display page called SideBar as an additional element on every page @param d: parameter dictionary @rtype: string @return: sidebar html """ request = self.request _ = self._ sidebar = request.getPragma('sidebar', u'SideBar') page = Page(request, sidebar) if not page.exists() or not request.user.may.read(page.page_name): return u'' buff = StringIO.StringIO() request.redirect(buff) try: try: page.send_page(content_only=1, content_id="sidebar") except TypeError: page.send_page(request, content_only=1, content_id="sidebar") finally: request.redirect() return u'<div class="sidebar">%s<div id="sidebar-end"></div></div>' % buff.getvalue()
def xmlrpc_getPageHTMLVersion(self, pagename, rev): """ Get HTML of from specific revision of pagename @param pagename: the page name (utf-8) @param rev: revision number (int) @rtype: str @return: page in rendered HTML (utf-8) """ pagename = self._instr(pagename) # User may read page? if not self.request.user.may.read(pagename): return self.notAllowedFault() if rev != None: page = Page(self.request, pagename, rev=rev) else: page = Page(self.request, pagename) # Non existing page? if not page.exists(): return self.noSuchPageFault() # Render page into a buffer import StringIO out = StringIO.StringIO() self.request.redirect(out) self.request.form = self.request.args = self.request.setup_args({}) page.send_page(self.request, content_only=1) result = out.getvalue() self.request.redirect() # Return rendered page if self.version == 2: return self._outstr(result) elif self.version == 1: return xmlrpclib.Binary(result)
def send_moveform(pagename, request): _ = request.getText filename, fpath = _access_file(pagename, request) if not filename: return # error msg already sent in _access_file # move file d = {'action': 'AttachFile', 'do': 'attachment_move', 'ticket': wikiutil.createTicket(request), 'pagename': pagename, 'attachment_name': filename, 'move': _('Move'), 'cancel': _('Cancel'), 'newname_label': _("New page name"), 'attachment_label': _("New attachment name"), } formhtml = ''' <form method="post" action=""> <input type="hidden" name="action" value="%(action)s"> <input type="hidden" name="do" value="%(do)s"> <input type="hidden" name="ticket" value="%(ticket)s"> <table> <tr> <td class="label"><label>%(newname_label)s</label></td> <td class="content"> <input type="text" name="newpagename" value="%(pagename)s"> </td> </tr> <tr> <td class="label"><label>%(attachment_label)s</label></td> <td class="content"> <input type="text" name="newattachmentname" value="%(attachment_name)s"> </td> </tr> <tr> <td></td> <td class="buttons"> <input type="hidden" name="oldattachmentname" value="%(attachment_name)s"> <input type="submit" name="move" value="%(move)s"> <input type="submit" name="cancel" value="%(cancel)s"> </td> </tr> </table> </form>''' % d thispage = Page(request, pagename) return thispage.send_page(request, msg=formhtml)
def execute(pagename, request): _ = request.getText page = Page(request, pagename) if not request.user.may.write(request.cfg.page_local_spelling_words): request.theme.add_msg(_("You can't save spelling words."), "error") page.send_page() return if request.user.may.read(pagename): badwords, badwords_re, msg = checkSpelling(page, request) else: badwords = [] request.theme.add_msg(_("You can't check spelling on a page you can't read."), "error") request.theme.add_msg(msg, "dialog") if badwords: page.send_page(hilite_re=badwords_re) else: page.send_page()
def execute(pagename, request): _ = request.getText page = Page(request, pagename) if not request.user.may.write(request.cfg.page_local_spelling_words): request.theme.add_msg(_("You can't save spelling words."), "error") page.send_page() return if request.user.may.read(pagename): badwords, badwords_re, msg = checkSpelling(page, request) else: badwords = [] request.theme.add_msg( _("You can't check spelling on a page you can't read."), "error") request.theme.add_msg(msg, "dialog") if badwords: page.send_page(hilite_re=badwords_re) else: page.send_page()
def execute(pagename, request): found = False for auth in request.cfg.auth: if isinstance(auth, MoinAuth): found = True break if not found: # we will not have linked, so forbid access request.makeForbidden(403, 'No MoinAuth in auth list') return page = Page(request, pagename) _ = request.getText form = request.values # link in mail -> GET request if not request.cfg.mail_enabled: request.theme.add_msg( _("""This wiki is not enabled for mail processing. Contact the owner of the wiki, who can enable email."""), 'warning') page.send_page() return submitted = form.get('account_sendmail', '') token = form.get('token', '') newpass = form.get('password', '') name = form.get('name', '') if token and name and newpass: newpass2 = form.get('password_repeat', '') msg = _("Passwords don't match!") msg_type = 'error' if newpass == newpass2: pw_checker = request.cfg.password_checker pw_error = None if pw_checker: pw_error = pw_checker(request, name, newpass) if pw_error: msg = _("Password not acceptable: %s") % wikiutil.escape( pw_error) if not pw_error: u = user.User(request, user.getUserId(request, name)) if u and u.valid and u.apply_recovery_token(token, newpass): msg = _( "Your password has been changed, you can log in now.") msg_type = 'info' else: msg = _('Your token is invalid!') if msg: request.theme.add_msg(msg, msg_type) if msg_type != 'error': page.send_page() return if token and name: request.theme.send_title(_("Password reset"), pagename=pagename) request.write(request.formatter.startContent("content")) request.write( _(""" == Password reset == Enter a new password below.""", wiki=True)) request.write(_create_token_form(request, name=name, token=token)) request.write(request.formatter.endContent()) request.theme.send_footer(pagename) request.theme.send_closing_html() elif submitted: # user pressed create button if request.method != 'POST': return msg = _do_recover(request) request.theme.add_msg(msg, "dialog") page.send_page() else: # show create form request.theme.send_title(_("Lost password"), pagename=pagename) request.write(request.formatter.startContent("content")) request.write( _(""" == Recovering a lost password == If you have forgotten your password, provide your email address or username and click on '''Mail me my account data'''. You will receive an email containing a recovery token that can be used to change your password. The email will also contain further instructions.""", wiki=True)) request.write(_create_form(request)) request.write(request.formatter.rule()) request.write( _(""" === Password reset === If you already have received the email with the recovery token, enter your username, the recovery token and a new password (twice) below.""", wiki=True)) request.write(_create_token_form(request)) request.write(request.formatter.endContent()) request.theme.send_footer(pagename) request.theme.send_closing_html()
def execute(pagename, request): """ Handle "action=diff" checking for either a "rev=formerrevision" parameter or rev1 and rev2 parameters """ if not request.user.may.read(pagename): Page(request, pagename).send_page() return try: date = request.values['date'] try: date = long(date) # must be long for py 2.2.x except StandardError: date = 0 except KeyError: date = 0 try: rev1 = int(request.values.get('rev1', -1)) except StandardError: rev1 = 0 try: rev2 = int(request.values.get('rev2', 0)) except StandardError: rev2 = 0 if rev1 == -1 and rev2 == 0: rev1 = request.rev if rev1 is None: rev1 = -1 # spacing flag? ignorews = int(request.values.get('ignorews', 0)) _ = request.getText # get a list of old revisions, and back out if none are available currentpage = Page(request, pagename) currentrev = currentpage.current_rev() if currentrev < 2: request.theme.add_msg(_("No older revisions available!"), "error") currentpage.send_page() return if date: # this is how we get called from RecentChanges rev1 = 0 log = editlog.EditLog(request, rootpagename=pagename) for line in log.reverse(): if date >= line.ed_time_usecs and int(line.rev) != 99999999: rev1 = int(line.rev) break else: rev1 = 1 rev2 = 0 if rev1 > 0 and rev2 > 0 and rev1 > rev2 or rev1 == 0 and rev2 > 0: rev1, rev2 = rev2, rev1 if rev1 == -1: oldrev = currentrev - 1 oldpage = Page(request, pagename, rev=oldrev) elif rev1 == 0: oldrev = currentrev oldpage = currentpage else: oldrev = rev1 oldpage = Page(request, pagename, rev=oldrev) if rev2 == 0: newrev = currentrev newpage = currentpage else: newrev = rev2 newpage = Page(request, pagename, rev=newrev) oldlog = oldpage.editlog_entry() newlog = newpage.editlog_entry() if not oldlog or not newlog: # We use "No log entries found." msg because we already have i18n # for that. Better would "At least one log entry was not found.". request.theme.add_msg(_("No log entries found."), "error") currentpage.send_page() return edit_count = abs(newrev - oldrev) # Start output # This action generates content in the user language request.setContentLanguage(request.lang) request.theme.send_title(_('Diff for "%s"') % (pagename, ), pagename=pagename, allow_doubleclick=1) f = request.formatter request.write(f.div(1, id="content")) oldrev = oldpage.get_real_rev() newrev = newpage.get_real_rev() title = _('Differences between revisions %d and %d') % (oldrev, newrev) if edit_count > 1: title += ' ' + _('(spanning %d versions)') % (edit_count, ) title = f.text(title) page_url = wikiutil.escape(currentpage.url(request), True) def enabled(val): return not val and u' disabled="disabled"' or u'' revert_html = "" if request.user.may.revert(pagename): revert_html = """ <form action="%s" method="get"> <div style="text-align:center"> <input name="action" value="revert" type="hidden"> <input name="rev" value="%d" type="hidden"> <input value="%s" type="submit"%s> </div> </form> """ % (page_url, rev2, _("Revert to this revision"), enabled(newrev < currentrev)) other_diff_button_html = """ <td style="border:0;"> <form action="%s" method="get"> <div style="text-align:%s"> <input name="action" value="diff" type="hidden"> <input name="rev1" value="%d" type="hidden"> <input name="rev2" value="%d" type="hidden"> <input value="%s" type="submit"%s> </div> </form> </td> """ navigation_html = """ <span class="diff-header">%%s</span> <table class="diff"> <tr> %(button)s <td style="border:0"> %%s </td> %(button)s </tr> </table> """ % { 'button': other_diff_button_html } prev_oldrev = (oldrev > 1) and (oldrev - 1) or 1 next_oldrev = (oldrev < currentrev) and (oldrev + 1) or currentrev prev_newrev = (newrev > 1) and (newrev - 1) or 1 next_newrev = (newrev < currentrev) and (newrev + 1) or currentrev navigation_html = navigation_html % ( title, page_url, "left", prev_oldrev, oldrev, _("Previous change"), enabled(oldrev > 1), revert_html, page_url, "right", newrev, next_newrev, _("Next change"), enabled(newrev < currentrev), ) request.write(f.rawHTML(navigation_html)) def rev_nav_link(enabled, old_rev, new_rev, caption, css_classes, enabled_title, disabled_title): if enabled: return currentpage.link_to( request, on=1, querystr={ 'action': 'diff', 'rev1': old_rev, 'rev2': new_rev, }, css_class="diff-nav-link %s" % css_classes, title=enabled_title) + request.formatter.text( caption) + currentpage.link_to(request, on=0) else: return '<span class="diff-no-nav-link %(css_classes)s" title="%(disabled_title)s">%(caption)s</span>' % { 'css_classes': css_classes, 'disabled_title': disabled_title, 'caption': caption, } rev_info_html = """ <div class="diff-info diff-info-header">%%(rev_first_link)s %%(rev_prev_link)s %(rev_header)s %%(rev_next_link)s %%(rev_last_link)s</div> <div class="diff-info diff-info-rev-size"><span class="diff-info-caption">%(rev_size_caption)s:</span> <span class="diff-info-value">%%(rev_size)d</span></div> <div class="diff-info diff-info-rev-author"><span class="diff-info-caption">%(rev_author_caption)s:</span> <span class="diff-info-value">%%(rev_author)s</span></div> <div class="diff-info diff-info-rev-comment"><span class="diff-info-caption">%(rev_comment_caption)s:</span> <span class="diff-info-value">%%(rev_comment)s</span></div> """ % { 'rev_header': _('Revision %(rev)d as of %(date)s'), 'rev_size_caption': _('Size'), 'rev_author_caption': _('Editor'), 'rev_ts_caption': _('Date'), 'rev_comment_caption': _('Comment'), } rev_info_old_html = rev_info_html % { 'rev_first_link': rev_nav_link(oldrev > 1, 1, newrev, u'\u21e4', 'diff-first-link diff-old-rev', _('Diff with oldest revision in left pane'), _("No older revision available for diff")), 'rev_prev_link': rev_nav_link(oldrev > 1, prev_oldrev, newrev, u'\u2190', 'diff-prev-link diff-old-rev', _('Diff with older revision in left pane'), _("No older revision available for diff")), 'rev_next_link': rev_nav_link( (oldrev < currentrev) and (next_oldrev < newrev), next_oldrev, newrev, u'\u2192', 'diff-next-link diff-old-rev', _('Diff with newer revision in left pane'), _("Can't change to revision newer than in right pane")), 'rev_last_link': '', 'rev': oldrev, 'rev_size': oldpage.size(), 'rev_author': oldlog.getEditor(request) or _('N/A'), 'date': request.user.getFormattedDateTime( wikiutil.version2timestamp(oldlog.ed_time_usecs)) or _('N/A'), 'rev_comment': wikiutil.escape(oldlog.comment) or '', } rev_info_new_html = rev_info_html % { 'rev_first_link': '', 'rev_prev_link': rev_nav_link( (newrev > 1) and (oldrev < prev_newrev), oldrev, prev_newrev, u'\u2190', 'diff-prev-link diff-new-rev', _('Diff with older revision in right pane'), _("Can't change to revision older than revision in left pane")), 'rev_next_link': rev_nav_link(newrev < currentrev, oldrev, next_newrev, u'\u2192', 'diff-next-link diff-new-rev', _('Diff with newer revision in right pane'), _("No newer revision available for diff")), 'rev_last_link': rev_nav_link(newrev < currentrev, oldrev, currentrev, u'\u21e5', 'diff-last-link diff-old-rev', _('Diff with newest revision in right pane'), _("No newer revision available for diff")), 'rev': newrev, 'rev_size': newpage.size(), 'rev_author': newlog.getEditor(request) or _('N/A'), 'date': request.user.getFormattedDateTime( wikiutil.version2timestamp(newlog.ed_time_usecs)) or _('N/A'), 'rev_comment': wikiutil.escape(newlog.comment) or '', } if request.user.show_fancy_diff: from MoinMoin.util import diff_html request.write( f.rawHTML( diff_html.diff(request, oldpage.get_raw_body(), newpage.get_raw_body(), old_top=rev_info_old_html, new_top=rev_info_new_html, old_top_class="diff-info", new_top_class="diff-info"))) newpage.send_page(count_hit=0, content_only=1, content_id="content-below-diff") else: request.write( f.rawHTML( '<table class="diff"><tr><td class="diff-info">%s</td><td class="diff-info">%s</td></tr></table>' % (rev_info_old_html, rev_info_new_html))) from MoinMoin.util import diff_text lines = diff_text.diff(oldpage.getlines(), newpage.getlines()) if not lines: msg = f.text(" - " + _("No differences found!")) if edit_count > 1: msg = msg + f.paragraph(1) + f.text( _('The page was saved %(count)d times, though!') % {'count': edit_count}) + f.paragraph(0) request.write(msg) else: if ignorews: request.write(f.text(_('(ignoring whitespace)')), f.linebreak()) else: qstr = { 'action': 'diff', 'ignorews': '1', } if rev1: qstr['rev1'] = str(rev1) if rev2: qstr['rev2'] = str(rev2) request.write( f.paragraph(1), Page(request, pagename).link_to( request, text=_('Ignore changes in the amount of whitespace'), querystr=qstr, rel='nofollow'), f.paragraph(0)) request.write(f.preformatted(1)) for line in lines: if line[0] == "@": request.write(f.rule(1)) request.write(f.text(line + '\n')) request.write(f.preformatted(0)) request.write(f.div(0)) # end content div request.theme.send_footer(pagename) request.theme.send_closing_html()
def execute(pagename, request): from MoinMoin import wikiutil from MoinMoin.Page import Page _ = request.getText thispage = Page(request, pagename) if request.user.valid: username = request.user.name else: username = '' if not username: request.theme.add_msg(_('Please log in first.'), "error") return thispage.send_page() userhomewiki = request.cfg.user_homewiki if userhomewiki != 'Self' and userhomewiki != request.cfg.interwikiname: interwiki = wikiutil.getInterwikiHomePage(request, username=username) wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki( request, *interwiki) wikiurl = wikiutil.mapURL(request, wikiurl) homepageurl = wikiutil.join_wiki(wikiurl, wikitail) request.http_redirect('%s?action=MyPages' % homepageurl) homepage = Page(request, username) if not homepage.exists(): request.theme.add_msg( _('Please first create a homepage before creating additional pages.' ), "error") return homepage.send_page() pagecontent = _("""\ You can add some additional sub pages to your already existing homepage here. You can choose how open to other readers or writers those pages shall be, access is controlled by group membership of the corresponding group page. Just enter the sub page's name and click on the button to create a new page. Before creating access protected pages, make sure the corresponding group page exists and has the appropriate members in it. Use HomepageGroupsTemplate for creating the group pages. ||'''Add a new personal page:'''||'''Related access control list group:'''|| ||<<NewPage(HomepageReadWritePageTemplate,read-write page,%(username)s)>>||[[%(username)s/ReadWriteGroup]]|| ||<<NewPage(HomepageReadPageTemplate,read-only page,%(username)s)>>||[[%(username)s/ReadGroup]]|| ||<<NewPage(HomepagePrivatePageTemplate,private page,%(username)s)>>||%(username)s only|| """) pagecontent = pagecontent % locals() pagecontent = pagecontent.replace('\n', '\r\n') from MoinMoin.parser.text_moin_wiki import Parser as WikiParser # This action generate data using the user language request.setContentLanguage(request.lang) request.theme.send_title(_('MyPages management'), page=homepage) parser = WikiParser(pagecontent, request) p = Page(request, "$$$") request.formatter.setPage(p) parser.format(request.formatter) # Start content - IMPORTANT - without content div, there is no direction support! request.write(request.formatter.startContent("content")) request.write(request.formatter.endContent()) request.theme.send_footer(homepage.page_name) request.theme.send_closing_html()
def execute(macro, text, args_re=re.compile(_args_re_pattern), title_re=re.compile(_title_re, re.M), called_by_toc=0): request = macro.request _ = request.getText # return immediately if getting links for the current page if request.mode_getpagelinks: return '' # parse and check arguments args = args_re.match(text) if not args: return (_sysmsg % ('error', _('Invalid include arguments "%s"!')) % (text,)) # prepare including page result = [] print_mode = macro.form.has_key('action') and macro.form['action'][0] == "print" this_page = macro.formatter.page if not hasattr(this_page, '_macroInclude_pagelist'): this_page._macroInclude_pagelist = {} # get list of pages to include inc_name = wikiutil.AbsPageName(request, this_page.page_name, args.group('name')) pagelist = [inc_name] if inc_name.startswith("^"): try: inc_match = re.compile(inc_name) except re.error: pass # treat as plain page name else: # Get user filtered readable page list pagelist = request.rootpage.getPageList(filter=inc_match.match) # sort and limit page list pagelist.sort() sort_dir = args.group('sort') if sort_dir == 'descending': pagelist.reverse() max_items = args.group('items') if max_items: pagelist = pagelist[:int(max_items)] skipitems = 0 if args.group("skipitems"): skipitems = int(args.group("skipitems")) titlesonly = args.group('titlesonly') editlink = args.group('editlink') # iterate over pages for inc_name in pagelist: if not request.user.may.read(inc_name): continue if this_page._macroInclude_pagelist.has_key(inc_name): result.append(u'<p><strong class="error">Recursive include of "%s" forbidden</strong></p>' % (inc_name,)) continue if skipitems: skipitems -= 1 continue fmt = macro.formatter.__class__(request, is_included=True) fmt._base_depth = macro.formatter._base_depth inc_page = Page(request, inc_name, formatter=fmt) inc_page._macroInclude_pagelist = this_page._macroInclude_pagelist # check for "from" and "to" arguments (allowing partial includes) body = inc_page.get_raw_body() + '\n' from_pos = 0 to_pos = -1 from_re = args.group('from') if from_re: try: from_match = re.compile(from_re, re.M).search(body) except re.error, e: ##result.append("*** fe=%s ***" % e) from_match = re.compile(re.escape(from_re), re.M).search(body) if from_match: from_pos = from_match.end() else: result.append(_sysmsg % ('warning', 'Include: ' + _('Nothing found for "%s"!')) % from_re) to_re = args.group('to') if to_re: try: to_match = re.compile(to_re, re.M).search(body, from_pos) except re.error: to_match = re.compile(re.escape(to_re), re.M).search(body, from_pos) if to_match: to_pos = to_match.start() else: result.append(_sysmsg % ('warning', 'Include: ' + _('Nothing found for "%s"!')) % to_re) if titlesonly: newbody = [] levelstack = [] for title, level in extract_titles(body[from_pos:to_pos], title_re): if levelstack: if level > levelstack[-1]: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) else: while levelstack and level < levelstack[-1]: result.append(macro.formatter.bullet_list(0)) levelstack.pop() if not levelstack or level != levelstack[-1]: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) else: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) result.append(macro.formatter.listitem(1)) result.append(inc_page.link_to(request, title)) result.append(macro.formatter.listitem(0)) while levelstack: result.append(macro.formatter.bullet_list(0)) levelstack.pop() continue if from_pos or to_pos != -1: inc_page.set_raw_body(body[from_pos:to_pos], modified=True) ##result.append("*** f=%s t=%s ***" % (from_re, to_re)) ##result.append("*** f=%d t=%d ***" % (from_pos, to_pos)) if called_by_toc: result.append(inc_page.get_raw_body()) continue if not hasattr(request, "_Include_backto"): request._Include_backto = this_page.page_name # do headings level = None if args.group('heading') and args.group('hquote'): heading = args.group('htext') or inc_page.split_title(request) level = 1 if args.group('level'): level = int(args.group('level')) if print_mode: result.append(macro.formatter.heading(1, level) + macro.formatter.text(heading) + macro.formatter.heading(0, level)) else: import sha from MoinMoin import config # this heading id might produce duplicate ids, # if the same page is included multiple times # Encode stuf we feed into sha module. pntt = (inc_name + heading).encode(config.charset) hid = "head-" + sha.new(pntt).hexdigest() request._page_headings.setdefault(pntt, 0) request._page_headings[pntt] += 1 if request._page_headings[pntt] > 1: hid += '-%d'%(request._page_headings[pntt],) result.append( #macro.formatter.heading(1, level, hid, # icons=edit_icon.replace('<img ', '<img align="right" ')) + macro.formatter.heading(1, level, hid) + inc_page.link_to(request, heading, css_class="include-heading-link") + macro.formatter.heading(0, level) ) # set or increment include marker this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist.get(inc_name, 0) + 1 # output the included page strfile = StringIO.StringIO() request.redirect(strfile) try: cid = request.makeUniqueID("Include_%s" % wikiutil.quoteWikinameFS(inc_page.page_name)) inc_page.send_page(request, content_only=1, content_id=cid) result.append(strfile.getvalue()) finally: request.redirect() # decrement or remove include marker if this_page._macroInclude_pagelist[inc_name] > 1: this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist[inc_name] - 1 else: del this_page._macroInclude_pagelist[inc_name] # if no heading and not in print mode, then output a helper link if editlink and not (level or print_mode): result.extend([ '<div class="include-link">', inc_page.link_to(request, '[%s]' % (inc_name,), css_class="include-page-link"), inc_page.link_to(request, '[%s]' % (_('edit'),), css_class="include-edit-link", querystr={'action': 'edit', 'backto': request._Include_backto}), '</div>', ])
def execute(pagename, request): from MoinMoin import wikiutil from MoinMoin.Page import Page _ = request.getText thispage = Page(request, pagename) if request.user.valid: username = request.user.name else: username = '' if not username: request.theme.add_msg(_('Please log in first.'), "error") return thispage.send_page() userhomewiki = request.cfg.user_homewiki if userhomewiki != 'Self' and userhomewiki != request.cfg.interwikiname: interwiki = wikiutil.getInterwikiHomePage(request, username=username) wikitag, wikiurl, wikitail, wikitag_bad = wikiutil.resolve_interwiki(request, *interwiki) wikiurl = wikiutil.mapURL(request, wikiurl) homepageurl = wikiutil.join_wiki(wikiurl, wikitail) request.http_redirect('%s?action=MyPages' % homepageurl) homepage = Page(request, username) if not homepage.exists(): request.theme.add_msg(_('Please first create a homepage before creating additional pages.'), "error") return homepage.send_page() pagecontent = _("""\ You can add some additional sub pages to your already existing homepage here. You can choose how open to other readers or writers those pages shall be, access is controlled by group membership of the corresponding group page. Just enter the sub page's name and click on the button to create a new page. Before creating access protected pages, make sure the corresponding group page exists and has the appropriate members in it. Use HomepageGroupsTemplate for creating the group pages. ||'''Add a new personal page:'''||'''Related access control list group:'''|| ||<<NewPage(HomepageReadWritePageTemplate,read-write page,%(username)s)>>||[[%(username)s/ReadWriteGroup]]|| ||<<NewPage(HomepageReadPageTemplate,read-only page,%(username)s)>>||[[%(username)s/ReadGroup]]|| ||<<NewPage(HomepagePrivatePageTemplate,private page,%(username)s)>>||%(username)s only|| """) pagecontent = pagecontent % locals() pagecontent = pagecontent.replace('\n', '\r\n') from MoinMoin.parser.text_moin_wiki import Parser as WikiParser request.emit_http_headers() # This action generate data using the user language request.setContentLanguage(request.lang) request.theme.send_title(_('MyPages management'), page=homepage) parser = WikiParser(pagecontent, request) p = Page(request, "$$$") request.formatter.setPage(p) parser.format(request.formatter) # Start content - IMPORTANT - without content div, there is no direction support! request.write(request.formatter.startContent("content")) request.write(request.formatter.endContent()) request.theme.send_footer(homepage.page_name) request.theme.send_closing_html()
raise pg.SaveError(_('TextCha: Wrong answer! Try again below...')) if request.cfg.comment_required and not comment: raise pg.SaveError(_('Supplying a comment is mandatory. Write a comment below and try again...')) savemsg = pg.saveText(savetext, rev, trivial=trivial, comment=comment) except pg.EditConflict, e: msg = e.message # Handle conflict and send editor pg.set_raw_body(savetext, modified=1) pg.mergeEditConflict(rev) # We don't send preview when we do merge conflict pg.sendEditor(msg=msg, comment=comment) return except pg.SaveError, msg: # Show the error message request.theme.add_msg(unicode(msg), "error") # And show the editor again pg.sendEditor(preview=savetext, comment=comment, staytop=1) return # Send new page after successful save request.reset() pg = Page(request, pagename) # sets revision number to default for further actions request.rev = 0 request.theme.add_msg(savemsg, "info") pg.send_page()
def handle_request(self): wiki_page_base = Page(self.request, _wiki_base) wiki_page_config = Page(self.request, _wiki_base+'/Config') form = self.request.form #=== Sanity checks: Create required pages if not exist, check if oauth config works === #create _wiki_base page, if not exists if not Page(self.request, _wiki_base).exists(): try: self.create_default_wikibase_page() except Exception as e: self.request.theme.add_msg('Could not create page "'+_wiki_base+'": '+pformat(e), 'error') Page(self.request, self.pagename).send_page() return #create Template page, if not exists if not Page(self.request, _wiki_base+'/Template').exists(): try: self.create_default_wikitemplate_page() except Exception as e: self.request.theme.add_msg('Could not create page "'+_wiki_base+'/Template'+'": '+pformat(e), 'error') Page(self.request, self.pagename).send_page() return if wiki_page_config.exists(): #parse config page and put as dict into self.config self.read_config(wiki_page_config) else: #create Log page, if not exists try: if not Page(self.request, _wiki_base+'/Log').exists(): self.create_default_wikilog_page() except Exception as e: self.request.theme.add_msg('Could not create page "'+_wiki_base+'/Log": '+pformat(e), 'error') Page(self.request, self.pagename).send_page() return #create Config page, if not exists try: self.create_default_config_page() except Exception as e: self.request.theme.add_msg('Could not create page "'+_wiki_base+'/Config'+'": '+pformat(e), 'error') Page(self.request, self.pagename).send_page() return self.request.theme.add_msg('Welcome to Mendeley2Moin. Pages needed for this plugin have been created.', 'info') Page(self.request, _wiki_base+'/Log').send_page() return #Create MendeleyImporter instance and try to login using consumer/secret key and the file with authenticated tokens self.mendeley_importer = MendeleyImporter(self.config['consumer_key'], self.config['secret_key']) #Check if the user submitted the OAuth verifier if self.request.values.has_key('submitVerifier'): #parse serialized token and verifier try: self.mendeley_importer.set_verified_token(self.request.values['token'], self.request.values['verifier']) except ValueError as e: self.request.theme.add_msg('Could not authenticate tokens: '+pformat(e), 'error') Page(self.request, _wiki_base+'/Log').send_page() return #save tokens as pickled file as attachment to Config page self.mendeley_importer.save_keys(AttachFile.getAttachDir(self.request, _wiki_base+'/Config')) self.prepend_to_wiki_page(_wiki_base+'/Log', 'OAuth configuration completed', \ 'Access tokens have been saved [[attachment:%s/Config/mendeley_api_keys.pkl | here]]. Click here to run the plugin: [[/|Mendeley2Moin|&action=Mendeley2Moin]]\n'+\ '\n(Or go to Mendeley2Moin overview page.)\n' % (_wiki_base)) self.request.theme.add_msg('Tokens verified.' % (wikiutil.escape(self.mendeley_importer.mendeley.request_token)), 'info') Page(self.request, _wiki_base+'/Log').send_page() return #Try to read file with authenticated tokens. They are supposed to be an attachment of the Config page attachment = u'mendeley_api_keys.pkl' if not AttachFile.exists(self.request, _wiki_base+'/Config', attachment): #If file with authenticated tokens does not exist, request URL and write it as Log message to the user try: auth_url = self.mendeley_importer.get_auth_url() except Exception as e: self.request.theme.add_msg('Could not request OAuth URL: '+pformat(e), 'error') wiki_page_base.send_page() return self.request.theme.add_msg('Register token on: '+auth_url, 'info') try: self.prepend_to_wiki_page(_wiki_base+'/Log', 'Step two: Register your OAuth token on mendeley.com', """\ * If you have a backup of the file {{{mendeley_api_keys.pkl}}}, upload it here [[attachment:%s/Config/mendeley_api_keys.pkl]]. * Otherwise [[%s|click here]] to register your token on mendeley.com. Then enter the verification code here: {{{#!html <form action="submit" method="GET"> <input type="hidden" name="action" value="Mendeley2Moin" /> <input type="hidden" name="token" value="%s" /> <input type="text" name="verifier" value="" size="36" /> <input type="submit" name="submitVerifier" value="Submit" /> </form> }}} """ % (_wiki_base, auth_url, wikiutil.escape(self.mendeley_importer.mendeley.request_token.to_string()))) except Exception as e: self.request.theme.add_msg('Could not edit page "'+_wiki_base+'/Log": '+pformat(e), 'error') Page(self.request, self.pagename).send_page() return Page(self.request, _wiki_base+'/Log').send_page() return #Get path of file with authenticated tokens and load it. self.config['api_keys_pkl_dir'] = AttachFile.getAttachDir(self.request, _wiki_base+'/Config') try: self.mendeley_importer.load_keys(self.config['api_keys_pkl_dir']) except Exception as e: self.request.theme.add_msg('Could not authenticate to Mendeley: '+pformat(e)+traceback.format_exc(), 'error') Page(self.request, self.pagename).send_page() return #=== Start with actual plugin === #read in documents and folders from Mendeley logstring = '' try: text_output = '=== Mendeley Documents ===\n' fold = self.mendeley_importer.get_folders() docs = self.mendeley_importer.get_documents(int(self.config['mendeley_folder'])) except ValueError as e: self.request.theme.add_msg('Error while calling Mendeley API: '+pformat(e)+traceback.format_exc(), 'error') Page(self.request, self.pagename).send_page() return #if GET parameter 'import' is set, import/update the appropriate documents if self.request.values.has_key('import'): import_id = self.request.values['import'] for doc in docs: if import_id=='all' or import_id=='new' or import_id==doc['id']: try: #If wiki page for document exists, update it. Otherwise create new page and import. if Page(self.request, doc['citation_key']).exists(): if import_id!='new': self.update_mendeley_doc(doc) logstring += 'Successfully updated %s\n' % (doc['citation_key']) else: self.import_mendeley_doc(doc) logstring += 'Successfully imported %s\n' % (doc['citation_key']) except PageEditor.Unchanged: pass #Download files attached to documents if self.config['enable_copy_pdf']=='True': try: #If wiki page for document exists, update it. Otherwise create new page and import. if Page(self.request, doc['citation_key']).exists(): if import_id!='new': if self.import_mendeley_attached_file(doc): logstring += ' -> Downloaded file %s.pdf\n' % (doc['citation_key']) #raise ValueError("asdf") else: self.import_mendeley_attached_file(doc) except Exception as e: logstring += 'WARNING: Could not import attached file from mendeley: %s\n' % (pformat(e)) #prepare print out of documents with links to pages and links to import/update for doc in docs: if(Page(self.request, doc['citation_key']).exists()): text_output += "|| [["+doc['citation_key']+"]] || "+doc['title']+"|| <<Action(Mendeley2Moin, Update, import="+doc['id']+")>> ||\n" else: text_output += "|| "+doc['citation_key']+" || "+doc['title']+"|| <<Action(Mendeley2Moin, Import, import="+doc['id']+")>> ||\n" text_output += '\n<<Action(Mendeley2Moin, Import all documents, import=all)>>\n' #prepare print out of list of folders text_output += '\n=== Mendeley Folders ===\n|| ID || Name ||\n' for folder in fold: text_output += '|| %s || %s ||\n' % (folder['id'], folder['name']) #now print all prepared stuff out self.request.formatter.page = Page(self.request, self.pagename) self.output_content_with_header_and_footer(self.request.formatter.rawHTML('<pre>'+wikiutil.escape(logstring)+'</pre>')+\ wikiutil.renderText(self.request, WikiParser, text_output))
def execute(macro, text, args_re=re.compile(_args_re_pattern), title_re=re.compile(_title_re, re.M), called_by_toc=0): request = macro.request _ = request.getText # return immediately if getting links for the current page if request.mode_getpagelinks: return '' # parse and check arguments args = text and args_re.match(text) if not args: return (_sysmsg % ('error', _('Invalid include arguments "%s"!')) % (text, )) # prepare including page result = [] print_mode = macro.form.has_key('action') and macro.form['action'][0] in ( "print", "format") this_page = macro.formatter.page if not hasattr(this_page, '_macroInclude_pagelist'): this_page._macroInclude_pagelist = {} # get list of pages to include inc_name = wikiutil.AbsPageName(request, this_page.page_name, args.group('name')) pagelist = [inc_name] if inc_name.startswith("^"): try: inc_match = re.compile(inc_name) except re.error: pass # treat as plain page name else: # Get user filtered readable page list pagelist = request.rootpage.getPageList(filter=inc_match.match) # sort and limit page list pagelist.sort() sort_dir = args.group('sort') if sort_dir == 'descending': pagelist.reverse() max_items = args.group('items') if max_items: pagelist = pagelist[:int(max_items)] skipitems = 0 if args.group("skipitems"): skipitems = int(args.group("skipitems")) titlesonly = args.group('titlesonly') editlink = args.group('editlink') # iterate over pages for inc_name in pagelist: if not request.user.may.read(inc_name): continue if this_page._macroInclude_pagelist.has_key(inc_name): result.append( u'<p><strong class="error">Recursive include of "%s" forbidden</strong></p>' % (inc_name, )) continue if skipitems: skipitems -= 1 continue fmt = macro.formatter.__class__(request, is_included=True) fmt._base_depth = macro.formatter._base_depth inc_page = Page(request, inc_name, formatter=fmt) if not inc_page.exists(): continue inc_page._macroInclude_pagelist = this_page._macroInclude_pagelist # check for "from" and "to" arguments (allowing partial includes) body = inc_page.get_raw_body() + '\n' # body = body.replace(this_page.page_name, "_" + this_page.page_name + "_") body = body.replace('amcl', "_" + this_page.page_name + "_") # set or increment include marker this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist.get(inc_name, 0) + 1 # output the included page strfile = StringIO.StringIO() request.redirect(strfile) try: cid = request.makeUniqueID( "Include_%s" % wikiutil.quoteWikinameURL(inc_page.page_name)) inc_page.send_page(request, content_only=1, content_id=cid, omit_footnotes=True) result.append(strfile.getvalue()) finally: request.redirect() # decrement or remove include marker if this_page._macroInclude_pagelist[inc_name] > 1: this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist[inc_name] - 1 else: del this_page._macroInclude_pagelist[inc_name] # return include text str = ''.join(result) return str
class LoginHandler: def __init__(self, pagename, request): self.request = request self._ = request.getText self.cfg = request.cfg self.pagename = pagename self.page = Page(request, pagename) def handle_multistage(self): """Handle a multistage request. If the auth handler wants a multistage request, we now set up the login form for that. """ _ = self._ request = self.request form = html.FORM(method='POST', name='logincontinue', action=self.pagename) form.append(html.INPUT(type='hidden', name='action', value='login')) form.append(html.INPUT(type='hidden', name='login', value='1')) form.append( html.INPUT(type='hidden', name='stage', value=request._login_multistage_name)) request.theme.send_title(_("Login"), pagename=self.pagename) # Start content (important for RTL support) request.write(request.formatter.startContent("content")) extra = request._login_multistage(request, form) request.write(unicode(form)) if extra: request.write(extra) request.write(request.formatter.endContent()) request.theme.send_footer(self.pagename) request.theme.send_closing_html() def handle(self): _ = self._ request = self.request form = request.values error = None islogin = form.get('login', '') if islogin: # user pressed login button if request._login_multistage: return self.handle_multistage() if hasattr(request, '_login_messages'): for msg in request._login_messages: request.theme.add_msg(wikiutil.escape(msg), "error") return self.page.send_page() else: # show login form request.theme.send_title(_("Login"), pagename=self.pagename) # Start content (important for RTL support) request.write(request.formatter.startContent("content")) request.write(userform.getLogin(request)) request.write(request.formatter.endContent()) request.theme.send_footer(self.pagename) request.theme.send_closing_html()
class LoginHandler: def __init__(self, pagename, request): self.request = request self._ = request.getText self.cfg = request.cfg self.pagename = pagename self.page = Page(request, pagename) def handle_multistage(self): """Handle a multistage request. If the auth handler wants a multistage request, we now set up the login form for that. """ _ = self._ request = self.request form = html.FORM(method='POST', name='logincontinue') form.append(html.INPUT(type='hidden', name='login', value='login')) form.append(html.INPUT(type='hidden', name='stage', value=request._login_multistage_name)) request.emit_http_headers() request.theme.send_title(_("Login"), pagename=self.pagename) # Start content (important for RTL support) request.write(request.formatter.startContent("content")) extra = request._login_multistage(request, form) request.write(unicode(form)) if extra: request.write(extra) request.write(request.formatter.endContent()) request.theme.send_footer(self.pagename) request.theme.send_closing_html() def handle(self): _ = self._ request = self.request form = request.form error = None islogin = form.get('login', [''])[0] if islogin: # user pressed login button if request._login_multistage: return self.handle_multistage() error = [] if hasattr(request, '_login_messages'): for msg in request._login_messages: error.append('<p>') error.append(msg) error = ''.join(error) request.theme.add_msg(error, "error") return self.page.send_page() else: # show login form request.emit_http_headers() request.theme.send_title(_("Login"), pagename=self.pagename) # Start content (important for RTL support) request.write(request.formatter.startContent("content")) request.write(userform.getLogin(request)) request.write(request.formatter.endContent()) request.theme.send_footer(self.pagename) request.theme.send_closing_html()
request.theme.add_msg(unicode(msg), "error") # And show the editor again pg.sendEditor(preview=savetext, comment=comment, staytop=1) return # Send new page after successful save request.reset() pg = Page(request, pagename) ngowikiutil = NgoWikiUtil(request) ngowikiutil.open_database() try: pageinfo = ngowikiutil.parse_page(pg) pagerecord = ngowikiutil.select_page_by_path(pg.page_name) page_uuid = None if pagerecord == None: page_uuid = ngowikiutil.insert_page(pg)["id"] else: page_uuid = pagerecord["id"] ngowikiutil.update_page(page_uuid, pg) pageinfo["id"] = page_uuid ngowikiutil.update_page_meta(pageinfo) ngowikiutil.update_idea_status(page_uuid, ideastatus) finally: ngowikiutil.close_database(True) # sets revision number to default for further actions request.rev = 0 request.theme.add_msg(savemsg, "info") pg.send_page()
def execute(pagename, request): _ = request.getText def wr(fmt, *args): request.write(form_writer(fmt, *args)) # This action generates data using the user language request.setContentLanguage(request.lang) form = values_to_form(request.values) if form.has_key('cancel'): request.reset() backto = form.get('backto', [None])[0] request.theme.add_msg(_('Edit was cancelled.'), "error") if backto: page = Page(request, backto) request.http_redirect(page.url(request)) request.page = page request.page.send_page() elif form.has_key('save') or form.has_key('saveform'): if request.environ['REQUEST_METHOD'] != 'POST': request.page.send_page() return template = form.get('template', [None])[0] # MetaFormEdit is much closer to set_meta in function if form.has_key('saveform'): added, cleared = {pagename: dict()}, {pagename: list()} # Pre-create page if it does not exist, using the template specified if template: added[pagename]['gwikitemplate'] = template # Ignore form clutter ignore = set() files = dict() for key in request.files: ignore.add(key) _file = request.files.get(key) filename = _file.filename fileobj = _file.stream # if type(fileobj) != file: # continue banana = key.split(SEPARATOR) keys = files.setdefault(banana[0], dict()) values = keys.setdefault(banana[1], list()) values.append((filename, fileobj)) keys = list() for key in form: if key not in ignore and SEPARATOR in key: keys.append(key.split(SEPARATOR)[1]) # keys = [x.split(SEPARATOR)[1] for x in form if SEPARATOR in x] for key in keys: cleared[pagename].append(key) vals = [x.strip() for x in form[pagename + SEPARATOR + key] if x.strip()] if vals: added[pagename].setdefault(key, list()).extend(vals) msgs = list() # Add attachments for pname in files: for key in files[pname]: for value in files[pname][key]: name = value[0] try: t, s = add_attachment(request, pname, name, value[1]) added.setdefault(pname, dict()).setdefault( key, list()).append("[[attachment:%s]]" % name) except AttachmentAlreadyExists: msgs = ["Attachment '%s' already exists." % name] _, msgss = set_metas(request, cleared, dict(), added) msgs.extend(msgss) else: # MetaEdit pages, msgs, files = parse_editform(request, form) if pages: saved_templates = False for page, _ in pages.iteritems(): # Save the template if needed if not Page(request, page).exists() and template: msgs.append(save_template(request, page, template)) saved_templates = True # If new pages were changed we need to redo parsing # the form to know what we really need to edit if saved_templates: pages, newmsgs, files = parse_editform(request, form) for page, (oldMeta, newMeta) in pages.iteritems(): msgs.append('%s: ' % page + edit_meta(request, page, oldMeta, newMeta)) for page in files: for key in files[page]: name, content = files[page][key] t, s = add_attachment(request, page, name, content) else: msgs.append(request.getText('No pages changed')) msg = '' for line in msgs: msg += line + request.formatter.linebreak(0) request.reset() backto = form.get('backto', [None])[0] if backto: page = Page(request, backto) request.http_redirect(page.url(request)) else: page = Page(request, pagename) request.theme.add_msg(msg) request.page = page page.send_page() elif form.has_key('args'): enter_page(request, pagename, 'Metatable editor') formatter = request.page.formatter request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit metatable"))) request.write(formatter.heading(0, 2)) args = ', '.join(form['args']) show_editform(wr, request, pagename, args) exit_page(request, pagename) else: enter_page(request, pagename, 'Metatable editor') formatter = request.page.formatter request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit current page"))) request.write(formatter.heading(0, 2)) show_editform(wr, request, pagename, pagename) request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit metatable"))) request.write(formatter.heading(0, 2)) show_queryform(wr, request, pagename) exit_page(request, pagename) return
class ActionBase: """ action base class with some generic stuff to inherit Note: the action name is the class name of the derived class """ def __init__(self, pagename, request): self.request = request self.form = request.form self.cfg = request.cfg self._ = _ = request.getText self.pagename = pagename self.actionname = self.__class__.__name__ self.use_ticket = False # set this to True if you want to use a ticket self.user_html = '''Just checking.''' # html fragment for make_form self.form_cancel = "cancel" # form key for cancelling action self.form_cancel_label = _("Cancel") # label for the cancel button self.form_trigger = "doit" # form key for triggering action (override with e.g. 'rename') self.form_trigger_label = _("Do it.") # label for the trigger button self.page = Page(request, pagename) self.error = '' # CHECKS ----------------------------------------------------------------- def is_excluded(self): """ Return True if action is excluded """ return self.actionname in self.cfg.actions_excluded def is_allowed(self): """ Return True if action is allowed (by ACL) """ return True def check_condition(self): """ Check if some other condition is not allowing us to do that action, return error msg or None if there is no problem. You can use this to e.g. check if a page exists. """ return None def ticket_ok(self): """ Return True if we check for tickets and there is some valid ticket in the form data or if we don't check for tickets at all. Use this to make sure someone really used the web interface. """ if not self.use_ticket: return True # Require a valid ticket. Make outside attacks harder by # requiring two full HTTP transactions ticket = self.form.get('ticket', [''])[0] return wikiutil.checkTicket(self.request, ticket) # UI --------------------------------------------------------------------- def get_form_html(self, buttons_html): """ Override this to assemble the inner part of the form, for convenience we give him some pre-assembled html for the buttons. """ _ = self._ prompt = _("Execute action %(actionname)s?") % {'actionname': self.actionname} return "<p>%s</p>%s" % (prompt, buttons_html) def make_buttons(self): """ return a list of form buttons for the action form """ return [ (self.form_trigger, self.form_trigger_label), (self.form_cancel, self.form_cancel_label), ] def make_form(self): """ Make some form html for later display. The form might contain an error that happened when trying to do the action. """ from MoinMoin.widget.dialog import Dialog _ = self._ if self.error: error_html = u'<p class="error">%s</p>\n' % self.error else: error_html = '' buttons = self.make_buttons() buttons_html = [] for button in buttons: buttons_html.append('<input type="submit" name="%s" value="%s">' % button) buttons_html = "".join(buttons_html) if self.use_ticket: ticket_html = '<input type="hidden" name="ticket" value="%s">' % wikiutil.createTicket(self.request) else: ticket_html = '' d = { 'error_html': error_html, 'actionname': self.actionname, 'pagename': self.pagename, 'ticket_html': ticket_html, 'user_html': self.get_form_html(buttons_html), } form_html = ''' %(error_html)s <form method="post" action=""> <input type="hidden" name="action" value="%(actionname)s"> %(ticket_html)s %(user_html)s </form>''' % d return Dialog(self.request, content=form_html) def render_msg(self, msg): """ Called to display some message (can also be the action form) """ self.page.send_page(self.request, msg=msg) def render_success(self, msg): """ Called to display some message when the action succeeded """ self.page.send_page(self.request, msg=msg) def render_cancel(self): """ Called when user has hit the cancel button """ self.page.send_page(self.request) # we don't tell user he has hit cancel :) def render(self): """ Render action - this is the main function called by action's execute() function. We usually render a form here, check for posted forms, etc. """ _ = self._ form = self.form if form.has_key(self.form_cancel): self.render_cancel() return # Validate allowance, user rights and other conditions. error = None if self.is_excluded(): error = _('Action %(actionname)s is excluded in this wiki!') % {'actionname': self.actionname } elif not self.is_allowed(): error = _('You are not allowed to use action %(actionname)s on this page!') % {'actionname': self.actionname } if error is None: error = self.check_condition() if error: self.render_msg(error) elif form.has_key(self.form_trigger): # user hit the trigger button if self.ticket_ok(): success, self.error = self.do_action() else: success = False self.error = _('Please use the interactive user interface to use action %(actionname)s!') % {'actionname': self.actionname } self.do_action_finish(success) else: # Return a new form self.render_msg(self.make_form()) # Executing the action --------------------------------------------------- def do_action(self): """ Do the action and either return error msg or None, if there was no error. """ return None # AFTER the action ------------------------------------------------------- def do_action_finish(self, success): """ Override this to handle success or failure (with error in self.error) of your action. """ if success: self.render_success(self.error) else: self.render_msg(self.make_form()) # display the form again
def execute(pagename, request): _ = request.getText def wr(fmt, *args): request.write(form_writer(fmt, *args)) # This action generates data using the user language request.setContentLanguage(request.lang) form = values_to_form(request.values) if form.has_key('cancel'): request.reset() backto = form.get('backto', [None])[0] request.theme.add_msg(_('Edit was cancelled.'), "error") if backto: page = Page(request, backto) request.http_redirect(page.url(request)) request.page = page request.page.send_page() elif form.has_key('save') or form.has_key('saveform'): if request.environ['REQUEST_METHOD'] != 'POST': request.page.send_page() return template = form.get('template', [None])[0] # MetaFormEdit is much closer to set_meta in function if form.has_key('saveform'): added, cleared = {pagename: dict()}, {pagename: list()} # Pre-create page if it does not exist, using the template specified if template: added[pagename]['gwikitemplate'] = template # Ignore form clutter ignore = set() files = dict() for key in request.files: ignore.add(key) _file = request.files.get(key) filename = _file.filename fileobj = _file.stream # if type(fileobj) != file: # continue banana = key.split(SEPARATOR) keys = files.setdefault(banana[0], dict()) values = keys.setdefault(banana[1], list()) values.append((filename, fileobj)) keys = list() for key in form: if key not in ignore and SEPARATOR in key: keys.append(key.split(SEPARATOR)[1]) # keys = [x.split(SEPARATOR)[1] for x in form if SEPARATOR in x] for key in keys: cleared[pagename].append(key) vals = [ x.strip() for x in form[pagename + SEPARATOR + key] if x.strip() ] if vals: added[pagename].setdefault(key, list()).extend(vals) msgs = list() # Add attachments for pname in files: for key in files[pname]: for value in files[pname][key]: name = value[0] try: t, s = add_attachment(request, pname, name, value[1]) added.setdefault(pname, dict()).setdefault( key, list()).append("[[attachment:%s]]" % name) except AttachmentAlreadyExists: msgs = ["Attachment '%s' already exists." % name] _, msgss = set_metas(request, cleared, dict(), added) msgs.extend(msgss) else: # MetaEdit pages, msgs, files = parse_editform(request, form) if pages: saved_templates = False for page, _ in pages.iteritems(): # Save the template if needed if not Page(request, page).exists() and template: msgs.append(save_template(request, page, template)) saved_templates = True # If new pages were changed we need to redo parsing # the form to know what we really need to edit if saved_templates: pages, newmsgs, files = parse_editform(request, form) for page, (oldMeta, newMeta) in pages.iteritems(): msgs.append('%s: ' % page + edit_meta(request, page, oldMeta, newMeta)) for page in files: for key in files[page]: name, content = files[page][key] t, s = add_attachment(request, page, name, content) else: msgs.append(request.getText('No pages changed')) msg = '' for line in msgs: msg += line + request.formatter.linebreak(0) request.reset() backto = form.get('backto', [None])[0] if backto: page = Page(request, backto) request.http_redirect(page.url(request)) else: page = Page(request, pagename) request.theme.add_msg(msg) request.page = page page.send_page() elif form.has_key('args'): enter_page(request, pagename, 'Metatable editor') formatter = request.page.formatter request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit metatable"))) request.write(formatter.heading(0, 2)) args = ', '.join(form['args']) show_editform(wr, request, pagename, args) exit_page(request, pagename) else: enter_page(request, pagename, 'Metatable editor') formatter = request.page.formatter request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit current page"))) request.write(formatter.heading(0, 2)) show_editform(wr, request, pagename, pagename) request.write(formatter.heading(1, 2)) request.write(formatter.text(_("Edit metatable"))) request.write(formatter.heading(0, 2)) show_queryform(wr, request, pagename) exit_page(request, pagename) return
def execute(macro, text, args_re=re.compile(_args_re_pattern), title_re=re.compile(_title_re, re.M)): request = macro.request _ = request.getText # return immediately if getting links for the current page if request.mode_getpagelinks: return '' # parse and check arguments args = text and args_re.match(text) if not args: return (_sysmsg % ('error', _('Invalid include arguments "%s"!')) % (text, )) # prepare including page result = [] print_mode = request.action in ("print", "format") this_page = macro.formatter.page if not hasattr(this_page, '_macroInclude_pagelist'): this_page._macroInclude_pagelist = {} # get list of pages to include inc_name = wikiutil.AbsPageName(this_page.page_name, args.group('name')) pagelist = [inc_name] if inc_name.startswith("^"): try: inc_match = re.compile(inc_name) except re.error: pass # treat as plain page name else: # Get user filtered readable page list pagelist = request.rootpage.getPageList(filter=inc_match.match) # sort and limit page list pagelist.sort() sort_dir = args.group('sort') if sort_dir == 'descending': pagelist.reverse() max_items = args.group('items') if max_items: pagelist = pagelist[:int(max_items)] skipitems = 0 if args.group("skipitems"): skipitems = int(args.group("skipitems")) titlesonly = args.group('titlesonly') editlink = args.group('editlink') # iterate over pages for inc_name in pagelist: if not request.user.may.read(inc_name): continue if inc_name in this_page._macroInclude_pagelist: result.append(u'<p><strong class="error">Recursive include of "%s" forbidden</strong></p>' % (inc_name, )) continue if skipitems: skipitems -= 1 continue fmt = macro.formatter.__class__(request, is_included=True) fmt._base_depth = macro.formatter._base_depth inc_page = Page(request, inc_name, formatter=fmt) if not inc_page.exists(): continue inc_page._macroInclude_pagelist = this_page._macroInclude_pagelist # check for "from" and "to" arguments (allowing partial includes) body = inc_page.get_raw_body() + '\n' from_pos = 0 to_pos = -1 from_re = args.group('from') if from_re: try: from_match = re.compile(from_re, re.M).search(body) except re.error: ##result.append("*** fe=%s ***" % e) from_match = re.compile(re.escape(from_re), re.M).search(body) if from_match: from_pos = from_match.end() else: result.append(_sysmsg % ('warning', 'Include: ' + _('Nothing found for "%s"!')) % from_re) to_re = args.group('to') if to_re: try: to_match = re.compile(to_re, re.M).search(body, from_pos) except re.error: to_match = re.compile(re.escape(to_re), re.M).search(body, from_pos) if to_match: to_pos = to_match.start() else: result.append(_sysmsg % ('warning', 'Include: ' + _('Nothing found for "%s"!')) % to_re) if titlesonly: levelstack = [] for title, level in extract_titles(body[from_pos:to_pos], title_re): if levelstack: if level > levelstack[-1]: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) else: while levelstack and level < levelstack[-1]: result.append(macro.formatter.bullet_list(0)) levelstack.pop() if not levelstack or level != levelstack[-1]: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) else: result.append(macro.formatter.bullet_list(1)) levelstack.append(level) result.append(macro.formatter.listitem(1)) result.append(inc_page.link_to(request, title)) result.append(macro.formatter.listitem(0)) while levelstack: result.append(macro.formatter.bullet_list(0)) levelstack.pop() continue if from_pos or to_pos != -1: inc_page.set_raw_body(body[from_pos:to_pos], modified=True) ##result.append("*** f=%s t=%s ***" % (from_re, to_re)) ##result.append("*** f=%d t=%d ***" % (from_pos, to_pos)) if not hasattr(request, "_Include_backto"): request._Include_backto = this_page.page_name # do headings level = None if args.group('heading') and args.group('hquote'): heading = args.group('htext') or inc_page.split_title() level = 1 if args.group('level'): level = int(args.group('level')) if print_mode: result.append(macro.formatter.heading(1, level) + macro.formatter.text(heading) + macro.formatter.heading(0, level)) else: url = inc_page.url(request) result.extend([ macro.formatter.heading(1, level, id=heading), macro.formatter.url(1, url, css="include-heading-link"), macro.formatter.text(heading), macro.formatter.url(0), macro.formatter.heading(0, level), ]) # set or increment include marker this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist.get(inc_name, 0) + 1 # output the included page strfile = StringIO.StringIO() request.redirect(strfile) try: inc_page.send_page(content_only=True, omit_footnotes=True, count_hit=False) result.append(strfile.getvalue()) finally: request.redirect() # decrement or remove include marker if this_page._macroInclude_pagelist[inc_name] > 1: this_page._macroInclude_pagelist[inc_name] = \ this_page._macroInclude_pagelist[inc_name] - 1 else: del this_page._macroInclude_pagelist[inc_name] # if no heading and not in print mode, then output a helper link if editlink and not (level or print_mode): result.extend([ macro.formatter.div(1, css_class="include-link"), inc_page.link_to(request, '[%s]' % (inc_name, ), css_class="include-page-link"), inc_page.link_to(request, '[%s]' % (_('edit'), ), css_class="include-edit-link", querystr={'action': 'edit', 'backto': request._Include_backto}), macro.formatter.div(0), ]) # XXX page.link_to is wrong now, it escapes the edit_icon html as it escapes normal text # return include text return ''.join(result)
# Needed to load configuration sys.path = [ os.getcwd(), ] + sys.path url = re.sub("%", re.escape(pageName), options.url_template) request = RequestCLI(url=url, pagename=pageName) Formatter = wikiutil.importPlugin(request.cfg, "formatter", "text_x-rst", "Formatter") formatter = Formatter(request) request.formatter = formatter page = Page(request, pageName, rev=options.revision, formatter=formatter) if not page.exists(): raise RuntimeError("No page named %r" % ( pageName, )) page.send_page() # TODO Extension for reStructuredText parser in MoinMoin: # # * Support for role `macro` for using inline macros such as # ``:macro:`Date(...)``` to replace the macro-as-a-link-hack # # * Expansion of @SIG@ and other variables must be done by the formatter # # * Role `smiley` must expand to the respective smiley # # * Otherwise for standard smileys there should be a default list of # substitutions # # * Role `icon` must expand to the respective icon #