def findMatches(pagename, request, s_re=None, e_re=None):
""" Find like pages
@param pagename: name to match
@param request: current reqeust
@param s_re: start re for wiki matching
@param e_re: end re for wiki matching
@rtype: tuple
@return: start word, end word, matches dict
"""
# Get full list of pages, with no filtering - very fast. We will
# first search for like pages, then filter the results.
pages = request.rootpage.getPageList(user='', exists='')
# Remove current page
try:
pages.remove(pagename)
except ValueError:
pass
# Get matches using wiki way, start and end of word
start, end, matches = wikiMatches(pagename,
pages,
start_re=s_re,
end_re=e_re)
# Get the best 10 close matches
close_matches = {}
found = 0
for name in closeMatches(pagename, pages):
# Skip names already in matches
if name in matches:
continue
# Filter deleted pages or pages the user can't read
page = Page(request, name)
if page.exists() and request.user.may.read(name):
close_matches[name] = 8
found += 1
# Stop after 10 matches
if found == 10:
break
# Filter deleted pages or pages the user can't read from
# matches. Order is important!
for name in matches.keys(): # we need .keys() because we modify the dict
page = Page(request, name)
if not (page.exists() and request.user.may.read(name)):
del matches[name]
# Finally, merge both dicts
matches.update(close_matches)
return start, end, matches
def findMatches(pagename, request, s_re=None, e_re=None,):
""" Find like pages
@param pagename: name to match
@param request: current reqeust
@param s_re: start re for wiki matching
@param e_re: end re for wiki matching
@rtype: tuple
@return: start word, end word, matches dict
"""
# Get full list of pages, with no filtering - very fast. We will
# first search for like pages, then filter the results.
pages = request.rootpage.getPageList(user='', exists='')
# Remove current page
try:
pages.remove(pagename)
except ValueError:
pass
# Get matches using wiki way, start and end of word
start, end, matches = wikiMatches(pagename, pages, start_re=s_re,
end_re=e_re)
# Get the best 10 close matches using difflib
close_matches = {}
found = 0
for name in closeMatches(pagename, pages):
# Skip names already in matches
if name in matches:
continue
# Filter deleted pages or pages the user can't read
page = Page(request, name)
if page.exists() and request.user.may.read(name):
close_matches[name] = 8
found += 1
# Stop after 10 matches
if found == 10:
break
# Filter deleted pages or pages the user can't read from
# matches. Order is important!
for name in matches.keys():
page = Page(request, name)
if not (page.exists() and request.user.may.read(name)):
del matches[name]
# Finally, merge both dicts
matches.update(close_matches)
return start, end, matches
def _load_dict(self):
request = self.request
dict_name = self.name
page = Page(request, dict_name)
if page.exists():
arena = "pagedicts"
key = wikiutil.quoteWikinameFS(dict_name)
cache = caching.CacheEntry(request, arena, key, scope="wiki", use_pickle=True)
try:
cache_mtime = cache.mtime()
page_mtime = wikiutil.version2timestamp(page.mtime_usecs())
# TODO: fix up-to-date check mtime granularity problems.
#
# cache_mtime is float while page_mtime is integer
# The comparision needs to be done on the lowest type of both
if int(cache_mtime) > int(page_mtime):
# cache is uptodate
return cache.content()
else:
raise caching.CacheError
except caching.CacheError:
# either cache does not exist, is erroneous or not uptodate: recreate it
d = super(WikiDict, self)._load_dict()
cache.update(d)
return d
else:
raise DictDoesNotExistError(dict_name)
def include(self, name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
# content contains the included file name
_ = self.request.getText
if len(content):
if content[0] in self.included_documents:
lines = [_("**Duplicate included files are not permitted**")]
state_machine.insert_input(lines, 'MoinDirectives')
return
self.included_documents.append(content[0])
page = Page(page_name = content[0], request = self.request)
if page.exists():
text = page.get_raw_body()
lines = text.split('\n')
# Remove the "#format rst" line
if lines[0].startswith("#format"):
del lines[0]
else:
lines = [_("**Could not find the referenced page: %s**") % (content[0],)]
# Insert the text from the included document and then continue
# parsing
state_machine.insert_input(lines, 'MoinDirectives')
return
def move_file(request, pagename, new_pagename, attachment, new_attachment):
_ = request.getText
newpage = Page(request, new_pagename)
if newpage.exists(includeDeleted=1) and request.user.may.write(new_pagename) and request.user.may.delete(pagename):
new_attachment_path = os.path.join(getAttachDir(request, new_pagename,
create=1), new_attachment).encode(config.charset)
attachment_path = os.path.join(getAttachDir(request, pagename),
attachment).encode(config.charset)
if os.path.exists(new_attachment_path):
upload_form(pagename, request,
msg=_("Attachment '%(new_pagename)s/%(new_filename)s' already exists.") % {
'new_pagename': new_pagename,
'new_filename': new_attachment})
return
if new_attachment_path != attachment_path:
# move file
filesys.rename(attachment_path, new_attachment_path)
_addLogEntry(request, 'ATTDEL', pagename, attachment)
_addLogEntry(request, 'ATTNEW', new_pagename, new_attachment)
upload_form(pagename, request,
msg=_("Attachment '%(pagename)s/%(filename)s' moved to '%(new_pagename)s/%(new_filename)s'.") % {
'pagename': pagename,
'filename': attachment,
'new_pagename': new_pagename,
'new_filename': new_attachment})
else:
upload_form(pagename, request, msg=_("Nothing changed"))
else:
upload_form(pagename, request, msg=_("Page '%(new_pagename)s' does not exist or you don't have enough rights.") % {
'new_pagename': new_pagename})
def addTrail(self, pagename):
"""
Add page to trail.
@param pagename: the page name to add to the trail
"""
if self.valid and (self.show_page_trail or self.remember_last_visit):
# load trail if not known
self.getTrail()
# don't append tail to trail ;)
if self._trail and self._trail[-1] == pagename: return
# Add only existing pages that the user may read
if self._request:
from MoinMoin.Page import Page
page = Page(self._request, pagename)
if not (page.exists() and
self._request.user.may.read(page.page_name)):
return
# append new page, limiting the length
self._trail = filter(lambda p, pn=pagename: p != pn, self._trail)
self._trail = self._trail[-(self._cfg.trail_size-1):]
self._trail.append(pagename)
# save new trail
trailfile = codecs.open(self.__filename() + ".trail", "w", config.charset)
for t in self._trail:
trailfile.write('%s\n' % t)
trailfile.close()
try:
os.chmod(self.__filename() + ".trail", 0666 & config.umask)
except OSError:
pass
def xmlrpc_getProcessingInstructionVersion(self, pagename, rev, pi):
"""
Returns value of Processing Instruction
@param pagename: pagename (utf-8)
@param rev: revision number (int)
@param pi: PI key
"""
# User may read page?
if not self.request.user.may.read(pagename):
return self.notAllowedFault()
if rev is not None:
page = Page(self.request, pagename, rev=rev)
else:
page = Page(self.request, pagename)
if not page.exists():
return xmlrpclib.Fault("NOT_EXIST", "Page does not exist.")
if pi is None:
return xmlrpclib.Fault("NOT_EXIST",
"Processing Instruction not given.")
try:
instruction = page.pi[pi]
except KeyError:
return xmlrpclib.Fault("NOT_EXIST",
"Processing Instruction does not exist.")
return self._outstr(instruction)
def include(self, name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
# content contains the included file name
_ = self.request.getText
if len(content):
if content[0] in self.included_documents:
lines = [_("**Duplicate included files are not permitted**")]
state_machine.insert_input(lines, 'MoinDirectives')
return
self.included_documents.append(content[0])
page = Page(page_name=content[0], request=self.request)
if page.exists():
text = page.get_raw_body()
lines = text.split('\n')
# Remove the "#format rst" line
if lines[0].startswith("#format"):
del lines[0]
else:
lines = [
_("**Could not find the referenced page: %s**") %
(content[0], )
]
# Insert the text from the included document and then continue
# parsing
state_machine.insert_input(lines, 'MoinDirectives')
return
def xmlrpc_listLinks(self, pagename):
"""
list links for a given page
@param pagename: the page name
@rtype: list
@return: links of the page, structs, with the following elements
* name (string) : The page name or URL the link is to, UTF-8 encoding.
* type (int) : The link type. Zero (0) for internal Wiki
link, one (1) for external link (URL - image link, whatever).
"""
pagename = self._instr(pagename)
# User may read page?
if not self.request.user.may.read(pagename):
return self.notAllowedFault()
page = Page(self.request, pagename)
# Non existing page?
if not page.exists():
return self.noSuchPageFault()
links_out = []
for link in page.getPageLinks(self.request):
links_out.append({ 'name': self._outstr(link), 'type': 0 })
return links_out
def find_by_re (request, formatter, re_exp, rpl_text, search):
ret = []
if not hasattr(request, "_Include_backto"):
request._Include_backto = formatter.page.page_name
if search == None:
pages = getPageListFromLog(request)
ret.append('Results from recent-log(%d pages):' % len(pages))
else:
pages = getPageListFromSearch(request,search)
ret.append('Results from searching by __%s__(%d pages):' % (search, len(pages)))
task_re = re.compile(re_exp, re.UNICODE|re.DOTALL)
for pagename in pages:
if pagename == formatter.page.page_name: continue
page = Page(request, pagename)
if not page.exists(): continue
ret.append(findtext_by_re(request, task_re, re_exp, rpl_text, page))
return wikiutil.renderText(request, WikiParser, '\n'.join(ret))#wikiutil.escape('\n'.join(ret)))
def xmlrpc_listLinks(self, pagename):
"""
list links for a given page
@param pagename: the page name
@rtype: list
@return: links of the page, structs, with the following elements
* name (string) : The page name or URL the link is to, UTF-8 encoding.
* type (int) : The link type. Zero (0) for internal Wiki
link, one (1) for external link (URL - image link, whatever).
"""
pagename = self._instr(pagename)
# User may read page?
if not self.request.user.may.read(pagename):
return self.notAllowedFault()
page = Page(self.request, pagename)
# Non existing page?
if not page.exists():
return self.noSuchPageFault()
links_out = []
for link in page.getPageLinks(self.request):
links_out.append({'name': self._outstr(link), 'type': 0})
return links_out
def _load_group(self):
request = self.request
group_name = self.name
page = Page(request, group_name)
if page.exists():
arena = 'pagegroups'
key = wikiutil.quoteWikinameFS(group_name)
cache = caching.CacheEntry(request, arena, key, scope='wiki', use_pickle=True)
try:
cache_mtime = cache.mtime()
page_mtime = wikiutil.version2timestamp(page.mtime_usecs())
# TODO: fix up-to-date check mtime granularity problems.
#
# cache_mtime is float while page_mtime is integer
# The comparision needs to be done on the lowest type of both
if int(cache_mtime) > int(page_mtime):
# cache is uptodate
return cache.content()
else:
raise caching.CacheError
except caching.CacheError:
# either cache does not exist, is erroneous or not uptodate: recreate it
members, member_groups = super(WikiGroup, self)._load_group()
cache.update((members, member_groups))
return members, member_groups
else:
raise GroupDoesNotExistError(group_name)
def include(self, name, arguments, options, content, lineno,
content_offset, block_text, state, state_machine):
# content contains the included file name
_ = self.request.getText
# Limit the number of documents that can be included
if self.num_includes < self.max_includes:
self.num_includes += 1
else:
lines = [_("**Maximum number of allowed includes exceeded**")]
state_machine.insert_input(lines, 'MoinDirectives')
return
if len(content):
pagename = content[0]
page = Page(page_name=pagename, request=self.request)
if not self.request.user.may.read(pagename):
lines = [_("**You are not allowed to read the page: %s**") % (pagename, )]
else:
if page.exists():
text = page.get_raw_body()
lines = text.split('\n')
# Remove the "#format rst" line
if lines[0].startswith("#format"):
del lines[0]
else:
lines = [_("**Could not find the referenced page: %s**") % (pagename, )]
# Insert the text from the included document and then continue parsing
state_machine.insert_input(lines, 'MoinDirectives')
return
def save(self, editor, newtext, rev, **kw):
request = self.request
username = request.user.name
pagename = editor.page_name
if grouppage_autocreate and username == pagename:
# create group pages when a user saves his own homepage
for page in grouppages:
grouppagename = "%s/%s" % (username, page)
grouppage = Page(request, grouppagename)
if not grouppage.exists():
text = """\
#acl %(username)s:read,write,delete,revert
* %(username)s
""" % locals()
editor = PageEditor(request, grouppagename)
editor._write_file(text)
parts = pagename.split('/')
if len(parts) == 2:
subpage = parts[1]
if subpage in grouppages and not self.admin(pagename):
return False
# No problem to save if my base class agrees
return Permissions.save(self, editor, newtext, rev, **kw)
def packagePages(self, pagelist, filename, function):
""" Puts pages from pagelist into filename and calls function on them on installation. """
request = self.request
try:
os.remove(filename)
except OSError:
pass
zf = zipfile.ZipFile(filename, "w", COMPRESSION_LEVEL)
cnt = 0
script = [packLine(['MoinMoinPackage', '1']), ]
for pagename in pagelist:
pagename = pagename.strip()
page = Page(request, pagename)
if page.exists():
cnt += 1
script.append(packLine([function, str(cnt), pagename]))
timestamp = wikiutil.version2timestamp(page.mtime_usecs())
zi = zipfile.ZipInfo(filename=str(cnt), date_time=datetime.fromtimestamp(timestamp).timetuple()[:6])
zi.compress_type = COMPRESSION_LEVEL
zf.writestr(zi, page.get_raw_body().encode("utf-8"))
else:
#import sys
#print >>sys.stderr, "Could not find the page %s." % pagename.encode("utf-8")
pass
script += [packLine(['Print', 'Installed MoinMaster page bundle %s.' % os.path.basename(filename)])]
zf.writestr(MOIN_PACKAGE_FILE, u"\n".join(script).encode("utf-8"))
zf.close()
def execute(pagename, request):
_ = request.getText
sub_page_name = request.cfg.supplementation_page_name
sub_page_template = request.cfg.supplementation_page_template
newpagename = "%s/%s" % (pagename, sub_page_name)
errormsg = _("You are not allowed to create the supplementation page.")
if pagename.endswith(sub_page_name): # sub_sub_page redirects to sub_page
query = {}
url = Page(request, pagename).url(request, query)
request.http_redirect(url)
elif request.user.may.read(newpagename):
query = {}
url = Page(request, newpagename).url(request, query)
test = Page(request, newpagename)
if test.exists(): # page is defined -> redirect
request.http_redirect(url)
elif request.user.may.write(
newpagename): # page will be created from template
query = {
'action': 'edit',
'backto': newpagename,
'template': quoteWikinameURL(sub_page_template)
}
url = Page(request, newpagename).url(request, query)
request.http_redirect(url)
else:
request.theme.add_msg(errormsg, "error")
else:
request.theme.add_msg(errormsg, "error")
def xmlrpc_getPageVersion(self, pagename, rev):
""" Get raw text from specific revision of pagename
@param pagename: pagename (utf-8)
@param rev: revision number (int)
@rtype: str
@return: utf-8 encoded page data
"""
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()
# Return page raw text
if self.version == 2:
return self._outstr(page.get_raw_body())
elif self.version == 1:
return self._outlob(page.get_raw_body())
def save(self, editor, newtext, rev, **kw):
request = self.request
username = request.user.name
pagename = editor.page_name
if grouppage_autocreate and username == pagename:
# create group pages when a user saves his own homepage
for page in grouppages:
grouppagename = "%s/%s" % (username, page)
grouppage = Page(request, grouppagename)
if not grouppage.exists():
text = """\
#acl %(username)s:read,write,delete,revert
* %(username)s
""" % locals()
editor = PageEditor(request, grouppagename)
editor._write_file(text)
parts = pagename.split('/')
if len(parts) == 2:
subpage = parts[1]
if subpage in grouppages and not self.admin(pagename):
return False
# No problem to save if my base class agrees
return Permissions.save(self, editor, newtext, rev, **kw)
def xmlrpc_getPageVersion(self, pagename, rev):
"""
Get raw text from specific revision of pagename
@param pagename: pagename (utf-8)
@param rev: revision number (int)
@rtype: str
@return: utf-8 encoded page data
"""
pagename = self._instr(pagename)
# User may read page?
if not self.request.user.may.read(pagename):
return self.notAllowedFault()
if rev is not None:
page = Page(self.request, pagename, rev=rev)
else:
page = Page(self.request, pagename)
# Non existing page?
if not page.exists():
return self.noSuchPageFault()
# Return page raw text
if self.version == 2:
return self._outstr(page.get_raw_body())
elif self.version == 1:
return self._outlob(page.get_raw_body())
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 is not 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
result = self.request.redirectedOutput(page.send_page, content_only=1)
# Return rendered page
if self.version == 2:
return self._outstr(result)
elif self.version == 1:
return xmlrpclib.Binary(result)
def _load_group(self):
request = self.request
group_name = self.name
page = Page(request, group_name)
if page.exists():
arena = 'pagegroups'
key = wikiutil.quoteWikinameFS(group_name)
cache = caching.CacheEntry(request,
arena,
key,
scope='wiki',
use_pickle=True)
try:
cache_mtime = cache.mtime()
page_mtime = wikiutil.version2timestamp(page.mtime_usecs())
# TODO: fix up-to-date check mtime granularity problems.
#
# cache_mtime is float while page_mtime is integer
# The comparision needs to be done on the lowest type of both
if int(cache_mtime) > int(page_mtime):
# cache is uptodate
return cache.content()
else:
raise caching.CacheError
except caching.CacheError:
# either cache does not exist, is erroneous or not uptodate: recreate it
members, member_groups = super(WikiGroup, self)._load_group()
cache.update((members, member_groups))
return members, member_groups
else:
raise GroupDoesNotExistError(group_name)
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 is not 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
result = self.request.redirectedOutput(page.send_page, content_only=1)
# Return rendered page
if self.version == 2:
return self._outstr(result)
elif self.version == 1:
return xmlrpclib.Binary(result)
def execute(pagename, request):
_ = request.getText
sub_page_name = request.cfg.supplementation_page_name
sub_page_template = request.cfg.supplementation_page_template
newpagename = "%s/%s" % (pagename, sub_page_name)
errormsg = _("You are not allowed to create the supplementation page.")
if pagename.endswith(sub_page_name): # sub_sub_page redirects to sub_page
query = {}
url = Page(request, pagename).url(request, query)
request.http_redirect(url)
elif request.user.may.read(newpagename):
query = {}
url = Page(request, newpagename).url(request, query)
test = Page(request, newpagename)
if test.exists(): # page is defined -> redirect
request.http_redirect(url)
elif request.user.may.write(newpagename): # page will be created from template
query = {'action': 'edit', 'backto': newpagename, 'template': quoteWikinameURL(sub_page_template)}
url = Page(request, newpagename).url(request, query)
request.http_redirect(url)
else:
request.theme.add_msg(errormsg, "error")
else:
request.theme.add_msg(errormsg, "error")
def addTrail(self, pagename):
"""
Add page to trail.
@param pagename: the page name to add to the trail
"""
# TODO: acquire lock here, so multiple processes don't clober
# each one trail.
if self.valid and (self.show_page_trail or self.remember_last_visit):
# load trail if not known
self.getTrail()
# don't append tail to trail ;)
if self._trail and self._trail[-1] == pagename: return
# Add only existing pages that the user may read
if self._request:
from MoinMoin.Page import Page
page = Page(self._request, pagename)
if not (page.exists() and
self._request.user.may.read(page.page_name)):
return
# append new page, limiting the length
self._trail = filter(lambda p, pn=pagename: p != pn, self._trail)
self._trail = self._trail[-(self._cfg.trail_size-1):]
self._trail.append(pagename)
self.saveTrail()
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()
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 general(page, pagename, request):
_ = request.getText
f = request.formatter
request.write(f.heading(1, 1), f.text(_('General Information')),
f.heading(0, 1))
request.write(f.paragraph(1), f.text(_("Page size: %d") % page.size()),
f.paragraph(0))
from MoinMoin.support.python_compatibility import hash_new
digest = hash_new('sha1',
page.get_raw_body().encode(
config.charset)).hexdigest().upper()
request.write(
f.paragraph(1),
f.rawHTML(
'%(label)s <tt>%(value)s</tt>' % {
'label': _("SHA digest of this page's content is:"),
'value': digest,
}), f.paragraph(0))
# show attachments (if allowed)
attachment_info = action.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(f.paragraph(1))
request.write(
f.text(_('The following users subscribed to this page:')))
for lang in subscribers:
request.write(f.linebreak(), f.text('[%s] ' % lang))
for user in subscribers[lang]:
# do NOT disclose email addr, only WikiName
userhomepage = Page(request, user.name)
if userhomepage.exists():
request.write(
f.rawHTML(userhomepage.link_to(request) + ' '))
else:
request.write(f.text(user.name + ' '))
request.write(f.paragraph(0))
# show links
links = page.getPageLinks(request)
if links:
request.write(f.paragraph(1))
request.write(f.text(_('This page links to the following pages:')))
request.write(f.linebreak())
for linkedpage in links:
request.write(
f.rawHTML("%s%s " %
(Page(request, linkedpage).link_to(request),
",."[linkedpage == links[-1]])))
request.write(f.paragraph(0))
def filterReadableHits(self, hits):
""" Filter out hits the user many not see """
userMayRead = self.request.user.may.read
for pagename in hits.keys():
page = Page(self.request, pagename)
if page.exists() and userMayRead(pagename):
continue
del hits[pagename]
def xmlrpc_getPageInfoVersion(self, pagename, rev):
"""
Return page information for specific revision
@param pagename: the name of the page (utf-8)
@param rev: revision to get info about (int)
@rtype: dict
@return: page information
* name (string): the canonical page name, UTF-8.
* lastModified (date): Last modification date, UTC.
* author (string): author name, UTF-8.
* version (int): current version
"""
pn = self._instr(pagename)
# User may read this page?
if not self.request.user.may.read(pn):
return self.notAllowedFault()
if rev is not None:
page = Page(self.request, pn, rev=rev)
else:
page = Page(self.request, pn)
rev = page.current_rev()
# Non existing page?
if not page.exists():
return self.noSuchPageFault()
# Get page info
edit_info = page.edit_info()
if not edit_info:
return self.noLogEntryFault()
mtime = wikiutil.version2timestamp(long(
edit_info['timestamp'])) # must be long for py 2.2.x
gmtuple = tuple(time.gmtime(mtime))
version = rev # our new rev numbers: 1,2,3,4,....
#######################################################################
# BACKWARDS COMPATIBILITY CODE - remove when 1.2.x is regarded stone age
# as we run a feed for BadContent on MoinMaster, we want to stay
# compatible here for a while with 1.2.x moins asking us for BadContent
# 1.3 uses the lastModified field for checking for updates, so it
# should be no problem putting the old UNIX timestamp style of version
# number in the version field
if self.request.cfg.sitename == 'MoinMaster' and pagename == 'BadContent':
version = int(mtime)
#######################################################################
return {
'name': self._outstr(page.page_name),
'lastModified': xmlrpclib.DateTime(gmtuple),
'author': self._outstr(edit_info['editor']),
'version': version,
}
def collectpackage(self, pagelist, fileobject, pkgname="", include_attachments=False):
""" Expects a list of pages as an argument, and fileobject to be an open
file object, which a zipfile will get written to.
@param pagelist: pages to package
@param fileobject: open file object to write to
@param pkgname: optional file name, to prevent self packaging
@rtype: string or None
@return: error message, if one happened
@rtype: boolean
@param include_attachments: True if you want attachments collected
"""
_ = self.request.getText
COMPRESSION_LEVEL = zipfile.ZIP_DEFLATED
pages = []
for pagename in pagelist:
pagename = wikiutil.normalize_pagename(pagename, self.request.cfg)
if pagename:
page = Page(self.request, pagename)
if page.exists() and self.request.user.may.read(pagename):
pages.append(page)
if not pages:
return (_('No pages like "%s"!') % wikiutil.escape(pagelist))
# Set zipfile output
zf = zipfile.ZipFile(fileobject, "w", COMPRESSION_LEVEL)
cnt = 0
userid = user.getUserIdentification(self.request)
script = [packLine(['MoinMoinPackage', '1']), ]
for page in pages:
cnt += 1
files = _get_files(self.request, page.page_name)
script.append(packLine(["AddRevision", str(cnt), page.page_name, userid, "Created by the PackagePages action."]))
timestamp = wikiutil.version2timestamp(page.mtime_usecs())
# avoid getting strange exceptions from zipfile in case of pre-1980 timestamps
nineteeneighty = (10 * 365 + 3) * 24 * 3600 # 1970 + 10y + 3d
timestamp = max(nineteeneighty, timestamp) # zip can not store timestamps before 1980
zi = zipfile.ZipInfo(filename=str(cnt), date_time=datetime.fromtimestamp(timestamp).timetuple()[:6])
zi.compress_type = COMPRESSION_LEVEL
zf.writestr(zi, page.get_raw_body().encode("utf-8"))
if include_attachments:
for attname in files:
if attname != pkgname:
cnt += 1
zipname = "%d_attachment" % cnt
script.append(packLine(["AddAttachment", zipname, attname, page.page_name, userid, "Created by the PackagePages action."]))
filename = AttachFile.getFilename(self.request, page.page_name, attname)
zf.write(filename, zipname)
script += [packLine(['Print', 'Thank you for using PackagePages!'])]
zf.writestr(MOIN_PACKAGE_FILE, u"\n".join(script).encode("utf-8"))
zf.close()
def load_template(request, name):
if not request.user.may.read(name):
raise InviteException("You are not allowed to read template page '%s'." % name)
page = Page(request, name)
if not page.exists():
raise InviteException("Template page '%s' does not exist." % name)
return page.get_raw_body()
def handle_action(context, pagename, action_name='show'):
""" Actual dispatcher function for non-XMLRPC actions.
Also sets up the Page object for this request, normalizes and
redirects to canonical pagenames and checks for non-allowed
actions.
"""
_ = context.getText
cfg = context.cfg
# pagename could be empty after normalization e.g. '///' -> ''
# Use localized FrontPage if pagename is empty
if not pagename:
context.page = wikiutil.getFrontPage(context)
else:
context.page = Page(context, pagename)
if '_' in pagename and not context.page.exists():
pagename = pagename.replace('_', ' ')
page = Page(context, pagename)
if page.exists():
url = page.url(context)
return context.http_redirect(url)
msg = None
# Complain about unknown actions
if not action_name in get_names(cfg):
msg = _("Unknown action %(action_name)s.") % {
'action_name': wikiutil.escape(action_name), }
# Disallow non available actions
elif action_name[0].isupper() and not action_name in \
get_available_actions(cfg, context.page, context.user):
msg = _("You are not allowed to do %(action_name)s on this page.") % {
'action_name': wikiutil.escape(action_name), }
if not context.user.valid:
# Suggest non valid user to login
msg += " " + _("Login and try again.")
if msg:
context.theme.add_msg(msg, "error")
context.page.send_page()
# Try action
else:
from MoinMoin import action
handler = action.getHandler(context, action_name)
if handler is None:
msg = _("You are not allowed to do %(action_name)s on this page.") % {
'action_name': wikiutil.escape(action_name), }
if not context.user.valid:
# Suggest non valid user to login
msg += " " + _("Login and try again.")
context.theme.add_msg(msg, "error")
context.page.send_page()
else:
handler(context.page.page_name, context)
return context
def xmlrpc_getPageInfoVersion(self, pagename, rev):
"""
Return page information for specific revision
@param pagename: the name of the page (utf-8)
@param rev: revision to get info about (int)
@rtype: dict
@return: page information
* name (string): the canonical page name, UTF-8.
* lastModified (date): Last modification date, UTC.
* author (string): author name, UTF-8.
* version (int): current version
"""
pn = self._instr(pagename)
# User may read this page?
if not self.request.user.may.read(pn):
return self.notAllowedFault()
if rev is not None:
page = Page(self.request, pn, rev=rev)
else:
page = Page(self.request, pn)
rev = page.current_rev()
# Non existing page?
if not page.exists():
return self.noSuchPageFault()
# Get page info
edit_info = page.edit_info()
if not edit_info:
return self.noLogEntryFault()
mtime = wikiutil.version2timestamp(long(edit_info['timestamp'])) # must be long for py 2.2.x
gmtuple = tuple(time.gmtime(mtime))
version = rev # our new rev numbers: 1,2,3,4,....
#######################################################################
# BACKWARDS COMPATIBILITY CODE - remove when 1.2.x is regarded stone age
# as we run a feed for BadContent on MoinMaster, we want to stay
# compatible here for a while with 1.2.x moins asking us for BadContent
# 1.3 uses the lastModified field for checking for updates, so it
# should be no problem putting the old UNIX timestamp style of version
# number in the version field
if self.request.cfg.sitename == 'MoinMaster' and pagename == 'BadContent':
version = int(mtime)
#######################################################################
return {
'name': self._outstr(page.page_name),
'lastModified': xmlrpclib.DateTime(gmtuple),
'author': self._outstr(edit_info['editor']),
'version': version,
}
def handle_action(context, pagename, action_name='show'):
""" Actual dispatcher function for non-XMLRPC actions.
Also sets up the Page object for this request, normalizes and
redirects to canonical pagenames and checks for non-allowed
actions.
"""
_ = context.getText
cfg = context.cfg
# pagename could be empty after normalization e.g. '///' -> ''
# Use localized FrontPage if pagename is empty
if not pagename:
context.page = wikiutil.getFrontPage(context)
else:
context.page = Page(context, pagename)
if '_' in pagename and not context.page.exists():
pagename = pagename.replace('_', ' ')
page = Page(context, pagename)
if page.exists():
url = page.url(context)
return context.http_redirect(url)
msg = None
# Complain about unknown actions
if not action_name in get_names(cfg):
msg = _("Unknown action %(action_name)s.") % {
'action_name': wikiutil.escape(action_name), }
# Disallow non available actions
elif action_name[0].isupper() and not action_name in \
get_available_actions(cfg, context.page, context.user):
msg = _("You are not allowed to do %(action_name)s on this page.") % {
'action_name': wikiutil.escape(action_name), }
if not context.user.valid:
# Suggest non valid user to login
msg += " " + _("Login and try again.")
if msg:
context.theme.add_msg(msg, "error")
context.page.send_page()
# Try action
else:
from MoinMoin import action
handler = action.getHandler(context, action_name)
if handler is None:
msg = _("You are not allowed to do %(action_name)s on this page.") % {
'action_name': wikiutil.escape(action_name), }
if not context.user.valid:
# Suggest non valid user to login
msg += " " + _("Login and try again.")
context.theme.add_msg(msg, "error")
context.page.send_page()
else:
handler(context.page.page_name, context)
return context
def filterReadableHits(self, hits):
""" Filter out hits the user many not see """
userMayRead = self.request.user.may.read
for pagename in hits.keys(
): # we need .keys() because we modify the dict
page = Page(self.request, pagename)
if page.exists() and userMayRead(pagename):
continue
del hits[pagename]
def load_template(request, name):
if not request.user.may.read(name):
raise InviteException(
"You are not allowed to read template page '%s'." % name)
page = Page(request, name)
if not page.exists():
raise InviteException("Template page '%s' does not exist." % name)
return page.get_raw_body()
def _index_page(self, request, connection, pagename, mode="update"):
""" Index a page.
Index all revisions (if wanted by configuration) and all attachments.
@param request: request suitable for indexing
@param connection: the Indexer connection object
@param pagename: a page name
@param mode: 'add' = just add, no checks
'update' = check if already in index and update if needed (mtime)
"""
page = Page(request, pagename)
revlist = page.getRevList() # recent revs first, does not include deleted revs
logging.debug("indexing page %r, %d revs found" % (pagename, len(revlist)))
if not revlist:
# we have an empty revision list, that means the page is not there any more,
# likely it (== all of its revisions, all of its attachments) got either renamed or nuked
wikiname = request.cfg.interwikiname or u"Self"
sc = self.get_search_connection()
docs_to_delete = sc.get_all_documents_with_fields(wikiname=wikiname, pagename=pagename)
# any page rev, any attachment
sc.close()
for doc in docs_to_delete:
connection.delete(doc.id)
logging.debug("page %s (all revs, all attachments) removed from xapian index" % pagename)
else:
if request.cfg.xapian_index_history:
index_revs, remove_revs = revlist, []
else:
if page.exists(): # is current rev not deleted?
index_revs, remove_revs = revlist[:1], revlist[1:]
else:
index_revs, remove_revs = [], revlist
for revno in index_revs:
updated = self._index_page_rev(request, connection, pagename, revno, mode=mode)
logging.debug("updated page %r rev %d (updated==%r)" % (pagename, revno, updated))
if not updated:
# we reached the revisions that are already present in the index
break
for revno in remove_revs:
# XXX remove_revs can be rather long for pages with many revs and
# XXX most page revs usually will be already deleted. optimize?
self._remove_page_rev(request, connection, pagename, revno)
logging.debug("removed page %r rev %d" % (pagename, revno))
from MoinMoin.action import AttachFile
for attachmentname in AttachFile._get_files(request, pagename):
self._index_attachment(request, connection, pagename, attachmentname, mode)
def execute(macro, args):
request = macro.request
# get number of wanted links
try:
links = max(int(args), 1)
except StandardError:
links = 1
# Get full page unfiltered page list - very fast!
all_pages = request.rootpage.getPageList(user='', exists=0)
# Now select random page from the full list, and if it exists and we
# can read it, save.
pages = []
found = 0
while found < links and all_pages:
# Take one random page from the list
pagename = random.choice(all_pages)
all_pages.remove(pagename)
# Filter out deleted pages or pages the user may not read.
page = Page(request, pagename)
if page.exists() and request.user.may.read(pagename):
pages.append(pagename)
found += 1
if not pages:
return ''
f = macro.formatter
# return a single page link
if links == 1:
name = pages[0]
return (f.pagelink(1, name, generated=1) +
f.text(name) +
f.pagelink(0, name))
# return a list of page links
pages.sort()
result = []
write = result.append
write(f.bullet_list(1))
for name in pages:
write(f.listitem(1))
write(f.pagelink(1, name, generated=1))
write(f.text(name))
write(f.pagelink(0, name))
write(f.listitem(0))
write(f.bullet_list(0))
result = ''.join(result)
return result
def move_file(request, pagename, new_pagename, attachment, new_attachment):
_ = request.getText
newpage = Page(request, new_pagename)
if newpage.exists(includeDeleted=1) and request.user.may.write(
new_pagename) and request.user.may.delete(pagename):
new_attachment_path = os.path.join(
getAttachDir(request, new_pagename, create=1),
new_attachment).encode(config.charset)
attachment_path = os.path.join(getAttachDir(request, pagename),
attachment).encode(config.charset)
if os.path.exists(new_attachment_path):
upload_form(
pagename,
request,
msg=
_("Attachment '%(new_pagename)s/%(new_filename)s' already exists."
) % {
'new_pagename': new_pagename,
'new_filename': new_attachment
})
return
if new_attachment_path != attachment_path:
filesize = os.path.getsize(attachment_path)
filesys.rename(attachment_path, new_attachment_path)
_addLogEntry(request, 'ATTDEL', pagename, attachment)
event = FileRemovedEvent(request, pagename, attachment, filesize)
send_event(event)
_addLogEntry(request, 'ATTNEW', new_pagename, new_attachment)
event = FileAttachedEvent(request, new_pagename, new_attachment,
filesize)
send_event(event)
upload_form(
pagename,
request,
msg=
_("Attachment '%(pagename)s/%(filename)s' moved to '%(new_pagename)s/%(new_filename)s'."
) % {
'pagename': pagename,
'filename': attachment,
'new_pagename': new_pagename,
'new_filename': new_attachment
})
else:
upload_form(pagename, request, msg=_("Nothing changed"))
else:
upload_form(
pagename,
request,
msg=
_("Page '%(new_pagename)s' does not exist or you don't have enough rights."
) % {'new_pagename': new_pagename})
def format_page_edits(macro, line):
request = macro.request
_ = request.getText
pagename = line.pagename
rev = int(line.rev)
page = Page(request, pagename)
html_link = u''
if not page.exists():
revbefore = rev - 1
if revbefore and page.exists(rev=revbefore, domain='standard'):
# indicate page was deleted and show diff to last existing revision of it
html_link = page.link_to_raw(request, u'(削除) %s' % pagename,
querystr={'action': 'diff'}, rel='nofollow')
else:
html_link = pagename
else:
html_link = page.link_to(request, pagename, rel='nofollow')
return u'<li>%s</li>' % html_link
def _get_page_body(self, page, this_page):
"""Return the content of a named page; accepts relative pages"""
if page.startswith("/") or len(page) == 0:
page = this_page + page
p = Page(self.request, page)
if not p.exists():
raise RuntimeError("Page '%s' not found" % page)
else:
return p.get_raw_body().split('\n')
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):
"""
Handle action=IntraFarmCopy
"""
if not request.user.may.read(pagename):
Page(request, pagename).send_page()
return
# Which local farm wiki - assume team for now
to_wiki_url = COPY_TO_WIKI_URL
# New page name
to_wiki_pagename = '%s%s' % (COPY_TO_PREFIX, pagename)
# create page at local wiki if it doesn't exist
to_request = ScriptContext(to_wiki_url)
# login this user remotely
to_uid = user.getUserId(to_request, request.user.name)
to_user = user.User(to_request, id=to_uid, name=request.user.name, password=request.user.password, auth_method="moin")
to_request.user = to_user
try:
page = Page(to_request, to_wiki_pagename)
except:
return action_error(u'Error accessing destination page')
if not page.exists():
pe = PageEditor(to_request, to_wiki_pagename)
# make initial revision pointer to original
try:
pe.saveText(u'[[%s:%s]]' % (request.cfg.interwikiname, pagename), 0, comment="Automated IntraFarmCopy pointing to original page")
except pe.Unchanged:
return action_error(u'Could not save initial page')
except pe.AccessDenied:
return action_error(u'Could not acquire credentials')
# make next revision content of this page
try:
pe.saveText(Page(request, pagename).get_raw_body(), 0, comment="Automated IntraFarmCopy importing contents from original page at [[%s:%s]]" % (request.cfg.interwikiname, pagename))
except pe.Unchanged:
return action_error(u'Could not save destination page text')
# send attachments over
attachments = AttachFile._get_files(request, pagename)
for attachname in attachments:
filename = AttachFile.getFilename(request, pagename, attachname)
if not os.path.isfile(filename):
continue
to_filename = AttachFile.getFilename(to_request, to_wiki_pagename, attachname)
shutil.copyfile(filename, to_filename)
AttachFile._addLogEntry(to_request, 'ATTNEW', to_wiki_pagename, attachname)
# redirect user to view new page in other wiki
request.http_redirect('%s%s' % (to_wiki_url, to_wiki_pagename))
return
else:
return action_error(u'Destination page already exists!')
def createSyncPage(self, page_name):
normalised_name = normalise_pagename(page_name, self.prefix)
if normalised_name is None:
return None
page = Page(self.request, page_name)
revno = page.get_real_rev()
if revno == 99999999: # I love sane in-band signalling
return None
return SyncPage(normalised_name,
local_rev=revno,
local_name=page_name,
local_deleted=not page.exists())
def prepend_to_wiki_page(self, page_uri, heading, content):
old_content = ''
wiki_page = Page(self.request, page_uri)
#if exists, get old page content
if(wiki_page.exists()):
old_content = wiki_page.get_raw_body()
pagecontent = """\
== %(heading)s ==
%(content)s
%(old_content)s
""" % {'heading': heading, 'content': content, 'old_content': old_content }
return(PageEditor(self.request, page_uri).saveText(pagecontent, 0))
def rollback_local_change(): # YYY direct local access
comment = u"Wikisync rollback"
rev = new_local_rev - 1
revstr = '%08d' % rev
oldpg = Page(self.request, sp.local_name, rev=rev)
pg = PageEditor(self.request, sp.local_name)
if not oldpg.exists():
pg.deletePage(comment)
else:
try:
savemsg = pg.saveText(oldpg.get_raw_body(), 0, comment=comment, extra=revstr, action="SAVE/REVERT")
except PageEditor.Unchanged:
pass
return sp.local_name
def general(page, pagename, request):
_ = request.getText
f = request.formatter
request.write(f.heading(1, 1),
f.text(_('General Information')),
f.heading(0, 1))
request.write(f.paragraph(1),
f.text(_("Page size: %d") % page.size()),
f.paragraph(0))
from MoinMoin.support.python_compatibility import hash_new
digest = hash_new('sha1', page.get_raw_body().encode(config.charset)).hexdigest().upper()
request.write(f.paragraph(1),
f.rawHTML('%(label)s <tt>%(value)s</tt>' % {
'label': _("SHA digest of this page's content is:"),
'value': digest, }),
f.paragraph(0))
# show attachments (if allowed)
attachment_info = action.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(f.paragraph(1))
request.write(f.text(_('The following users subscribed to this page:')))
for lang in subscribers:
request.write(f.linebreak(), f.text('[%s] ' % lang))
for user in subscribers[lang]:
# do NOT disclose email addr, only WikiName
userhomepage = Page(request, user.name)
if userhomepage.exists():
request.write(f.rawHTML(userhomepage.link_to(request) + ' '))
else:
request.write(f.text(user.name + ' '))
request.write(f.paragraph(0))
# show links
links = page.getPageLinks(request)
if links:
request.write(f.paragraph(1))
request.write(f.text(_('This page links to the following pages:')))
request.write(f.linebreak())
for linkedpage in links:
request.write(f.rawHTML("%s%s " % (Page(request, linkedpage).link_to(request), ",."[linkedpage == links[-1]])))
request.write(f.paragraph(0))
def _load_template(self, variable, default):
if not variable and default:
name = default
else:
name = getattr(self.request.cfg, variable, default)
if not self.request.user.may.read(name):
raise InviteException("You are not allowed to read template page '%s'." % name)
page = Page(self.request, name)
if not page.exists():
raise InviteException("Template page '%s' does not exist." % name)
return page.get_raw_body()
def rollback_local_change(): # YYY direct local access
comment = u"Wikisync rollback"
rev = new_local_rev - 1
revstr = '%08d' % rev
oldpg = Page(self.request, sp.local_name, rev=rev)
pg = PageEditor(self.request, sp.local_name)
if not oldpg.exists():
pg.deletePage(comment)
else:
try:
savemsg = pg.saveText(oldpg.get_raw_body(), 0, comment=comment, extra=revstr, action="SAVE/REVERT")
except PageEditor.Unchanged:
pass
return sp.local_name
def macro_RandomPage(macro, links=1):
request = macro.request
links = max(links, 1) # at least 1 link
# Get full page unfiltered page list - very fast!
all_pages = request.rootpage.getPageList(user='', exists=0)
# Now select random page from the full list, and if it exists and we
# can read it, save.
pages = []
found = 0
while found < links and all_pages:
# Take one random page from the list
pagename = random.choice(all_pages)
all_pages.remove(pagename)
# Filter out deleted pages or pages the user may not read.
page = Page(request, pagename)
if page.exists() and request.user.may.read(pagename):
pages.append(pagename)
found += 1
if not pages:
return ''
f = macro.formatter
# return a single page link
if links == 1:
name = pages[0]
return (f.pagelink(1, name, generated=1) + f.text(name) +
f.pagelink(0, name))
# return a list of page links
pages.sort()
result = []
write = result.append
write(f.bullet_list(1))
for name in pages:
write(f.listitem(1))
write(f.pagelink(1, name, generated=1))
write(f.text(name))
write(f.pagelink(0, name))
write(f.listitem(0))
write(f.bullet_list(0))
result = ''.join(result)
return result
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()
def testSaveAbort(self):
"""Test if saveText() is interrupted if PagePreSave event handler returns Abort"""
def handler(event):
from MoinMoin.events import Abort
return Abort("This is just a test")
pagename = u'AutoCreatedMoinMoinTemporaryTestPageFortestSave'
testtext = u'ThisIsSomeStupidTestPageText!'
self.request.cfg.event_handlers = [handler]
page = Page(self.request, pagename)
if page.exists():
deleter = PageEditor(self.request, pagename)
deleter.deletePage()
editor = PageEditor(self.request, pagename)
editor.saveText(testtext, 0)
print "PageEditor can't save a page if Abort is returned from PreSave event handlers"
page = Page(self.request, pagename)
assert page.body != testtext
def execute(macro, args):
formatter = macro.formatter
macro.request.page.formatter = formatter
request = macro.request
_ = request.getText
if not cairo_found:
return formatter.text(_(\
"ERROR: Cairo Python extensions not installed. " +\
"Not performing layout.")) + formatter.linebreak()
urlargs, macro_args = radarchart_args(args)
pagename = request.page.page_name
# The first page mentioned will be the page of the chart
for arg in macro_args.split(','):
page = Page(request, arg)
if page.exists():
pagename = arg
break
return u'<div class="metaradarchart">' + \
u'<img src="%s">' % url_construct(request, urlargs, pagename) + \
u'</div>'
def execute(macro, text):
request = macro.request
formatter = macro.formatter
_ = request.getText
# return immediately if getting links for the current page
if request.mode_getpagelinks:
return ''
currentyear, currentmonth, currentday, h, m, s, wd, yd, ds = request.user.getTime(
time.time())
thispage = formatter.page.page_name
# does the url have calendar params (= somebody has clicked on prev/next links in calendar) ?
if 'calparms' in macro.request.args:
has_calparms = 1 # yes!
text2 = macro.request.args['calparms']
cparmpagename, cparmyear, cparmmonth, cparmoffset, cparmoffset2, cparmheight6, cparmanniversary, cparmtemplate = \
parseargs(request, text2, thispage, currentyear, currentmonth, 0, 0, False, False, u'')
# Note: cparmheight6 and cparmanniversary are not used, they are just there
# to have a consistent parameter string in calparms and macro args
else:
has_calparms = 0
if text is None: # macro call without parameters
text = u''
# parse and check arguments
parmpagename, parmyear, parmmonth, parmoffset, parmoffset2, parmheight6, anniversary, parmtemplate = \
parseargs(request, text, thispage, currentyear, currentmonth, 0, 0, False, False, u'')
# does url have calendar params and is THIS the right calendar to modify (we can have multiple
# calendars on the same page)?
#if has_calparms and (cparmpagename,cparmyear,cparmmonth,cparmoffset) == (parmpagename,parmyear,parmmonth,parmoffset):
# move all calendars when using the navigation:
if has_calparms and cparmpagename == parmpagename:
year, month = yearmonthplusoffset(parmyear, parmmonth,
parmoffset + cparmoffset2)
parmoffset2 = cparmoffset2
parmtemplate = cparmtemplate
else:
year, month = yearmonthplusoffset(parmyear, parmmonth, parmoffset)
if request.isSpiderAgent and abs(currentyear - year) > 1:
return '' # this is a bot and it didn't follow the rules (see below)
if currentyear == year:
attrs = {}
else:
attrs = {
'rel': 'nofollow'
} # otherwise even well-behaved bots will index forever
# get the calendar
monthcal = calendar.monthcalendar(year, month)
# european / US differences
months = ('January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December')
# Set things up for Monday or Sunday as the first day of the week
if calendar.firstweekday() == calendar.MONDAY:
wkend = (5, 6)
wkdays = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')
if calendar.firstweekday() == calendar.SUNDAY:
wkend = (0, 6)
wkdays = ('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat')
colorstep = 85
p = Page(request, thispage)
qpagenames = '*'.join(
[wikiutil.quoteWikinameURL(pn) for pn in parmpagename])
qtemplate = wikiutil.quoteWikinameURL(parmtemplate)
querystr = "calparms=%%s,%d,%d,%d,%%d,,,%%s" % (parmyear, parmmonth,
parmoffset)
prevlink = p.url(request,
querystr % (qpagenames, parmoffset2 - 1, qtemplate))
nextlink = p.url(request,
querystr % (qpagenames, parmoffset2 + 1, qtemplate))
prevylink = p.url(request,
querystr % (qpagenames, parmoffset2 - 12, qtemplate))
nextylink = p.url(request,
querystr % (qpagenames, parmoffset2 + 12, qtemplate))
prevmonth = formatter.url(1, prevlink, 'cal-link', **
attrs) + '<' + formatter.url(0)
nextmonth = formatter.url(1, nextlink, 'cal-link', **
attrs) + '>' + formatter.url(0)
prevyear = formatter.url(1, prevylink, 'cal-link', **
attrs) + '<<' + formatter.url(0)
nextyear = formatter.url(1, nextylink, 'cal-link', **
attrs) + '>>' + formatter.url(0)
if parmpagename != [thispage]:
pagelinks = ''
r, g, b = (255, 0, 0)
l = len(parmpagename[0])
steps = len(parmpagename)
maxsteps = (255 / colorstep)
if steps > maxsteps:
steps = maxsteps
chstep = int(l / steps)
st = 0
while st < l:
ch = parmpagename[0][st:st + chstep]
r, g, b = cliprgb(r, g, b)
link = Page(request, parmpagename[0]).link_to(
request,
ch,
rel='nofollow',
style=
'background-color:#%02x%02x%02x;color:#000000;text-decoration:none'
% (r, g, b))
pagelinks = pagelinks + link
r, g, b = (r, g + colorstep, b)
st = st + chstep
r, g, b = (255 - colorstep, 255, 255 - colorstep)
for page in parmpagename[1:]:
link = Page(request, page).link_to(
request,
page,
rel='nofollow',
style=
'background-color:#%02x%02x%02x;color:#000000;text-decoration:none'
% (r, g, b))
pagelinks = pagelinks + '*' + link
showpagename = ' %s<BR>\n' % pagelinks
else:
showpagename = ''
if calendar.firstweekday() == calendar.SUNDAY:
resth1 = ' <th colspan="7" class="cal-header">\n' \
'%s' \
' %s %s <b> %s %s</b> %s\n %s\n' \
' </th>\n' % (showpagename, prevyear, prevmonth, months[month-1], str(year), nextmonth, nextyear)
if calendar.firstweekday() == calendar.MONDAY:
resth1 = ' <th colspan="7" class="cal-header">\n' \
'%s' \
' %s %s <b> %s / %s</b> %s\n %s\n' \
' </th>\n' % (showpagename, prevyear, prevmonth, str(year), month, nextmonth, nextyear)
restr1 = ' <tr>\n%s </tr>\n' % resth1
r7 = range(7)
restd2 = []
for wkday in r7:
wday = _(wkdays[wkday])
if wkday in wkend:
cssday = "cal-weekend"
else:
cssday = "cal-workday"
restd2.append(' <td class="%s">%s</td>\n' % (cssday, wday))
restr2 = ' <tr>\n%s </tr>\n' % "".join(restd2)
if parmheight6:
while len(monthcal) < 6:
monthcal = monthcal + [[0, 0, 0, 0, 0, 0, 0]]
maketip_js = []
restrn = []
for week in monthcal:
restdn = []
for wkday in r7:
day = week[wkday]
if not day:
restdn.append(' <td class="cal-invalidday"> </td>\n')
else:
page = parmpagename[0]
if anniversary:
link = "%s/%02d-%02d" % (page, month, day)
else:
link = "%s/%4d-%02d-%02d" % (page, year, month, day)
daypage = Page(request, link)
if daypage.exists() and request.user.may.read(link):
csslink = "cal-usedday"
query = {}
r, g, b, u = (255, 0, 0, 1)
daycontent = daypage.get_raw_body()
header1_re = re.compile(r'^\s*=\s(.*)\s=$',
re.MULTILINE) # re.UNICODE
titletext = []
for match in header1_re.finditer(daycontent):
if match:
title = match.group(1)
title = wikiutil.escape(title).replace("'", "\\'")
titletext.append(title)
tipname_unescaped = link.replace("'", "\\'")
link = wikiutil.escape(link).replace("'", "\\'")
tipname = link
tiptitle = link
tiptext = '<br>'.join(titletext)
maketip_js.append("maketip('%s','%s','%s');" %
(tipname, tiptitle, tiptext))
attrs = {
'onMouseOver': "tip('%s')" % tipname_unescaped,
'onMouseOut': "untip()"
}
else:
csslink = "cal-emptyday"
if parmtemplate:
query = {'action': 'edit', 'template': parmtemplate}
else:
query = {}
r, g, b, u = (255, 255, 255, 0)
if wkday in wkend:
csslink = "cal-weekend"
attrs = {'rel': 'nofollow'}
for otherpage in parmpagename[1:]:
otherlink = "%s/%4d-%02d-%02d" % (otherpage, year, month,
day)
otherdaypage = Page(request, otherlink)
if otherdaypage.exists():
csslink = "cal-usedday"
if u == 0:
r, g, b = (r - colorstep, g, b - colorstep)
else:
r, g, b = (r, g + colorstep, b)
r, g, b = cliprgb(r, g, b)
style = 'background-color:#%02x%02x%02x' % (r, g, b)
fmtlink = formatter.url(1, daypage.url(request,
query), csslink, **
attrs) + str(day) + formatter.url(0)
if day == currentday and month == currentmonth and year == currentyear:
cssday = "cal-today"
fmtlink = "<b>%s</b>" % fmtlink # for browser with CSS probs
else:
cssday = "cal-nottoday"
restdn.append(' <td style="%s" class="%s">%s</td>\n' %
(style, cssday, fmtlink))
restrn.append(' <tr>\n%s </tr>\n' % "".join(restdn))
restable = '<table border="2" cellspacing="2" cellpadding="2">\n<col width="14%%" span="7">%s%s%s</table>\n'
restable = restable % (restr1, restr2, "".join(restrn))
if maketip_js:
tip_js = '''<script language="JavaScript" type="text/javascript">
<!--
%s
// -->
</script>
''' % '\n'.join(maketip_js)
else:
tip_js = ''
result = """\
<script type="text/javascript" src="%s/common/js/infobox.js"></script>
<div id="%s" style="position:absolute; visibility:hidden; z-index:20; top:-999em; left:0px;"></div>
%s%s
""" % (request.cfg.url_prefix_static, formatter.make_id_unique('infodiv'),
tip_js, restable)
return formatter.rawHTML(result)
def visit_reference(self, node):
"""
Pass links to MoinMoin to get the correct wiki space url. Extract
the url and pass it on to the html4css1 writer to handle. Inline
images are also handled by visit_image. Not sure what the "drawing:"
link scheme is used for, so for now it is handled here.
Also included here is a hack to allow MoinMoin macros. This routine
checks for a link which starts with "<<". This link is passed to the
MoinMoin formatter and the resulting markup is inserted into the
document in the place of the original link reference.
"""
if 'refuri' in node.attributes:
refuri = node['refuri']
prefix = ''
link = refuri
if ':' in refuri:
prefix, link = refuri.lstrip().split(':', 1)
# First see if MoinMoin should handle completely. Exits through add_wiki_markup.
if refuri.startswith('<<') and refuri.endswith('>>'): # moin macro
self.process_wiki_text(refuri)
self.wiki_text = self.fixup_wiki_formatting(self.wiki_text)
self.add_wiki_markup()
if prefix == 'drawing':
self.process_wiki_text("[[%s]]" % refuri)
self.wiki_text = self.fixup_wiki_formatting(self.wiki_text)
self.add_wiki_markup()
# From here down, all links are handled by docutils (except
# missing attachments), just fixup node['refuri'].
if prefix == 'attachment':
if not AttachFile.exists(self.request,
self.request.page.page_name, link):
# Attachment doesn't exist, give to MoinMoin to insert upload text.
self.process_wiki_text("[[%s]]" % refuri)
self.wiki_text = self.fixup_wiki_formatting(self.wiki_text)
self.add_wiki_markup()
# Attachment exists, just get a link to it.
node['refuri'] = AttachFile.getAttachUrl(
self.request.page.page_name, link, self.request)
if not [
i for i in node.children
if i.__class__ == docutils.nodes.image
]:
node['classes'].append(prefix)
elif prefix == 'wiki':
wiki_name, page_name = wikiutil.split_interwiki(link)
wikitag, wikiurl, wikitail, err = wikiutil.resolve_interwiki(
self.request, wiki_name, page_name)
wikiurl = wikiutil.mapURL(self.request, wikiurl)
node['refuri'] = wikiutil.join_wiki(wikiurl, wikitail)
# Only add additional class information if the reference does
# not have a child image (don't want to add additional markup
# for images with targets).
if not [
i for i in node.children
if i.__class__ == docutils.nodes.image
]:
node['classes'].append('interwiki')
elif prefix == 'javascript':
# is someone trying to do XSS with javascript?
node['refuri'] = 'javascript:alert("it does not work")'
elif prefix != '':
# Some link scheme (http, file, https, mailto, etc.), add class
# information if the reference doesn't have a child image (don't
# want additional markup for images with targets).
# Don't touch the refuri.
if not [
i for i in node.children
if i.__class__ == docutils.nodes.image
]:
node['classes'].append(prefix)
else:
# Default case - make a link to a wiki page.
pagename, anchor = wikiutil.split_anchor(refuri)
page = Page(
self.request,
wikiutil.AbsPageName(self.formatter.page.page_name,
pagename))
node['refuri'] = page.url(self.request, anchor=anchor)
if not page.exists():
node['classes'].append('nonexistent')
html4css1.HTMLTranslator.visit_reference(self, node)
def execute(pagename, request):
form = values_to_form(request.values)
util = form.get('util', [None])[0]
if util == "format":
txt = form.get('text', [None])[0]
request.write(format_wikitext(request, txt))
elif util == "getTemplate":
template = form.get('name', [None])[0]
template_page = wikiutil.unquoteWikiname(template)
if request.user.may.read(template_page):
Page(request, template_page).send_raw()
elif util == "newPage":
page = form.get('page', [None])[0]
content = form.get('content', [""])[0]
request.content_type = "application/json"
if request.environ['REQUEST_METHOD'] != 'POST':
return
if not page:
msg = "Page name not defined!"
json.dump(dict(status="error", msg=msg), request)
return
if not request.user.may.write(page):
msg = "You are not allowed to edit this page"
json.dump(dict(status="error", msg=msg), request)
return
p = Page(request, page)
if p.exists():
msg = "Page already exists"
json.dump(dict(status="error", msg=msg), request)
return
editor = PageEditor(request, page)
msg = editor.saveText(content, p.get_real_rev())
json.dump(dict(status="ok", msg=msg), request)
elif util == "getProperties":
request.content_type = "application/json"
key = form.get('key', [''])[0]
json.dump(get_properties(request, key), request)
return
elif util == "uploadFile":
request.content_type = "application/json"
if not request.user.may.write(pagename):
msg = u"You are not allowed to edit this page!"
json.dump(dict(status="error", msg=msg), request)
request.status_code = 403
return
from MoinMoin.action.AttachFile import add_attachment, AttachmentAlreadyExists
try:
overwrite = int(form.get('overwrite', ['0'])[0])
except:
overwrite = 0
response = dict(success=list(), failed=list())
for name in request.files:
_file = request.files.get(name)
filename = _file.filename
try:
t, s = add_attachment(request,
pagename,
filename,
_file.stream,
overwrite=overwrite)
response['success'].append(filename)
except AttachmentAlreadyExists:
response['failed'].append(filename)
json.dump(response, request)
return
elif util == "getAttachments":
request.content_type = "application/json"
from MoinMoin.action.AttachFile import _get_files, getAttachUrl
files = _get_files(request, pagename)
response = []
for name in files:
response.append(
dict(url=getAttachUrl(pagename, name, request), name=name))
json.dump(response, request)
return
def do_user_browser(request):
""" Browser for SystemAdmin macro. """
_ = request.getText
groups = request.groups
data = TupleDataset()
data.columns = [
Column('name', label=_('Username')),
Column('groups', label=_('Member of Groups')),
Column('email', label=_('Email')),
Column('jabber', label=_('Jabber')),
Column('action', label=_('Action')),
]
# Iterate over users
for uid in user.getUserList(request):
account = user.User(request, uid)
account_groups = set(groups.groups_with_member(account.name))
wiki_groups = set([group for group in account_groups if isinstance(groups[group], WikiGroup)])
other_groups = list(account_groups - wiki_groups)
# First show groups that are defined in wikipages linking to it
# after show groups from other backends.
grouppage_links = ', '.join([Page(request, group_name).link_to(request) for group_name in wiki_groups] +
other_groups)
userhomepage = Page(request, account.name)
if userhomepage.exists():
namelink = userhomepage.link_to(request)
else:
namelink = wikiutil.escape(account.name)
# creates the POST data for account disable/enable
val = "1"
text=_('Disable user')
if account.disabled:
text=_('Enable user')
val = "0"
namelink += " (%s)" % _("disabled")
url = request.page.url(request)
ret = html.FORM(action=url)
ret.append(html.INPUT(type='hidden', name='action', value='userprofile'))
ticket = wikiutil.createTicket(request, action='userprofile')
ret.append(html.INPUT(type="hidden", name="ticket", value="%s" % ticket))
ret.append(html.INPUT(type='hidden', name='name', value=account.name))
ret.append(html.INPUT(type='hidden', name='key', value="disabled"))
ret.append(html.INPUT(type='hidden', name='val', value=val))
ret.append(html.INPUT(type='submit', name='userprofile', value=text))
enable_disable_link = unicode(unicode(ret))
# creates the POST data for recoverpass
url = request.page.url(request)
ret = html.FORM(action=url)
ret.append(html.INPUT(type='hidden', name='action', value='recoverpass'))
ret.append(html.INPUT(type='hidden', name='email', value=account.email))
ret.append(html.INPUT(type='hidden', name='account_sendmail', value="1"))
ret.append(html.INPUT(type='hidden', name='sysadm', value="users"))
ret.append(html.INPUT(type='submit', name='recoverpass', value=_('Mail account data')))
recoverpass_link = unicode(unicode(ret))
if account.email:
email_link = (request.formatter.url(1, 'mailto:' + account.email, css='mailto') +
request.formatter.text(account.email) +
request.formatter.url(0))
else:
email_link = ''
if account.jid:
jabber_link = (request.formatter.url(1, 'xmpp:' + account.jid, css='mailto') +
request.formatter.text(account.jid) +
request.formatter.url(0))
else:
jabber_link = ''
data.addRow((
(request.formatter.rawHTML(namelink), account.name),
request.formatter.rawHTML(grouppage_links),
email_link,
jabber_link,
recoverpass_link + enable_disable_link
))
if data:
from MoinMoin.widget.browser import DataBrowserWidget
browser = DataBrowserWidget(request)
browser.setData(data, sort_columns=[0])
return browser.render()
# No data
return ''
