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
#
