def execute(pagename, request):
_ = request.getText
from MoinMoin.formatter.text_html import Formatter
request.formatter = Formatter(request)
try:
request.emit_http_headers()
except AttributeError:
try:
request.http_headers()
except AttributeError:
pass
# This action generate data using the user language
request.setContentLanguage(request.lang)
try:
send_title = request.theme.send_title
send_title(_('Actions for %s') % pagename, page_name=pagename)
except AttributeError:
wikiutil.send_title(request, _('Actions for %s') % pagename, pagename=pagename)
# Start content - IMPORTANT - without content div, there is no
# direction support!
request.write(request.formatter.startContent("content"))
# Just list the actions
request.write(availableactions(request))
# End content and send footer
request.write(request.formatter.endContent())
try:
request.theme.send_footer(pagename)
except AttributeError:
wikiutil.send_footer(request, pagename)
def upload_form(pagename, request, msg=''):
_ = request.getText
request.http_headers()
# Use user interface language for this generated page
request.setContentLanguage(request.lang)
wikiutil.send_title(request, _('Attachments for "%(pagename)s"') % {'pagename': pagename}, pagename=pagename, msg=msg)
request.write('<div id="content">\n') # start content div
send_uploadform(pagename, request)
request.write('</div>\n') # end content div
wikiutil.send_footer(request, pagename)
def show_result(pagename, request):
_ = request.getText
request.http_headers()
wikiutil.send_title(request, _("Subscribed for %s:") % pagename, pagename=pagename)
from MoinMoin.formatter.text_html import Formatter
formatter = Formatter(request)
result = subscribe_users(request, request.form['users'][0].split(","), pagename, formatter)
request.write(result)
wikiutil.send_footer(request, pagename)
def show_form(pagename, request):
_ = request.getText
request.http_headers()
wikiutil.send_title(request, _("Subscribe users to the page %s") % pagename, pagename=pagename)
request.write("""
<form action="" method="POST" enctype="multipart/form-data">
<input type="hidden" name="action" value="SubscribeUser">
Enter user names (comma separated): <input type="text" name="users" size="50">
<input type="submit" value="Subscribe">
</form>
""")
wikiutil.send_footer(request, pagename)
def execute_wiki(pagename, request):
request.http_headers()
wikiutil.send_title(request, "Thread monitor")
request.write('<pre>')
if not thread_monitor.hook_enabled:
request.write("Hook is not enabled.")
else:
s = StringIO()
thread_monitor.trigger_dump(s)
time.sleep(5) # allow for all threads to dump to request
request.write(wikiutil.escape(s.getvalue()))
request.write('</pre>')
wikiutil.send_footer(request, pagename)
def sendBackupForm(request, pagename):
_ = request.getText
request.http_headers()
request.setContentLanguage(request.lang)
title = _('Wiki Backup / Restore')
wikiutil.send_title(request, title, form=request.form, pagename=pagename)
request.write(request.formatter.startContent("content"))
request.write(_("""Some hints:
* To restore a backup:
* Restoring a backup will overwrite existing data, so be careful.
* Rename it to <siteid>.tar.<compression> (remove the --date--time--UTC stuff).
* Put the backup file into the backup_storage_dir (use scp, ftp, ...).
* Hit the [[GetText(Restore)]] button below.
* To make a backup, just hit the [[GetText(Backup)]] button and save the file
you get to a secure place.
Please make sure your wiki configuration backup_* values are correct and complete.
"""))
request.write("""
<form action="%(baseurl)s/%(pagename)s" method="POST" enctype="multipart/form-data">
<input type="hidden" name="action" value="backup">
<input type="hidden" name="do" value="backup">
<input type="submit" value="%(backup_button)s">
</form>
<form action="%(baseurl)s/%(pagename)s" method="POST" enctype="multipart/form-data">
<input type="hidden" name="action" value="backup">
<input type="hidden" name="do" value="restore">
<input type="submit" value="%(restore_button)s">
</form>
""" % {
'baseurl': request.getScriptname(),
'pagename': wikiutil.quoteWikinameURL(pagename),
'backup_button': _('Backup'),
'restore_button': _('Restore'),
})
request.write(request.formatter.endContent())
wikiutil.send_footer(request, pagename)
def execute(pagename, request):
_ = request.getText
form = request.form
# get the MIME type
if form.has_key('mimetype'):
mimetype = form['mimetype'][0]
else:
mimetype = "text/html"
request.http_headers(["Content-Type: %s; charset=%s" % (mimetype,config.charset)])
if mimetype == "text/html":
wikiutil.send_title(request,
_('Full Link List for "%s"') % request.cfg.sitename)
request.write('<pre>')
# Get page dict readable by current user
pages = request.rootpage.getPageDict()
pagelist = pages.keys()
pagelist.sort()
for name in pagelist:
if mimetype == "text/html":
request.write(pages[name].link_to(request))
else:
_emit(request, name)
for link in pages[name].getPageLinks(request):
request.write(" ")
if mimetype == "text/html":
if pages.has_key(link):
request.write(pages[link].link_to(request))
else:
_emit(request, link)
else:
_emit(request, link)
request.write('\n')
if mimetype == "text/html":
request.write('</pre>')
wikiutil.send_footer(request, pagename, editable=0, showactions=0, form=form)
else:
raise MoinMoinNoFooter
def execute(pagename, request):
_ = request.getText
from MoinMoin.formatter.text_html import Formatter
request.formatter = Formatter(request)
start, end, matches = findMatches(pagename, request)
# Error?
if isinstance(matches, (str, unicode)):
Page(request, pagename).send_page(request, msg=matches)
return
# No matches
if not matches:
Page(request, pagename).send_page(request,
msg = _('No pages like "%s"!') % (pagename,))
return
# One match - display it
if len(matches) == 1:
Page(request, matches.keys()[0]).send_page(request,
msg = _('Exactly one page like "%s" found, redirecting to page.') % (
pagename,))
return
# more than one match, list 'em
request.http_headers()
# This action generate data using the user language
request.setContentLanguage(request.lang)
wikiutil.send_title(request, _('Pages like "%s"') % (pagename),
pagename=pagename)
# Start content - IMPORTANT - without content div, there is no
# direction support!
request.write(request.formatter.startContent("content"))
showMatches(pagename, request, start, end, matches)
# End content and send footer
request.write(request.formatter.endContent())
wikiutil.send_footer(request, pagename)
def execute(pagename, request):
_ = request.getText
request.http_headers()
# This action generate data using the user language
request.setContentLanguage(request.lang)
wikiutil.send_title(request, _('Local Site Map for "%s"') % (pagename),
pagename=pagename)
# Start content - IMPORTANT - witout content div, there is no
# direction support!
formatter = Formatter(request)
request.write(formatter.startContent("content"))
request.write(LocalSiteMap(pagename).output(request))
# End content
request.write(formatter.endContent()) # end content div
# Footer
wikiutil.send_footer(request, pagename)
def view_file(pagename, request):
_ = request.getText
filename, fpath = _access_file(pagename, request)
if not filename: return
# send header & title
request.http_headers()
# Use user interface language for this generated page
request.setContentLanguage(request.lang)
title = _('attachment:%(filename)s of %(pagename)s', formatted=True) % {
'filename': filename, 'pagename': pagename}
wikiutil.send_title(request, title, pagename=pagename)
# send body
# TODO: use formatter startContent?
request.write('<div id="content">\n') # start content div
send_viewfile(pagename, request)
send_uploadform(pagename, request)
request.write('</div>\n') # end content div
# send footer
wikiutil.send_footer(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 sendEditor(self, **kw):
"""
Send the editor form page.
@keyword preview: if given, show this text in preview mode
@keyword staytop: don't go to #preview
@keyword comment: comment field (when preview is true)
"""
from MoinMoin import i18n
try:
from MoinMoin.action import SpellCheck
except ImportError:
SpellCheck = None
request = self.request
form = self.request.form
_ = self._
self.request.disableHttpCaching(level=2)
self.request.http_headers()
raw_body = ''
msg = None
conflict_msg = None
edit_lock_message = None
preview = kw.get('preview', None)
staytop = kw.get('staytop', 0)
# check edit permissions
if not self.request.user.may.write(self.page_name):
msg = _('You are not allowed to edit this page.')
elif not self.isWritable():
msg = _('Page is immutable!')
elif self.rev:
# Trying to edit an old version, this is not possible via
# the web interface, but catch it just in case...
msg = _('Cannot edit old revisions!')
else:
# try to acquire edit lock
ok, edit_lock_message = self.lock.acquire()
if not ok:
# failed to get the lock
if preview is not None:
edit_lock_message = _('The lock you held timed out. Be prepared for editing conflicts!'
) + "<br>" + edit_lock_message
else:
msg = edit_lock_message
# Did one of the prechecks fail?
if msg:
self.send_page(self.request, msg=msg)
return
# Check for preview submit
if preview is None:
title = _('Edit "%(pagename)s"')
else:
title = _('Preview of "%(pagename)s"')
self.set_raw_body(preview, modified=1)
# send header stuff
lock_timeout = self.lock.timeout / 60
lock_page = wikiutil.escape(self.page_name, quote=1)
lock_expire = _("Your edit lock on %(lock_page)s has expired!") % {'lock_page': lock_page}
lock_mins = _("Your edit lock on %(lock_page)s will expire in # minutes.") % {'lock_page': lock_page}
lock_secs = _("Your edit lock on %(lock_page)s will expire in # seconds.") % {'lock_page': lock_page}
# get request parameters
try:
text_rows = int(form['rows'][0])
except StandardError:
text_rows = self.cfg.edit_rows
if self.request.user.valid:
text_rows = int(self.request.user.edit_rows)
if preview is not None:
# Propagate original revision
rev = int(form['rev'][0])
# Check for editing conflicts
if not self.exists():
# page does not exist, are we creating it?
if rev:
conflict_msg = _('Someone else deleted this page while you were editing!')
elif rev != self.current_rev():
conflict_msg = _('Someone else changed this page while you were editing!')
if self.mergeEditConflict(rev):
conflict_msg = _("""Someone else saved this page while you were editing!
Please review the page and save then. Do not save this page as it is!
Have a look at the diff of %(difflink)s to see what has been changed.""") % {
'difflink': self.link_to(self.request,
querystr='action=diff&rev=%d' % rev)
}
rev = self.current_rev()
if conflict_msg:
# We don't show preview when in conflict
preview = None
elif self.exists():
# revision of existing page
rev = self.current_rev()
else:
# page creation
rev = 0
# Page editing is done using user language
self.request.setContentLanguage(self.request.lang)
# Setup status message
status = [kw.get('msg', ''), conflict_msg, edit_lock_message]
status = [msg for msg in status if msg]
status = ' '.join(status)
status = Status(self.request, content=status)
wikiutil.send_title(self.request,
title % {'pagename': self.split_title(self.request),},
page=self,
pagename=self.page_name, msg=status,
html_head=self.lock.locktype and (
PageEditor._countdown_js % {
'countdown_script': self.request.theme.externalScript('countdown'),
'lock_timeout': lock_timeout,
'lock_expire': lock_expire,
'lock_mins': lock_mins,
'lock_secs': lock_secs,
}) or '',
editor_mode=1,
)
self.request.write(self.request.formatter.startContent("content"))
# Get the text body for the editor field.
# TODO: what about deleted pages? show the text of the last revision or use the template?
if preview is not None:
raw_body = self.get_raw_body()
elif self.exists():
# If the page exists, we get the text from the page.
# TODO: maybe warn if template argument was ignored because the page exists?
raw_body = self.get_raw_body()
elif form.has_key('template'):
# If the page does not exists, we try to get the content from the template parameter.
template_page = wikiutil.unquoteWikiname(form['template'][0])
if self.request.user.may.read(template_page):
raw_body = Page(self.request, template_page).get_raw_body()
if raw_body:
self.request.write(_("[Content of new page loaded from %s]") % (template_page,), '<br>')
else:
self.request.write(_("[Template %s not found]") % (template_page,), '<br>')
else:
self.request.write(_("[You may not read %s]") % (template_page,), '<br>')
# Make backup on previews - but not for new empty pages
if preview and raw_body:
self._make_backup(raw_body)
# Generate default content for new pages
if not raw_body:
raw_body = _('Describe %s here.') % (self.page_name,)
# send form
self.request.write('<form id="editor" method="post" action="%s/%s#preview">' % (
self.request.getScriptname(),
wikiutil.quoteWikinameURL(self.page_name),
))
# yet another weird workaround for broken IE6 (it expands the text
# editor area to the right after you begin to type...). IE sucks...
# http://fplanque.net/2003/Articles/iecsstextarea/
self.request.write('<fieldset style="border:none;padding:0;">')
self.request.write(unicode(html.INPUT(type="hidden", name="action", value="edit")))
# Send revision of the page our edit is based on
self.request.write('<input type="hidden" name="rev" value="%d">' % (rev,))
# Create and send a ticket, so we can check the POST
self.request.write('<input type="hidden" name="ticket" value="%s">' % wikiutil.createTicket(self.request))
# Save backto in a hidden input
backto = form.get('backto', [None])[0]
if backto:
self.request.write(unicode(html.INPUT(type="hidden", name="backto", value=backto)))
# button bar
button_spellcheck = (SpellCheck and
'<input class="button" type="submit" name="button_spellcheck" value="%s">'
% _('Check Spelling')) or ''
save_button_text = _('Save Changes')
cancel_button_text = _('Cancel')
if self.cfg.page_license_enabled:
self.request.write('<p><em>', _(
"""By hitting '''%(save_button_text)s''' you put your changes under the %(license_link)s.
If you don't want that, hit '''%(cancel_button_text)s''' to cancel your changes.""") % {
'save_button_text': save_button_text,
'cancel_button_text': cancel_button_text,
'license_link': wikiutil.getSysPage(self.request, self.cfg.page_license_page).link_to(self.request),
}, '</em></p>')
self.request.write('''
<input class="button" type="submit" name="button_save" value="%s">
<input class="button" type="submit" name="button_preview" value="%s">
<input class="button" type="submit" name="button_switch" value="%s">
%s
<input class="button" type="submit" name="button_cancel" value="%s">
<input type="hidden" name="editor" value="gui">
''' % (save_button_text, _('Preview'), _('Text mode'), button_spellcheck, cancel_button_text,))
self.sendconfirmleaving() # TODO update state of flgChange to make this work, see PageEditor
# Add textarea with page text
# TODO: currently self.language is None at this point. We have
# to do processing instructions parsing earlier, or move page
# language into meta file.
lang = self.language or self.request.cfg.language_default
contentlangdirection = i18n.getDirection(lang) # 'ltr' or 'rtl'
uilanguage = self.request.lang
url_prefix = self.request.cfg.url_prefix
wikipage = wikiutil.quoteWikinameURL(self.page_name)
fckbasepath = url_prefix + '/applets/FCKeditor'
wikiurl = request.getScriptname()
if not wikiurl or wikiurl[-1] != '/':
wikiurl += '/'
themepath = '%s/%s' % (url_prefix, self.request.theme.name)
smileypath = themepath + '/img'
# auto-generating a list for SmileyImages does NOT work from here!
editor_size = int(request.user.edit_rows) * 22 # 22 height_pixels/line
word_rule = self.word_rule()
self.request.write("""
<script type="text/javascript" src="%(fckbasepath)s/fckeditor.js"></script>
<script type="text/javascript">
<!--
var oFCKeditor = new FCKeditor( 'savetext', '100%%', %(editor_size)s, 'MoinDefault' ) ;
oFCKeditor.BasePath= '%(fckbasepath)s/' ;
oFCKeditor.Config['WikiBasePath'] = '%(wikiurl)s' ;
oFCKeditor.Config['WikiPage'] = '%(wikipage)s' ;
oFCKeditor.Config['PluginsPath'] = '%(url_prefix)s/applets/moinFCKplugins/' ;
oFCKeditor.Config['CustomConfigurationsPath'] = '%(url_prefix)s/applets/moinfckconfig.js' ;
oFCKeditor.Config['WordRule'] = %(word_rule)s ;
oFCKeditor.Config['SmileyPath'] = '%(smileypath)s/' ;
oFCKeditor.Config['EditorAreaCSS'] = '%(themepath)s/css/common.css' ;
oFCKeditor.Config['SkinPath'] = '%(fckbasepath)s/editor/skins/silver/' ;
oFCKeditor.Config['AutoDetectLanguage'] = false ;
oFCKeditor.Config['DefaultLanguage'] = '%(uilanguage)s' ;
oFCKeditor.Config['ContentLangDirection'] = '%(contentlangdirection)s' ;
oFCKeditor.Value= """ % locals())
from MoinMoin.formatter.text_gedit import Formatter
self.formatter = Formatter(request)
self.formatter.page = self
output = request.redirectedOutput(self.send_page_content, request, Parser, raw_body, do_cache=False)
output = repr(output)
if output[0] == 'u':
output = output[1:]
request.write(output)
self.request.write(""" ;
oFCKeditor.Create() ;
//-->
</script>
""")
self.request.write("<p>")
self.request.write(_("Comment:"),
' <input id="editor-comment" type="text" name="comment" value="%s" maxlength="200">' % (
wikiutil.escape(kw.get('comment', ''), 1), ))
self.request.write("</p>")
# Category selection
filter = re.compile(self.cfg.page_category_regex, re.UNICODE).search
cat_pages = self.request.rootpage.getPageList(filter=filter)
cat_pages.sort()
cat_pages = [wikiutil.pagelinkmarkup(p) for p in cat_pages]
cat_pages.insert(0, ('', _('<No addition>', formatted=False)))
self.request.write("<p>")
self.request.write(_('Add to: %(category)s') % {
'category': unicode(util.web.makeSelection('category', cat_pages)),
})
if self.cfg.mail_enabled:
self.request.write('''
<input type="checkbox" name="trivial" id="chktrivial" value="1" %(checked)s>
<label for="chktrivial">%(label)s</label> ''' % {
'checked': ('', 'checked')[form.get('trivial',['0'])[0] == '1'],
'label': _("Trivial change"),
})
self.request.write('''
<input type="checkbox" name="rstrip" id="chkrstrip" value="1" %(checked)s>
<label for="chkrstrip">%(label)s</label>
</p> ''' % {
'checked': ('', 'checked')[form.get('rstrip',['0'])[0] == '1'],
'label': _('Remove trailing whitespace from each line')
})
self.request.write("</p>")
badwords_re = None
if preview is not None:
if SpellCheck and (
form.has_key('button_spellcheck') or
form.has_key('button_newwords')):
badwords, badwords_re, msg = SpellCheck.checkSpelling(self, self.request, own_form=0)
self.request.write("<p>%s</p>" % msg)
self.request.write('</fieldset>')
self.request.write("</form>")
if preview is not None:
if staytop:
content_id = 'previewbelow'
else:
content_id = 'preview'
self.send_page(self.request, content_id=content_id, content_only=1,
hilite_re=badwords_re)
self.request.write(self.request.formatter.endContent()) # end content div
wikiutil.send_footer(self.request, self.page_name)
def do_diff(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(request)
return
try:
date = request.form['date'][0]
try:
date = long(date) # must be long for py 2.2.x
except StandardError:
date = 0
except KeyError:
date = 0
try:
rev1 = request.form['rev1'][0]
try:
rev1 = int(rev1)
except StandardError:
rev1 = 0
except KeyError:
rev1 = -1
try:
rev2 = request.form['rev2'][0]
try:
rev2 = int(rev2)
except StandardError:
rev2 = 0
except KeyError:
rev2 = 0
if rev1 == -1 and rev2 == 0:
try:
rev1 = request.form['rev'][0]
try:
rev1 = int(rev1)
except StandardError:
rev1 = -1
except KeyError:
rev1 = -1
# spacing flag?
try:
ignorews = int(request.form['ignorews'][0])
except (KeyError, ValueError, TypeError):
ignorews = 0
_ = request.getText
# get a list of old revisions, and back out if none are available
currentpage = Page(request, pagename)
revisions = currentpage.getRevList()
if len(revisions) < 2:
currentpage.send_page(request, msg=_("No older revisions available!"))
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
# Start output
# This action generate content in the user language
request.setContentLanguage(request.lang)
request.http_headers()
wikiutil.send_title(request, _('Diff for "%s"') % (pagename,), pagename=pagename)
if (rev1>0 and rev2>0 and rev1>rev2) or (rev1==0 and rev2>0):
rev1,rev2 = rev2,rev1
oldrev1,oldcount1 = None,0
oldrev2,oldcount2 = None,0
# get the filename of the version to compare to
edit_count = 0
for rev in revisions:
edit_count += 1
if rev <= rev1:
oldrev1,oldcount1 = rev,edit_count
if rev2 and rev >= rev2:
oldrev2,oldcount2 = rev,edit_count
if (oldrev1 and oldrev2) or (oldrev1 and not rev2):
break
if rev1 == -1:
oldpage = Page(request, pagename, rev=revisions[1])
oldcount1 = oldcount1 - 1
elif rev1 == 0:
oldpage = currentpage
# oldcount1 is still on init value 0
else:
if oldrev1:
oldpage = Page(request, pagename, rev=oldrev1)
else:
oldpage = Page(request, "$EmptyPage$") # hack
oldpage.set_raw_body("") # avoid loading from disk
oldrev1 = 0 # XXX
if rev2 == 0:
newpage = currentpage
# oldcount2 is still on init value 0
else:
if oldrev2:
newpage = Page(request, pagename, rev=oldrev2)
else:
newpage = Page(request, "$EmptyPage$") # hack
newpage.set_raw_body("") # avoid loading from disk
oldrev2 = 0 # XXX
edit_count = abs(oldcount1 - oldcount2)
# this should use the formatter, but there is none?
request.write('<div id="content">\n') # start content div
request.write('<p class="diff-header">')
request.write(_('Differences between revisions %d and %d') % (oldpage.get_real_rev(), newpage.get_real_rev()))
if edit_count > 1:
request.write(' ' + _('(spanning %d versions)') % (edit_count,))
request.write('</p>')
if request.user.show_fancy_diff:
from MoinMoin.util.diff import diff
request.write(diff(request, oldpage.get_raw_body(), newpage.get_raw_body()))
newpage.send_page(request, count_hit=0, content_only=1, content_id="content-below-diff")
else:
lines = wikiutil.linediff(oldpage.getlines(), newpage.getlines())
if not lines:
msg = _("No differences found!")
if edit_count > 1:
msg = msg + '<p>' + _('The page was saved %(count)d times, though!') % {
'count': edit_count}
request.write(msg)
else:
if ignorews:
request.write(_('(ignoring whitespace)') + '<br>')
else:
qstr = 'action=diff&ignorews=1'
if rev1: qstr = '%s&rev1=%s' % (qstr, rev1)
if rev2: qstr = '%s&rev2=%s' % (qstr, rev2)
request.write(Page(request, pagename).link_to(request,
text=_('Ignore changes in the amount of whitespace'),
querystr=qstr) + '<p>')
request.write('<pre>')
for line in lines:
if line[0] == "@":
request.write('<hr>')
request.write(wikiutil.escape(line)+'\n')
request.write('</pre>')
request.write('</div>\n') # end content div
wikiutil.send_footer(request, pagename, showpage=1)
def do_info(pagename, request):
if not request.user.may.read(pagename):
Page(request, pagename).send_page(request)
return
def general(page, pagename, request):
_ = request.getText
request.write('<h2>%s</h2>\n' % _('General Information'))
# show page size
request.write(("<p>%s</p>" % _("Page size: %d")) % page.size())
# show SHA digest fingerprint
import sha
digest = sha.new(page.get_raw_body().encode(config.charset)).hexdigest().upper()
request.write('<p>%(label)s <tt>%(value)s</tt></p>' % {
'label': _("SHA digest of this page's content is:"),
'value': digest,
})
# show attachments (if allowed)
attachment_info = getHandler(request, 'AttachFile', 'info')
if attachment_info:
request.write(attachment_info(pagename, request))
# show subscribers
subscribers = page.getSubscribers(request, include_self=1, return_users=1)
if subscribers:
request.write('<p>', _('The following users subscribed to this page:'))
for lang in subscribers.keys():
request.write('<br>[%s] ' % lang)
for user in subscribers[lang]:
# do NOT disclose email addr, only WikiName
userhomepage = Page(request, user.name)
if userhomepage.exists():
request.write(userhomepage.link_to(request) + ' ')
else:
request.write(user.name + ' ')
request.write('</p>')
# show links
links = page.getPageLinks(request)
if links:
request.write('<p>', _('This page links to the following pages:'), '<br>')
for linkedpage in links:
request.write("%s%s " % (Page(request, linkedpage).link_to(request), ",."[linkedpage == links[-1]]))
request.write("</p>")
def history(page, pagename, request):
# show history as default
_ = request.getText
# open log for this page
from MoinMoin.logfile import editlog
from MoinMoin.util.dataset import TupleDataset, Column
history = TupleDataset()
history.columns = [
Column('rev', label='#', align='right'),
Column('mtime', label=_('Date'), align='right'),
Column('size', label=_('Size'), align='right'),
Column('diff', label='<input type="submit" value="%s">' % (_("Diff"))),
# TODO: translate to English
# entfernt, nicht 4.01 compliant: href="%s" % page.url(request)
Column('editor', label=_('Editor'), hidden=not request.cfg.show_hosts),
Column('comment', label=_('Comment')),
Column('action', label=_('Action')),
]
# generate history list
revisions = page.getRevList()
versions = len(revisions)
may_revert = request.user.may.revert(pagename)
# read in the complete log of this page
log = editlog.EditLog(request, rootpagename=pagename)
count = 0
for line in log.reverse():
rev = int(line.rev)
actions = ""
if line.action in ['SAVE','SAVENEW','SAVE/REVERT',]:
if count == 0: # latest page
actions = '%s %s' % (actions, page.link_to(request,
text=_('view'),
querystr=''))
actions = '%s %s' % (actions, page.link_to(request,
text=_('raw'),
querystr='action=raw'))
actions = '%s %s' % (actions, page.link_to(request,
text=_('print'),
querystr='action=print'))
else:
actions = '%s %s' % (actions, page.link_to(request,
text=_('view'),
querystr='action=recall&rev=%d' % rev))
actions = '%s %s' % (actions, page.link_to(request,
text=_('raw'),
querystr='action=raw&rev=%d' % rev))
actions = '%s %s' % (actions, page.link_to(request,
text=_('print'),
querystr='action=print&rev=%d' % rev))
if may_revert:
actions = '%s %s' % (actions, page.link_to(request,
text=_('revert'),
querystr='action=revert&rev=%d' % (rev,)))
if count == 0:
rchecked=' checked="checked"'
lchecked = ''
elif count == 1:
lchecked=' checked="checked"'
rchecked = ''
else:
lchecked = rchecked = ''
diff = '<input type="radio" name="rev1" value="%d"%s><input type="radio" name="rev2" value="%d"%s>' % (rev,lchecked,rev,rchecked)
comment = line.comment
if not comment and line.action.find('/REVERT') != -1:
comment = _("Revert to revision %(rev)d.") % {'rev': int(line.extra)}
size = page.size(rev=rev)
else: # ATT*
rev = '-'
diff = '-'
filename = line.extra
comment = "%s: %s %s" % (line.action, filename, line.comment)
size = 0
if line.action != 'ATTDEL':
from MoinMoin.action import AttachFile
page_dir = AttachFile.getAttachDir(request, pagename)
filepath = os.path.join(page_dir, filename)
try:
# FIXME, wrong path on non-std names
size = os.path.getsize(filepath)
except:
pass
if line.action == 'ATTNEW':
actions = '%s %s' % (actions, page.link_to(request,
text=_('view'),
querystr='action=AttachFile&do=view&target=%s' % filename))
elif line.action == 'ATTDRW':
actions = '%s %s' % (actions, page.link_to(request,
text=_('edit'),
querystr='action=AttachFile&drawing=%s' % filename.replace(".draw","")))
actions = '%s %s' % (actions, page.link_to(request,
text=_('get'),
querystr='action=AttachFile&do=get&target=%s' % filename))
actions = '%s %s' % (actions, page.link_to(request,
text=_('del'),
querystr='action=AttachFile&do=del&target=%s' % filename))
# XXX use?: wikiutil.escape(filename)
history.addRow((
rev,
request.user.getFormattedDateTime(wikiutil.version2timestamp(line.ed_time_usecs)),
str(size),
diff,
line.getEditor(request) or _("N/A"),
wikiutil.escape(comment) or ' ',
actions,
))
count += 1
if count >= 100:
break
# print version history
from MoinMoin.widget.browser import DataBrowserWidget
from MoinMoin.formatter.text_html import Formatter
request.write('<h2>%s</h2>\n' % _('Revision History'))
if not count: # there was no entry in logfile
request.write(_('No log entries found.'))
return
# TODO: this form activate revert, which should use post, but
# other actions should use get. Maybe we should put the revert
# into the page view itself, and not in this form.
request.write('<form method="GET" action="">\n')
request.write('<div id="page-history">\n')
request.write('<input type="hidden" name="action" value="diff">\n')
request.formatter = Formatter(request)
history_table = DataBrowserWidget(request)
history_table.setData(history)
history_table.render()
request.write('</div>\n')
request.write('</form>\n')
_ = request.getText
page = Page(request, pagename)
qpagename = wikiutil.quoteWikinameURL(pagename)
title = page.split_title(request)
request.http_headers()
# This action uses page or wiki language TODO: currently
# page.language is broken and not available now, when we fix it,
# this will be automatically fixed.
lang = page.language or request.cfg.default_lang
request.setContentLanguage(lang)
wikiutil.send_title(request, _('Info for "%s"') % (title,), pagename=pagename)
historylink = wikiutil.link_tag(request, '%s?action=info' % qpagename,
_('Show "%(title)s"') % {'title': _('Revision History')})
generallink = wikiutil.link_tag(request, '%s?action=info&general=1' % qpagename,
_('Show "%(title)s"') % {'title': _('General Page Infos')})
hitcountlink = wikiutil.link_tag(request, '%s?action=info&hitcounts=1' % qpagename,
_('Show chart "%(title)s"') % {'title': _('Page hits and edits')})
request.write('<div id="content">\n') # start content div
request.write("<p>[%s] [%s] [%s]</p>" % (historylink, generallink, hitcountlink))
show_hitcounts = int(request.form.get('hitcounts', [0])[0]) != 0
show_general = int(request.form.get('general', [0])[0]) != 0
if show_hitcounts:
from MoinMoin.stats import hitcounts
request.write(hitcounts.linkto(pagename, request, 'page=' + urllib.quote_plus(pagename.encode(config.charset))))
elif show_general:
general(page, pagename, request)
else:
history(page, pagename, request)
request.write('</div>\n') # end content div
wikiutil.send_footer(request, pagename, showpage=1)
def execute(pagename, request, fieldname='value', titlesearch=0):
_ = request.getText
titlesearch = isTitleSearch(request)
# context is relevant only for full search
if titlesearch:
context = 0
else:
context = int(request.form.get('context', [0])[0])
# Get other form parameters
needle = request.form.get(fieldname, [''])[0]
case = int(request.form.get('case', [0])[0])
regex = int(request.form.get('regex', [0])[0]) # no interface currently
max_context = 1 # only show first `max_context` contexts XXX still unused
# check for sensible search term
striped = needle.strip()
if len(striped) == 0:
err = _('Please use a more selective search term instead '
'of {{{"%s"}}}') % needle
# send http headers
request.http_headers()
Page(request, pagename).send_page(request, msg=err)
return
# search the pages
from MoinMoin import search
query = search.QueryParser(case=case, regex=regex,
titlesearch=titlesearch).parse_query(needle)
results = search.searchPages(request, query)
# directly show a single hit
# XXX won't work with attachment search
# improve if we have one...
if len(results.hits) == 1:
page = Page(request, results.hits[0].page_name)
# TODO: remove escape=0 in 1.4
url = page.url(request, querystr={'highlight': query.highlight_re()},
escape=0)
request.http_redirect(url)
raise MoinMoinNoFooter
# send http headers
request.http_headers()
# This action generate data using the user language
request.setContentLanguage(request.lang)
# Setup for type of search
if titlesearch:
title = _('Title Search: "%s"')
results.sortByPagename()
else:
title = _('Full Text Search: "%s"')
results.sortByWeight()
wikiutil.send_title(request, title % needle, form=request.form,
pagename=pagename)
# Start content (important for RTL support)
formatter = Formatter(request)
request.write(formatter.startContent("content"))
# First search stats
request.write(results.stats(request, formatter))
# Then search results
info = not titlesearch
if context:
output = results.pageListWithContext(request, formatter, info=info,
context=context)
else:
output = results.pageList(request, formatter, info=info)
request.write(output)
# End content and send footer
request.write(formatter.endContent())
wikiutil.send_footer(request, pagename, editable=0, showactions=0,
form=request.form)
def execute(pagename, request):
request.http_headers()
wikiutil.send_title(request, "Updating DB")
Xapian.index_pages()
wikiutil.send_footer(request, '')
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:
return thispage.send_page(request,
msg = _('Please log in first.'))
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_wiki(request, '%s:%s' % 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():
return homepage.send_page(request,
msg = _('Please first create a homepage before creating additional pages.'))
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||
""", formatted=False)
pagecontent = pagecontent % locals()
pagecontent = pagecontent.replace('\n', '\r\n')
from MoinMoin.Page import Page
from MoinMoin.parser.wiki import Parser
from MoinMoin.formatter.text_html import Formatter
pagename = username
request.http_headers()
# This action generate data using the user language
request.setContentLanguage(request.lang)
wikiutil.send_title(request, _('MyPages management', formatted=False), pagename=pagename)
# Start content - IMPORTANT - without content div, there is no
# direction support!
request.write(request.formatter.startContent("content"))
parser = Parser(pagecontent, request)
formatter = Formatter(request)
reqformatter = None
if hasattr(request, 'formatter'):
reqformatter = request.formatter
request.formatter = formatter
p = Page(request, "$$$")
formatter.setPage(p)
parser.format(formatter)
if reqformatter == None:
del request.formatter
else:
request.formatter = reqformatter
# End content and send footer
request.write(request.formatter.endContent())
wikiutil.send_footer(request, pagename)
