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 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 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 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_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):
""" 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 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_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 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_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 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 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 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 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 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 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
