def do_replaceunderlayattachment(self, zipname, filename, pagename, author=u"Scripting Subsystem", comment=u""): """ overwrite underlay attachments @param pagename: Page where the file is attached. Or in 2.0, the file itself. @param zipname: Filename of the attachment from the zip file @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0) """ if self.request.user.may.write(pagename): _ = self.request.getText filename = wikiutil.taintfilename(filename) zipname = wikiutil.taintfilename(zipname) page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author) pagedir = page.getPagePath(use_underlay=1, check_create=1) attachments = os.path.join(pagedir, 'attachments') if not os.path.exists(attachments): os.mkdir(attachments) target = os.path.join(attachments, filename) self._extractToFile(zipname, target) if os.path.exists(target): filesys.chmod(target, 0666 & config.umask) else: self.msg += u"action replace underlay attachment: not enough rights - nothing done \n"
def group_del(request, grouppage, accounts): _ = request.getText success, msg = check_grouppage(request, grouppage) if not success: raise GroupException(msg + "(%s)" % (grouppage)) members = request.groups[grouppage].members | request.groups[grouppage].member_groups for name in accounts: if name not in members: raise GroupException(name + _(' not in group: ') + grouppage) page = PageEditor(request, grouppage) pagetext = page.get_raw_body() newtext = _group_del(request, pagetext, accounts) msg = page.saveText(newtext, 0, comment="Deleted from group: " + ', '.join(accounts)) newmembers = request.groups[grouppage].members | request.groups[grouppage].member_groups if not newmembers == members - set(accounts): msg = page.saveText(pagetext, 0, comment="Reverting due to problems in group operation.") raise GroupException(_('Delete unsuccessful for unknown reasons.')) return True, msg
def save(self, editor, newtext, rev, **kw): request = self.request username = request.user.name pagename = editor.page_name if grouppage_autocreate and username == pagename: # create group pages when a user saves his own homepage for page in grouppages: grouppagename = "%s/%s" % (username, page) grouppage = Page(request, grouppagename) if not grouppage.exists(): text = """\ #acl %(username)s:read,write,delete,revert * %(username)s """ % locals() editor = PageEditor(request, grouppagename) editor._write_file(text) parts = pagename.split('/') if len(parts) == 2: subpage = parts[1] if subpage in grouppages and not self.admin(pagename): return False # No problem to save if my base class agrees return Permissions.save(self, editor, newtext, rev, **kw)
def do_action(self): """ copy this page to "pagename" """ _ = self._ # Currently we only check TextCha for upload (this is what spammers ususally do), # but it could be extended to more/all attachment write access if not TextCha(self.request).check_answer_from_form(): return status, _('TextCha: Wrong answer! Go back and try again...') form = self.form newpagename = form.get('newpagename', u'') newpagename = wikiutil.normalize_pagename(newpagename, self.cfg) comment = form.get('comment', u'') comment = wikiutil.clean_input(comment) self.page = PageEditor(self.request, self.pagename) success, msgs = self.page.copyPage(newpagename, comment) copy_subpages = 0 try: copy_subpages = int(form['copy_subpages']) except: pass if copy_subpages and self.subpages or (not self.users_subpages and self.subpages): for name in self.subpages: self.page = PageEditor(self.request, name) new_subpagename = name.replace(self.pagename, newpagename, 1) success_i, msg = self.page.copyPage(new_subpagename, comment) msgs = "%s %s" % (msgs, msg) self.newpagename = newpagename # keep there for finish return success, msgs
def mainloop(self): self.init_request() request = self.request request.user.may = IAmRoot() request.cfg.mail_enabled = False for root, dirs, files in os.walk(self.options.file_dir): files.sort() for filename in files: pagename = self.options.page + filename_function(filename) #print "Pushing %r as %r" % (filename, pagename) p = PageEditor(request, pagename, do_editor_backup=0, uid_override=self.options.author, do_revision_backup=0) if p.exists(): if filename != files[-1]: continue else: p = PageEditor(request, pagename, do_editor_backup=0, uid_override=self.options.author) fileObj = open(os.path.join(root, filename), 'rb') try: acl = "" if self.options.acl: acl = "#acl %s\n" % (self.options.acl, ) p.saveText(acl + "#format irc\n" + decodeLinewise(fileObj.read()), 0) except PageEditor.Unchanged, e: pass except PageEditor.SaveError, e: print "Got %r" % (e, ) fileObj.close()
def xmlrpc_putPage(self, pagename, pagetext): """ save a page / change a page to a new text @param pagename: the page name (unicode or utf-8) @param pagetext: the new page text (content, unicode or utf-8) @rtype: bool @return: True on success """ pagename = self._instr(pagename) pagename = wikiutil.normalize_pagename(pagename, self.cfg) if not pagename: return xmlrpclib.Fault("INVALID", "pagename can't be empty") # check ACLs if not self.request.user.may.write(pagename): return xmlrpclib.Fault(1, "You are not allowed to edit this page") page = PageEditor(self.request, pagename, do_editor_backup=0) try: if self.version == 2: newtext = self._instr(pagetext) elif self.version == 1: newtext = self._inlob(pagetext) msg = page.saveText(newtext, 0) except page.SaveError, msg: logging.error("SaveError: %s" % msg) return xmlrpclib.Fault(1, "%s" % msg)
def xmlrpc_revertPage(self, pagename, revision): """ Revert a page to previous revision This is mainly intended to be used by the jabber bot. @param pagename: the page name (unicode or utf-8) @param revision: revision to revert to @rtype: bool @return: True on success """ pagename = self._instr(pagename) if not self.request.user.may.write(pagename): return xmlrpclib.Fault(1, "You are not allowed to edit this page") rev = int(self._instr(revision)) editor = PageEditor(self.request, pagename, do_editor_backup=0) try: editor.revertPage(rev) except PageEditor.SaveError, error: return xmlrpclib.Fault(1, "Revert failed: %s" % (str(error), ))
def execute(pagename, request): form = values_to_form(request.values) template = form.get('template', [''])[0] if template and not request.page.exists(): template_page = wikiutil.unquoteWikiname(template) if request.user.may.read(template_page): editor = PageEditor(request, template_page) editor.user = request.user text = editor.get_raw_body() editor.page_name = pagename request.page.set_raw_body(editor._expand_variables(text)) newdata = parse_text(request, request.page, request.page.get_raw_body()) # Add prototype metas (^ something::\s*$) as keys protokeys = [y for x,y in dl_proto_re.findall(text)] for key in protokeys: if not (key in newdata[pagename].get('out', dict()) or key in newdata[pagename].get('meta', dict())): newdata[pagename].setdefault('meta', dict())[key] = list() # I'll lie, cheat, do anything to make this work newdata[pagename]['saved'] = True # Add the template metas to cache so that they'd show request.graphdata.cacheset(pagename, newdata.get(pagename, dict())) MetaEdit.execute(pagename, request)
def do_action(self): """ Rename this page to "pagename" """ _ = self._ form = self.form newpagename = form.get('newpagename', [u''])[0] newpagename = self.request.normalizePagename(newpagename) comment = form.get('comment', [u''])[0] comment = wikiutil.clean_input(comment) self.page = PageEditor(self.request, self.pagename) success, msgs = self.page.renamePage(newpagename, comment) rename_subpages = 0 if 'rename_subpages' in form: try: rename_subpages = int(form['rename_subpages'][0]) except: pass if rename_subpages and self.subpages: for name in self.subpages: self.page = PageEditor(self.request, name) new_subpagename = name.replace(self.pagename, newpagename, 1) success_i, msg = self.page.renamePage(new_subpagename, comment) msgs = "%s %s" % (msgs, msg) self.newpagename = newpagename # keep there for finish return success, msgs
def execute(pagename, request): request.headers["Content-Type"] = "text/plain; charset=ascii" if request.environ['REQUEST_METHOD'] != 'POST': return form = values_to_form(request.values) content = form.get('content', [None])[0] if not content: sendfault(request, "Missing page content") return pagename = normalize_pagename(pagename, request.cfg) if not pagename: sendfault(request, "No page name entered") return if not request.user.may.write(pagename): sendfault(request, "You are not allowed to edit this page") return page = PageEditor(request, pagename) if page.exists(): sendfault(request, "Page already exists.") return msg = "" try: msg = page.saveText(content, 0) except page.SaveError, msg: sendfault(request, "Failed to save page: %s" % pagename) return
def do_addattachment(self, zipname, filename, pagename, author=u"Scripting Subsystem", comment=u""): """ Installs an attachment @param pagename: Page where the file is attached. Or in 2.0, the file itself. @param zipname: Filename of the attachment from the zip file @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0) """ if self.request.user.may.write(pagename): _ = self.request.getText attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1) filename = wikiutil.taintfilename(filename) zipname = wikiutil.taintfilename(zipname) target = os.path.join(attachments, filename) page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author) rev = page.current_rev() path = page.getPagePath(check_create=0) if not os.path.exists(target): self._extractToFile(zipname, target) if os.path.exists(target): os.chmod(target, config.umask ) action = 'ATTNEW' edit_logfile_append(self, pagename, path, rev, action, logname='edit-log', comment=u'%(filename)s' % {"filename": filename}, author=author) self.msg += u"%(filename)s attached \n" % {"filename": filename} else: self.msg += u"%(filename)s not attached \n" % {"filename": filename} else: self.msg += u"action add attachment: not enough rights - nothing done \n"
def do_action(self): """ Delete pagename """ form = self.form comment = form.get('comment', [u''])[0] comment = wikiutil.clean_input(comment) # Create a page editor that does not do editor backups, because # delete generates a "deleted" version of the page. self.page = PageEditor(self.request, self.pagename, do_editor_backup=0) success, msgs = self.page.deletePage(comment) delete_subpages = 0 if 'delete_subpages' in form: try: delete_subpages = int(form['delete_subpages'][0]) except: pass if delete_subpages and self.subpages: for name in self.subpages: self.page = PageEditor(self.request, name, do_editor_backup=0) success_i, msg = self.page.deletePage(comment) msgs = "%s %s" % (msgs, msg) return success, msgs
def do_delattachment(self, filename, pagename, author=u"Scripting Subsystem", comment=u""): """ Removes an attachment @param pagename: Page where the file is attached. Or in 2.0, the file itself. @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0) """ if self.request.user.may.write(pagename): _ = self.request.getText attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1) filename = wikiutil.taintfilename(filename) target = os.path.join(attachments, filename) page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author) rev = page.current_rev() path = page.getPagePath(check_create=0) if os.path.exists(target): os.remove(target) action = 'ATTDEL' edit_logfile_append(self, pagename, path, rev, action, logname='edit-log', comment=u'%(filename)s' % {"filename": filename}, author=author) self.msg += u"%(filename)s removed \n" % {"filename": filename} else: self.msg += u"%(filename)s does not exist \n" % {"filename": filename} else: self.msg += u"action delete attachment: not enough rights - nothing done \n"
def do_action(self): """ Load """ status = False _ = self._ form = self.form request = self.request comment = form.get('comment', [u''])[0] comment = wikiutil.clean_input(comment) filename = form.get('file__filename__') rename = form.get('rename', [''])[0].strip() if rename: target = rename else: target = filename target = AttachFile.preprocess_filename(target) target = wikiutil.clean_input(target) if target: filecontent = form['file'][0] if hasattr(filecontent, 'read'): # a file-like object filecontent = filecontent.read() # XXX reads complete file into memory! filecontent = wikiutil.decodeUnknownInput(filecontent) self.pagename = target pg = PageEditor(request, self.pagename) try: msg = pg.saveText(filecontent, 0, comment=comment) status = True except pg.EditConflict, e: msg = e.message except pg.SaveError, msg: msg = unicode(msg)
def xmlrpc_renamePage(self, pagename, newpagename): """ Renames a page <pagename> to <newpagename>. @param pagename: the page name (unicode or utf-8) @param newpagename: the new pagename (unicode or utf-8) @rtype: bool @return: True on success """ pagename = self._instr(pagename) pagename = wikiutil.normalize_pagename(pagename, self.cfg) if not pagename: return xmlrpclib.Fault("INVALID", "pagename can't be empty") # check ACLs if not (self.request.user.may.delete(pagename) and self.request.user.may.write(newpagename)): return xmlrpclib.Fault(1, "You are not allowed to rename this page") editor = PageEditor(self.request, pagename, do_editor_backup=0) try: editor.renamePage(newpagename) except PageEditor.SaveError, error: return xmlrpclib.Fault(1, "Rename failed: %s" % (str(error), ))
def group_del(request, grouppage, accounts): _ = request.getText success, msg = check_grouppage(request, grouppage) if not success: raise GroupException(msg + "(%s)" % (grouppage)) members = request.groups[grouppage].members | request.groups[ grouppage].member_groups for name in accounts: if name not in members: raise GroupException(name + _(' not in group: ') + grouppage) page = PageEditor(request, grouppage) pagetext = page.get_raw_body() newtext = _group_del(request, pagetext, accounts) msg = page.saveText(newtext, 0, comment="Deleted from group: " + ', '.join(accounts)) newmembers = request.groups[grouppage].members | request.groups[ grouppage].member_groups if not newmembers == members - set(accounts): msg = page.saveText( pagetext, 0, comment="Reverting due to problems in group operation.") raise GroupException(_('Delete unsuccessful for unknown reasons.')) return True, msg
def do_addrevision(self, filename, pagename, author=u"Scripting Subsystem", comment=u"", trivial=u"No"): """ Adds a revision to a page. @param filename: name of the file in this package @param pagename: name of the target page @param author: user name of the editor (optional) @param comment: comment related to this revision (optional) @param trivial: boolean, if it is a trivial edit """ _ = self.request.getText trivial = str2boolean(trivial) if self.request.user.may.write(pagename): page = PageEditor(self.request, pagename, do_editor_backup=0) try: page.saveText(self.extract_file(filename).decode("utf-8"), 0, trivial=trivial, comment=comment) except PageEditor.Unchanged: pass else: self.msg += u"%(pagename)s added \n" % {"pagename": pagename} else: self.msg += u"action add revision: not enough rights - nothing done \n"
def test_acls(self): p = PageEditor(self.request, self.pagename) oldacl = p.getACL(self.request).acl assert not self.request.user.may.admin(p.page_name) newacl = parseACL(self.request, self.newtext).acl assert newacl != oldacl py.test.raises(PageEditor.NoAdmin, p.saveText, self.newtext, 0)
def nuke_page(request, pagename): """ completely delete a page, everything in the pagedir """ page = PageEditor(request, pagename, do_editor_backup=False) page.deletePage() # really get rid of everything there: fpath = page.getPagePath(check_create=0) shutil.rmtree(fpath, True)
def deletecomment(macro, delkey, delpasswd): # Deletes a comment with given index and password request = Globs.macro.request formatter = Globs.macro.formatter datapagename = Globs.datapagename _ = request.getText if Params.encryptpass: from MoinMoin import user delpasswd = user.encodePassword(delpasswd) pg = PageEditor( request, datapagename ) pagetext = pg.get_raw_body() regex = ur""" (?P<comblock> ^[\{]{3}\n ^(?P<icon>[^\n]*)\n ^(?P<name>[^\n]*)\n ^(?P<date>[^\n]*)[\n]+ ^(?P<text> \s*.*? (?=[\}]{3}) )[\}]{3}[\n]* ^[#]{2}PASSWORD[ ](?P<passwd>[^\n]*)[\n]* ^[#]{2}LOGINUSER[ ](?P<loginuser>[^\n]*)[\n$]* )""" pattern = re.compile(regex, re.UNICODE + re.MULTILINE + re.VERBOSE + re.DOTALL) commentitems = pattern.findall(pagetext) for item in commentitems: if delkey == item[3].strip(): comauthor = item[2] if Globs.admin or (request.user.valid and request.user.name == comauthor) or delpasswd == item[5]: newpagetext = pagetext.replace(item[0], '', 1) action = 'SAVE' comment = 'Deleted comment by "%s"' % comauthor trivial = 1 pg._write_file(newpagetext, action, u'PageComment modification at %s' % Globs.curpagename) addLogEntry(request, 'COMDEL', Globs.curpagename, comment) msg = _('The comment is deleted.') # send notification mails if Params.notify: msg = msg + commentNotify(comment, trivial) message(msg) return else: message(_('Sorry, wrong password.')) return message(_('No such comment'))
def create_page(request, pagename, content, do_editor_backup=False): """ create a page with some content """ # make sure there is nothing already there: nuke_page(request, pagename) # now create from scratch: page = PageEditor(request, pagename, do_editor_backup=do_editor_backup) page.saveText(content, 0) return page
def savetext(request, pagename, newtext, **kw): page = PageEditor(request, pagename) try: msg = page.saveText(newtext, 0, **kw) except page.Unchanged: msg = u'Unchanged' return msg
def ownPutPage(request, pagename, pagetext): if not request.user.may.write(pagename): return False page = PageEditor(request, pagename) try: msg = page.saveText(pagetext, 0) except page.SaveError, msg: pass
def append_page(request, pagename, content, do_editor_backup=False): """ appends some conetent to an existing page """ # reads the raw text of the existing page raw = Page(request, pagename).get_raw_body() # adds the new content to the old content = "%s\n%s\n" % (raw, content) page = PageEditor(request, pagename, do_editor_backup=do_editor_backup) page.saveText(content, 0) return page
def append_page(request, pagename, content, do_editor_backup=False): """ appends some conetent to an existing page """ # reads the raw text of the existing page raw = Page(request, pagename).get_raw_body() # adds the new content to the old content = "%s\n%s\n"% (raw, content) page = PageEditor(request, pagename, do_editor_backup=do_editor_backup) page.saveText(content, 0) return page
def nuke_page(request, pagename): """ completely delete a page, everything in the pagedir """ attachments = AttachFile._get_files(request, pagename) for attachment in attachments: AttachFile.remove_attachment(request, pagename, attachment) page = PageEditor(request, pagename, do_editor_backup=False) page.deletePage() # really get rid of everything there: fpath = page.getPagePath(check_create=0) shutil.rmtree(fpath, True)
def test_page_change_message(request): page = PageEditor(request, "FrontPage") print "Provided with a dumb change type argument, this should raise an exception!" py.test.raises(notification.UnknownChangeType, notification.page_change_message, "StupidType", request, page, "en", revisions=page.getRevList())
def execute(pagename, request): """ Handle action=IntraFarmCopy """ if not request.user.may.read(pagename): Page(request, pagename).send_page() return # Which local farm wiki - assume team for now to_wiki_url = COPY_TO_WIKI_URL # New page name to_wiki_pagename = '%s%s' % (COPY_TO_PREFIX, pagename) # create page at local wiki if it doesn't exist to_request = ScriptContext(to_wiki_url) # login this user remotely to_uid = user.getUserId(to_request, request.user.name) to_user = user.User(to_request, id=to_uid, name=request.user.name, password=request.user.password, auth_method="moin") to_request.user = to_user try: page = Page(to_request, to_wiki_pagename) except: return action_error(u'Error accessing destination page') if not page.exists(): pe = PageEditor(to_request, to_wiki_pagename) # make initial revision pointer to original try: pe.saveText(u'[[%s:%s]]' % (request.cfg.interwikiname, pagename), 0, comment="Automated IntraFarmCopy pointing to original page") except pe.Unchanged: return action_error(u'Could not save initial page') except pe.AccessDenied: return action_error(u'Could not acquire credentials') # make next revision content of this page try: pe.saveText(Page(request, pagename).get_raw_body(), 0, comment="Automated IntraFarmCopy importing contents from original page at [[%s:%s]]" % (request.cfg.interwikiname, pagename)) except pe.Unchanged: return action_error(u'Could not save destination page text') # send attachments over attachments = AttachFile._get_files(request, pagename) for attachname in attachments: filename = AttachFile.getFilename(request, pagename, attachname) if not os.path.isfile(filename): continue to_filename = AttachFile.getFilename(to_request, to_wiki_pagename, attachname) shutil.copyfile(filename, to_filename) AttachFile._addLogEntry(to_request, 'ATTNEW', to_wiki_pagename, attachname) # redirect user to view new page in other wiki request.http_redirect('%s%s' % (to_wiki_url, to_wiki_pagename)) return else: return action_error(u'Destination page already exists!')
def execute(pagename, request): _ = request.getText actname = __name__.split('.')[-1] # Create a page editor that does not do edior backups, becuase # delete generate "deleted" version, of the page. page = PageEditor(request, pagename, do_editor_backup=0) # be extra paranoid in dangerous actions if actname in request.cfg.excluded_actions \ or not request.user.may.write(pagename) \ or not request.user.may.delete(pagename): return page.send_page(request, msg = _('You are not allowed to delete this page.')) # check whether page exists at all if not page.exists(): return page.send_page(request, msg = _('This page is already deleted or was never created!')) # check whether the user clicked the delete button if request.form.has_key('button') and request.form.has_key('ticket'): # check whether this is a valid deletion request (make outside # attacks harder by requiring two full HTTP transactions) if not wikiutil.checkTicket(request.form['ticket'][0]): return page.send_page(request, msg = _('Please use the interactive user interface to delete pages!')) # Delete the page page.deletePage(request.form.get('comment', [u''])[0]) return page.send_page(request, msg = _('Page "%s" was successfully deleted!') % (pagename,)) # send deletion form ticket = wikiutil.createTicket() querytext = _('Really delete this page?') button = _('Delete') comment_label = _("Optional reason for the deletion") # TODO: this form suck, redesign like RenamePage formhtml = ''' <form method="post" action=""> <strong>%(querytext)s</strong> <input type="hidden" name="action" value="%(actname)s"> <input type="hidden" name="ticket" value="%(ticket)s"> <input type="submit" name="button" value="%(button)s"> <p> %(comment_label)s<br> <input type="text" name="comment" size="60" maxlength="80"> </form>''' % { 'querytext': querytext, 'actname': actname, 'ticket': ticket, 'button': button, 'comment_label': comment_label, } return page.send_page(request, msg=formhtml)
def save_page(self, output): editor = PageEditor(self.macro.request, self.pagename) text = self.create_header() text += editor.normalizeText(output) dummy, revision, exists = editor.get_rev() try: res = editor.saveText(text, revision, comment="updated by MakeList macro.") return res except editor.Unchanged: return "You did not change the page content, not saved!" except: return "An error occured!"
def do_deletepage(self, pagename, comment="Deleted by the scripting subsystem."): """ Marks a page as deleted (like the DeletePage action). @param pagename: page to delete @param comment: the related comment (optional) """ _ = self.request.getText page = PageEditor(self.request, pagename, do_editor_backup=0) if not page.exists(): raise RuntimeScriptException(_("The page %s does not exist.") % pagename) page.deletePage(comment)
def write_homepage(self, account, homepage_text): # writes the homepage if account.exists() and not account.disabled and not Page(self.request, account.name).exists(): userhomepage = PageEditor(self.request, account.name) try: userhomepage.saveText(homepage_text, 0) print "INFO homepage for %s created." % account.name except userhomepage.Unchanged: print "You did not change the page content, not saved!" except userhomepage.NoAdmin: print "You don't have enough rights to create the %s page" % account.name else: print "INFO homepage for %s already exists or account is disabled or user does not exist." % account.name
def do_addattachment(self, zipname, filename, pagename, author=u"Scripting Subsystem", comment=u""): """ Installs an attachment @param pagename: Page where the file is attached. Or in 2.0, the file itself. @param zipname: Filename of the attachment from the zip file @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0) """ if self.request.user.may.write(pagename): _ = self.request.getText attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1) filename = wikiutil.taintfilename(filename) zipname = wikiutil.taintfilename(zipname) target = os.path.join(attachments, filename) page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author) rev = page.current_rev() path = page.getPagePath(check_create=0) if not os.path.exists(target): self._extractToFile(zipname, target) if os.path.exists(target): filesys.chmod(target, 0666 & config.umask) action = 'ATTNEW' edit_logfile_append(self, pagename, path, rev, action, logname='edit-log', comment=u'%(filename)s' % {"filename": filename}, author=author) self.msg += u"%(filename)s attached \n" % { "filename": filename } else: self.msg += u"%(filename)s not attached \n" % { "filename": filename } else: self.msg += u"action add attachment: not enough rights - nothing done \n"
def force_revert(self, pagename, request): rev = int(request.form['rev'][0]) revstr = '%08d' % rev oldpg = Page(request, pagename, rev=rev) pg = PageEditor(request, pagename) _ = request.getText msg = _("Thank you for your changes. Your attention to detail is appreciated.") try: pg._write_file(oldpg.get_raw_body(), action="SAVE/REVERT", extra=revstr) pg.clean_acl_cache() except pg.SaveError, msg: pass
def rollback_local_change(): # YYY direct local access comment = u"Wikisync rollback" rev = new_local_rev - 1 revstr = '%08d' % rev oldpg = Page(self.request, sp.local_name, rev=rev) pg = PageEditor(self.request, sp.local_name) if not oldpg.exists(): pg.deletePage(comment) else: try: savemsg = pg.saveText(oldpg.get_raw_body(), 0, comment=comment, extra=revstr, action="SAVE/REVERT") except PageEditor.Unchanged: pass return sp.local_name
def test_update_needed(self): """ test update check) """ test_data1 = u'does not matter' test_data2 = u'something else' page_name = u'Caching_TestPage' page = PageEditor(self.request, page_name) page._write_file(test_data1) cache = caching.CacheEntry(self.request, page, 'test_key', 'item') cache.update(test_data1) assert not cache.needsUpdate(page._text_filename()) time.sleep(3) # XXX fails without, due to mtime granularity page = PageEditor(self.request, page_name) page._write_file(test_data2) assert cache.needsUpdate(page._text_filename())
def do_deletepage(self, pagename, comment="Deleted by the scripting subsystem."): """ Marks a page as deleted (like the DeletePage action). @param pagename: page to delete @param comment: the related comment (optional) """ if self.request.user.may.write(pagename): _ = self.request.getText page = PageEditor(self.request, pagename, do_editor_backup=0) if not page.exists(): raise RuntimeScriptException(_("The page %s does not exist.") % pagename) page.deletePage(comment) else: self.msg += u"action delete page: not enough rights - nothing done \n"
def execute(self, groupname, groupcomment, memberlist, pageacls=u"All:read"): """ create or overwrite a group definition page @param groupname: the page name of the group definition page (unicode or utf-8) must match the page_group_regex or it won't have effect @param memberlist: the group members (unicode or utf-8) @param pageacls: the ACLs to use for the group page (defaults to u"All:read") @rtype: bool @return: true on success """ if self.request.cfg.xmlrpc_putpage_enabled: pagename = self._instr(groupname) else: pagename = u"TestUpdateGroup" # By default, only authenticated (trusted) users may use putPage! # Trusted currently means being authenticated by http auth. # if you also want untrusted users to be able to write pages, then # change your wikiconfig to have xmlrpc_putpage_trusted_only = 0 # and make very very sure that nobody untrusted can access your wiki # via network or somebody will raid your wiki some day! if self.request.cfg.xmlrpc_putpage_trusted_only and not self.request.user.trusted: return xmlrpclib.Fault(1, "You are not allowed to edit this page") # also check ACLs if not self.request.user.may.write(pagename): return xmlrpclib.Fault(1, "You are not allowed to edit this page") # check if groupname matches page_group_regex if not re.match(self.request.cfg.page_group_regex, groupname): return xmlrpclib.Fault(2, "The groupname %s does not match your page_group_regex (%s)" % ( groupname, self.request.cfg.page_group_regex)) newtext = """\ #acl %(acl)s %(comment)s %(memberlist)s """ % { 'acl': pageacls, 'comment': groupcomment, 'memberlist': "\n * ".join([''] + memberlist) } page = PageEditor(self.request, pagename) try: msg = page.saveText(newtext, 0) except page.SaveError, msg: return xmlrpclib.Fault(3, msg)
def testCreateDictAndDeleteDictPage(self): """ simple test if it is possible to delete a Dict page after creation """ become_trusted(self.request) pagename = u'SomeDict' page = PageEditor(self.request, pagename, do_editor_backup=0) body = u"This is an example text" page.saveText(body, 0) success_i, result = page.deletePage() expected = u'Page "SomeDict" was successfully deleted!' assert result == expected
def edit_meta(request, pagename, oldmeta, newmeta): page = PageEditor(request, pagename) text = page.get_raw_body() text = replace_metas(request, text, oldmeta, newmeta) # PageEditor.saveText doesn't allow empty texts if not text: text = u" " try: msg = page.saveText(text, 0) except page.Unchanged: msg = u'Unchanged' return msg
def delete(request, pagename, comment = None): _ = request.getText # check ACLs if not request.user.may.delete(pagename): return xmlrpclib.Fault(1, _("You are not allowed to delete this page")) # Deletes pages page = PageEditor(request, pagename, do_editor_backup=0) if not page.exists(): return xmlrpclib.Fault(1, _('No such page %s' % pagename)) page.deletePage(comment) return True
def do_deletepage(self, pagename, comment="Deleted by the scripting subsystem."): """ Marks a page as deleted (like the DeletePage action). @param pagename: page to delete @param comment: the related comment (optional) """ if self.request.user.may.write(pagename): _ = self.request.getText page = PageEditor(self.request, pagename, do_editor_backup=0) if not page.exists(): raise RuntimeScriptException( _("The page %s does not exist.") % pagename) page.deletePage(comment) else: self.msg += u"action delete page: not enough rights - nothing done \n"
def test_copy_page(self): """ Tests copying a page without restricted acls """ self.createTestPage() result, msg = PageEditor(self.request, self.pagename).copyPage(self.copy_pagename) revision = Page(self.request, self.copy_pagename).current_rev() assert result and revision is 2
def create_default_wikibase_page(self): pagecontent = """\ == Mendeley2Moin overview == || Run plugin || [[/|Mendeley2Moin|&action=Mendeley2Moin]] || || Edit Config || [[/Config]] || || Edit Template || [[/Template]] || || Review installation steps || [[/Log]] || """ return(PageEditor(self.request, _wiki_base).saveText(pagecontent, 0))
def do_action(self): """ revert pagename """ form = self.form comment = form.get('comment', u'') comment = wikiutil.clean_input(comment) if self.request.method != 'POST': return False, u'' rev = self.request.rev pg = PageEditor(self.request, self.pagename) try: msg = pg.revertPage(rev, comment) # make it show the current version... self.request.rev = None except PageEditor.SaveError, error: msg = unicode(error)
def _addLocalWords(request): from MoinMoin.PageEditor import PageEditor # get the new words as a string (if any are marked at all) try: newwords = request.form.getlist('newwords') except KeyError: # no new words checked return newwords = u' '.join(newwords) # get the page contents lsw_page = PageEditor(request, request.cfg.page_local_spelling_words) words = lsw_page.get_raw_body() # add the words to the page and save it if words and words[-1] != '\n': words = words + '\n' lsw_page.saveText(words + '\n' + newwords, 0)
def do_delattachment(self, filename, pagename, author=u"Scripting Subsystem", comment=u""): """ Removes an attachment @param pagename: Page where the file is attached. Or in 2.0, the file itself. @param filename: Filename of the attachment (just applicable for MoinMoin < 2.0) """ if self.request.user.may.write(pagename): _ = self.request.getText attachments = Page(self.request, pagename).getPagePath("attachments", check_create=1) filename = wikiutil.taintfilename(filename) target = os.path.join(attachments, filename) page = PageEditor(self.request, pagename, do_editor_backup=0, uid_override=author) rev = page.current_rev() path = page.getPagePath(check_create=0) if os.path.exists(target): os.remove(target) action = 'ATTDEL' edit_logfile_append(self, pagename, path, rev, action, logname='edit-log', comment=u'%(filename)s' % {"filename": filename}, author=author) self.msg += u"%(filename)s removed \n" % {"filename": filename} else: self.msg += u"%(filename)s does not exist \n" % { "filename": filename } else: self.msg += u"action delete attachment: not enough rights - nothing done \n"
def create_default_wikilog_page(self): pagecontent = """\ == Configuration steps on first run == On the first run you need to add your Mendeley consumer key and secret key to the config. TODO: Explain Mendeley OAuth Go to [[http://dev.mendeley.com/applications/register/]] and register the application to get the consumer and secret key. Please edit [[Mendeley2Moin/Config]] and add consumer and secret key. Then as next step click on [[/|Mendeley2Moin|&action=Mendeley2Moin]] to get the link to verify OAuth. """ return(PageEditor(self.request, _wiki_base+'/Log').saveText(pagecontent, 0))
def xmlrpc_mergeDiff(self, pagename, diff, local_rev, delta_remote_rev, last_remote_rev, interwiki_name, normalised_name): """ Merges a diff sent by the remote machine and returns the number of the new revision. Additionally, this method tags the new revision. @param pagename: The pagename that is currently dealt with. @param diff: The diff that can be applied to the version specified by delta_remote_rev. If it is None, the page is deleted. @param local_rev: The revno of the page on the other wiki system, used for the tag. @param delta_remote_rev: The revno that the diff is taken against. @param last_remote_rev: The last revno of the page `pagename` that is known by the other wiki site. @param interwiki_name: Used to build the interwiki tag. @param normalised_name: The normalised pagename that is common to both wikis. @return: Returns the current revision number after the merge was done. Or one of the following errors: * "SUCCESS" - the page could be merged and tagged successfully. * "NOT_EXIST" - item does not exist and there was not any content supplied. * "LASTREV_INVALID" - the page was changed and the revision got invalid * "INTERNAL_ERROR" - there was an internal error * "NOT_ALLOWED" - you are not allowed to do the merge operation on the page """ from MoinMoin.util.bdiff import decompress, patch from MoinMoin.wikisync import TagStore, BOTH from MoinMoin.packages import unpackLine LASTREV_INVALID = xmlrpclib.Fault("LASTREV_INVALID", "The page was changed") pagename = self._instr(pagename) comment = u"Remote Merge - %r" % unpackLine(interwiki_name)[-1] # User may read page? if not self.request.user.may.read( pagename) or not self.request.user.may.write(pagename): return xmlrpclib.Fault( "NOT_ALLOWED", "You are not allowed to write to this page.") # XXX add locking here! # current version of the page currentpage = PageEditor(self.request, pagename, do_editor_backup=0) if last_remote_rev is not None and currentpage.get_real_rev( ) != last_remote_rev: return LASTREV_INVALID if not currentpage.exists() and diff is None: return xmlrpclib.Fault( "NOT_EXIST", "The page does not exist and no diff was supplied.") if diff is None: # delete the page try: currentpage.deletePage(comment) except PageEditor.AccessDenied, (msg, ): return xmlrpclib.Fault("NOT_ALLOWED", msg) return currentpage.get_real_rev()
def test_copy_page_acl_no_read(self): """ Tests copying a page without read rights """ self.text = u'#acl SomeUser:read,write,delete All:\n' self.createTestPage() result, msg = PageEditor(self.request, self.pagename).copyPage(self.copy_pagename) revision = Page(self.request, self.copy_pagename).current_rev() assert result and revision is 2