def add(self,
request,
eventtype,
values=None,
add_http_info=1,
mtime_usecs=None):
""" Write an event of type `eventtype, with optional key/value
pairs appended (i.e. you have to pass a dict).
"""
if request.isSpiderAgent:
return
if mtime_usecs is None:
mtime_usecs = wikiutil.timestamp2version(time.time())
if values is None:
values = {}
if request.cfg.log_remote_addr and add_http_info:
# if cfg.log_remote_addr is False (usually for privacy reasons),
# we likely do not want to log user agent and http referer either.
for key in ['remote_addr', 'http_user_agent', 'http_referer']:
value = getattr(request, key, '')
if value:
# Save those http headers in UPPERcase
values[key.upper()] = value
# Encode values in a query string TODO: use more readable format
values = wikiutil.makeQueryString(values)
self._add(u"%d\t%s\t%s\n" % (mtime_usecs, eventtype, values))
def linkto(pagename, request, params=''):
_ = request.getText
if not request.cfg.chart_options:
return (request.formatter.sysmsg(1) +
request.formatter.text(_('Charts are not available!')) +
request.formatter.sysmsg(0))
if _debug:
return draw(pagename, request)
page = Page(request, pagename)
# Create escaped query string from dict and params
querystr = {'action': 'chart', 'type': 'pagesize'}
querystr = wikiutil.makeQueryString(querystr)
querystr = wikiutil.escape(querystr)
if params:
querystr += '&' + params
data = {'url': page.url(request, querystr)}
data.update(request.cfg.chart_options)
result = ('<img src="%(url)s" width="%(width)d" height="%(height)d"'
' alt="pagesize chart">') % data
return result
def _handle_oidreturn(self):
request = self.request
_ = request.getText
oidconsumer = consumer.Consumer(request.session,
MoinOpenIDStore(request))
query = {}
for key in request.form:
query[key] = request.form[key][0]
qstr = wikiutil.makeQueryString({'action': 'userprefs',
'handler': 'oid',
'oid.return': '1'})
return_to = request.getQualifiedURL(request.page.url(request, qstr))
info = oidconsumer.complete(query, return_to=return_to)
if info.status == consumer.FAILURE:
return 'error', _('OpenID error: %s.') % info.message
elif info.status == consumer.CANCEL:
return 'info', _('Verification canceled.')
elif info.status == consumer.SUCCESS:
if not hasattr(self.request.user, 'openids'):
request.user.openids = []
if info.identity_url in request.user.openids:
return 'error', _("OpenID is already present.")
if user.getUserIdByOpenId(request, info.identity_url):
return 'error', _("This OpenID is already used for another account.")
# all fine
request.user.openids.append(info.identity_url)
request.user.save()
return 'info', _("OpenID added successfully.")
else:
return 'error', _('OpenID failure.')
def attachUrl(request, pagename, filename=None, **kw):
# filename is not used yet, but should be used later to make a sub-item url
if kw:
qs = '?%s' % wikiutil.makeQueryString(kw, want_unicode=False)
else:
qs = ''
return "%s/%s%s" % (request.getScriptname(), wikiutil.quoteWikinameURL(pagename), qs)
def add(self, request, eventtype, values=None, add_http_info=1,
mtime_usecs=None):
""" Write an event of type `eventtype, with optional key/value
pairs appended (i.e. you have to pass a dict).
"""
cfg = request.cfg
if cfg.log_events_format == 0 or request.isSpiderAgent:
# no event logging enabled or user agent is a bot / spider
return
if mtime_usecs is None:
mtime_usecs = wikiutil.timestamp2version(time.time())
if values is None:
values = {}
if cfg.log_remote_addr and add_http_info:
# if cfg.log_remote_addr is False (usually for privacy reasons),
# we likely do not want to log user agent and http referer either.
for key in ['remote_addr', 'http_user_agent', 'http_referer']:
value = getattr(request, key, '')
if value:
# Save those http headers in UPPERcase
values[key.upper()] = value
if cfg.log_events_format == 2:
values['username'] = request.user.name
values['wikiname'] = cfg.interwikiname
values['url'] = request.url
# Encode values in a query string TODO: use more readable format
values = wikiutil.makeQueryString(values)
self._add(u"%d\t%s\t%s\n" % (mtime_usecs, eventtype, values))
def linkto(pagename, request, params=''):
_ = request.getText
if not request.cfg.chart_options:
request.formatter = Formatter(request)
return text(pagename, request, params)
if _debug:
return draw(pagename, request)
page = Page(request, pagename)
# Create escaped query string from dict and params
querystr = {'action': 'chart', 'type': 'hitcounts'}
querystr = wikiutil.makeQueryString(querystr)
querystr = wikiutil.escape(querystr)
if params:
querystr += '&' + params
# TODO: remove escape=0 in 2.0
data = {'url': page.url(request, querystr, escape=0)}
data.update(request.cfg.chart_options)
result = ('<img src="%(url)s" width="%(width)d" height="%(height)d"'
' alt="hitcounts chart">') % data
return result
def querystring(self, querydict=None):
""" Return query string, used in the page link """
if querydict is None:
querydict = {'highlight': self.query.highlight_re()}
querystr = wikiutil.makeQueryString(querydict)
#querystr = wikiutil.escape(querystr)
return querystr
def linkto(pagename, request, params=''):
_ = request.getText
if not request.cfg.chart_options:
return (request.formatter.sysmsg(1) +
request.formatter.text(_('Charts are not available!')) +
request.formatter.sysmsg(0))
if _debug:
return draw(pagename, request)
page = Page(request, pagename)
# Create escaped query string from dict and params
querystr = {'action': 'chart', 'type': 'pagesize'}
querystr = wikiutil.makeQueryString(querystr)
querystr = wikiutil.escape(querystr)
if params:
querystr += '&' + params
data = {'url': page.url(request, querystr)}
data.update(request.cfg.chart_options)
result = ('<img src="%(url)s" width="%(width)d" height="%(height)d"'
' alt="pagesize chart">') % data
return result
def make_iconlink(self, which, d):
"""
Make a link with an icon
@param which: icon id (dictionary key)
@param d: parameter dictionary
@rtype: string
@return: html link tag
"""
page_name, querystr, title, icon = self.button_table[which]
d['title'] = title % d
d['i18ntitle'] = self.request.getText(d['title'], formatted=False)
img_src = self.make_icon(icon, d)
attrs = {'rel': 'nofollow', 'title': d['i18ntitle'], }
if page_name:
page = Page(self.request, page_name % d)
else:
page = d['page']
if self.is_moin_1_5: # Moin 1.5.x
url = wikiutil.quoteWikinameURL(page.page_name)
querystr = wikiutil.makeQueryString(querystr)
if querystr:
url = '%s?%s' % (url, querystr)
html = wikiutil.link_tag(self.request, url, img_src, title="%(i18ntitle)s" % d)
else: # Moin 1.6
rev = d['rev']
if rev and which in ['raw', 'print', ]:
querystr['rev'] = str(rev)
html = page.link_to_raw(self.request, text=img_src, querystr=querystr, **attrs)
return html
def page_link(request, page, querystr):
"""Create an absolute url to a given page with optional action
@param page: a page to link to
@type page: MoinMoin.Page.Page
@param querystr: a dict passed to wikiutil.makeQueryString
"""
query = wikiutil.makeQueryString(querystr, True)
return request.getQualifiedURL(page.url(request, query))
def testMakeQueryStringFromArgument(self):
""" util.web: make query sting from argument """
tests = (
# description, arg, expected
('string unchanged', 'a=b', 'a=b'),
('string value', {'a': 'b'}, 'a=b'),
('integer value', {'a': 1}, 'a=1'),
('multiply values', {'a': 1, 'b': 2}, 'a=1&b=2'),
)
for description, arg, expected in tests:
assert wikiutil.makeQueryString(arg) == expected
def write(self, fname):
""" write complete event-log to disk """
if self.data:
f = file(fname, 'w')
for timestamp, action, kvdict in self.data:
pagename = kvdict.get('pagename')
if pagename and ('PAGE', pagename) in self.renames:
kvdict['pagename'] = self.renames[('PAGE', pagename)]
kvpairs = wikiutil.makeQueryString(kvdict)
fields = str(timestamp), action, kvpairs
line = '\t'.join(fields) + '\n'
f.write(line)
f.close()
def querystring(self, querydict=None):
""" Return query string, used in the page link
@keyword querydict: use these parameters (default: None)
"""
if querydict is None:
querydict = {}
if 'action' not in querydict or querydict['action'] == 'AttachFile':
highlight = self.query.highlight_re()
if highlight:
querydict.update({'highlight': highlight})
querystr = wikiutil.makeQueryString(querydict)
return querystr
def write(self, fname):
""" write complete event-log to disk """
if self.data:
f = file(fname, "w")
for timestamp, action, kvdict in self.data:
pagename = kvdict.get("pagename")
if pagename and ("PAGE", pagename) in self.renames:
kvdict["pagename"] = self.renames[("PAGE", pagename)]
kvpairs = wikiutil.makeQueryString(kvdict)
fields = str(timestamp), action, kvpairs
line = "\t".join(fields) + "\n"
f.write(line)
f.close()
def testMakeQueryStringFromArgumentAndKeywords(self):
""" util.web: make query sting from argument and keywords """
tests = (
# description, arg, expected
('kw ignored', 'a=1', 'a=1'),
('kw added to arg', {'a': 1}, 'a=1&b=kw'),
('kw override arg', {'a': 1, 'b': 'arg'}, 'a=1&b=kw'),
)
for description, arg, expected in tests:
# Call makeQueryString with both arg and keyword
assert wikiutil.makeQueryString(arg, b='kw') == expected
def querystring(self, querydict=None):
""" Return query string, used in the page link
@keyword querydict: use these parameters (default: None)
"""
if querydict is None:
querydict = {}
if 'action' not in querydict or querydict['action'] == 'AttachFile':
highlight = self.query.highlight_re()
if highlight:
querydict.update({'highlight': highlight})
querystr = wikiutil.makeQueryString(querydict)
return querystr
def write(self, fname):
""" write complete event-log to disk """
if self.data:
f = file(fname, 'wb') # write in binary mode, so it stays exactly as we write it, even on windows.
# the code in MoinMoin.logfile also uses binary mode and writes \n only.
for timestamp, action, kvdict in self.data:
pagename = kvdict.get('pagename')
if pagename and ('PAGE', pagename) in self.renames:
kvdict['pagename'] = self.renames[('PAGE', pagename)]
kvpairs = wikiutil.makeQueryString(kvdict)
fields = str(timestamp), action, kvpairs
line = '\t'.join(fields) + '\n'
f.write(line)
f.close()
def testMakeQueryStringFromArgument(self):
""" util.web: make query sting from argument """
tests = (
# description, arg, expected
('string unchanged', 'a=b', 'a=b'),
('string value', {'a': 'b'}, 'a=b'),
('integer value', {'a': 1}, 'a=1'),
('multiply values', {'a': 1, 'b': 2}, 'a=1&b=2'),
)
for description, arg, expected in tests:
result = wikiutil.makeQueryString(arg)
self.assertEqual(result, expected,
('%(description)s: expected "%(expected)s" '
'but got "%(result)s"') % locals())
def testMakeQueryStringFromArgumentAndKeywords(self):
""" util.web: make query sting from argument and keywords """
tests = (
# description, arg, expected
('kw ignored', 'a=1', 'a=1'),
('kw added to arg', {'a': 1}, 'a=1&b=kw'),
('kw override arg', {'a': 1, 'b': 'arg'}, 'a=1&b=kw'),
)
for description, arg, expected in tests:
# Call makeQueryString with both arg and keyword
result = wikiutil.makeQueryString(arg, b='kw')
self.assertEqual(result, expected,
('%(description)s: expected "%(expected)s" '
'but got "%(result)s"') % locals())
def write(self, fname):
""" write complete event-log to disk """
if self.data:
f = file(
fname, 'wb'
) # write in binary mode, so it stays exactly as we write it, even on windows.
# the code in MoinMoin.logfile also uses binary mode and writes \n only.
for timestamp, action, kvdict in self.data:
pagename = kvdict.get('pagename')
if pagename and ('PAGE', pagename) in self.renames:
kvdict['pagename'] = self.renames[('PAGE', pagename)]
kvpairs = wikiutil.makeQueryString(kvdict)
fields = str(timestamp), action, kvpairs
line = '\t'.join(fields) + '\n'
f.write(line)
f.close()
def testMakeQueryStringFromArgumentAndKeywords(self):
""" util.web: make query sting from argument and keywords """
tests = (
# description, arg, expected
('kw ignored', 'a=1', 'a=1'),
('kw added to arg', {
'a': 1
}, 'a=1&b=kw'),
('kw override arg', {
'a': 1,
'b': 'arg'
}, 'a=1&b=kw'),
)
for description, arg, expected in tests:
# Call makeQueryString with both arg and keyword
assert wikiutil.makeQueryString(arg, b='kw') == expected
def testMakeQueryStringFromArgument(self):
""" util.web: make query sting from argument """
tests = (
# description, arg, expected
('string unchanged', 'a=b', 'a=b'),
('string value', {
'a': 'b'
}, 'a=b'),
('integer value', {
'a': 1
}, 'a=1'),
('multiply values', {
'a': 1,
'b': 2
}, 'a=1&b=2'),
)
for description, arg, expected in tests:
assert wikiutil.makeQueryString(arg) == expected
def make_iconlink(self, which, d):
"""
Make a link with an icon
@param which: icon id (dictionary key)
@param d: parameter dictionary
@rtype: string
@return: html link tag
"""
page_name, querystr, title, icon = self.button_table[which]
d['title'] = title % d
d['i18ntitle'] = self.request.getText(d['title'], formatted=False)
img_src = self.make_icon(icon, d)
attrs = {
'rel': 'nofollow',
'title': d['i18ntitle'],
}
if page_name:
page = Page(self.request, page_name % d)
else:
page = d['page']
if self.is_moin_1_5: # Moin 1.5.x
url = wikiutil.quoteWikinameURL(page.page_name)
querystr = wikiutil.makeQueryString(querystr)
if querystr:
url = '%s?%s' % (url, querystr)
html = wikiutil.link_tag(self.request,
url,
img_src,
title="%(i18ntitle)s" % d)
else: # Moin 1.6
rev = d['rev']
if rev and which in [
'raw',
'print',
]:
querystr['rev'] = str(rev)
html = page.link_to_raw(self.request,
text=img_src,
querystr=querystr,
**attrs)
return html
def send_hotdraw(pagename, request):
_ = request.getText
now = time.time()
pubpath = request.cfg.url_prefix + "/applets/TWikiDrawPlugin"
basename = request.form['drawing'][0]
drawpath = getAttachUrl(pagename, basename + '.draw', request, escaped=1)
pngpath = getAttachUrl(pagename, basename + '.png', request, escaped=1)
querystr = {'action': 'AttachFile', 'ts': now}
querystr = wikiutil.escape(wikiutil.makeQueryString(querystr))
pagelink = '%s/%s?%s' % (request.getScriptname(), wikiutil.quoteWikinameURL(pagename), querystr)
helplink = Page(request, "HelpOnActions/AttachFile").url(request)
savelink = Page(request, pagename).url(request) # XXX include target filename param here for twisted
# request, {'savename': request.form['drawing'][0]+'.draw'}
#savelink = '/cgi-bin/dumpform.bat'
if htdocs_access(request):
timestamp = '?ts=%s' % now
else:
timestamp = '&ts=%s' % now
request.write('<h2>' + _("Edit drawing") + '</h2>')
request.write("""
<p>
<img src="%(pngpath)s%(timestamp)s">
<applet code="CH.ifa.draw.twiki.TWikiDraw.class"
archive="%(pubpath)s/twikidraw.jar" width="640" height="480">
<param name="drawpath" value="%(drawpath)s">
<param name="pngpath" value="%(pngpath)s">
<param name="savepath" value="%(savelink)s">
<param name="basename" value="%(basename)s">
<param name="viewpath" value="%(pagelink)s">
<param name="helppath" value="%(helplink)s">
<strong>NOTE:</strong> You need a Java enabled browser to edit the drawing example.
</applet>
</p>""" % {
'pngpath': pngpath, 'timestamp': timestamp,
'pubpath': pubpath, 'drawpath': drawpath,
'savelink': savelink, 'pagelink': pagelink, 'helplink': helplink,
'basename': basename
})
def add(self, request, eventtype, values=None, add_http_info=1, mtime_usecs=None):
""" Write an event of type `eventtype, with optional key/value
pairs appended (i.e. you have to pass a dict).
"""
if request.isSpiderAgent:
return
if mtime_usecs is None:
mtime_usecs = wikiutil.timestamp2version(time.time())
if values is None:
values = {}
if add_http_info:
# All these are ascii
for key in ["remote_addr", "http_user_agent", "http_referer"]:
value = getattr(request, key, "")
if value:
# Save those http headers in UPPERcase
values[key.upper()] = value
# Encode values in a query string TODO: use more readable format
values = wikiutil.makeQueryString(values, want_unicode=True)
self._add(u"%d\t%s\t%s\n" % (mtime_usecs, eventtype, values))
def elemlist(request, formatter, elems, text):
_ = request.getText
if not elems:
return
request.write(formatter.paragraph(1))
request.write(formatter.text(_("The following") + " %s " % form_escape(text)
+ _("found")))
request.write(formatter.paragraph(0))
request.write(formatter.bullet_list(1))
for elem in sorted(elems):
kwelem = {
'querystr': wikiutil.makeQueryString({'action': 'MetaSearch', 'q': elem}),
'allowed_attrs': ['title', 'href', 'class'],
'class': 'meta_search'
}
request.write(formatter.listitem(1))
request.write(formatter.pagelink(1, request.page.page_name,
request.page, **kwelem))
request.write(formatter.text(elem))
request.write(formatter.pagelink(0))
request.write(formatter.listitem(0))
request.write(formatter.bullet_list(0))
def get_multistage_continuation_url(request, auth_name, extra_fields={}):
"""get_continuation_url - return a multistage continuation URL
This function returns a URL that when loaded continues a multistage
authentication at the auth method requesting it (parameter auth_name.)
Additional fields are added to the URL from the extra_fields dict.
@param request: the Moin request
@param auth_name: name of the auth method requesting the continuation
@param extra_fields: extra GET fields to add to the URL
"""
# logically, this belongs to request, but semantically it should
# live in auth so people do auth.get_multistage_continuation_url()
fields = {'action': 'login',
'login': '******',
'stage': auth_name}
fields.update(extra_fields)
if request.page:
return request.page.url(request, querystr=fields)
else:
qstr = wikiutil.makeQueryString(fields)
return ''.join([request.getBaseURL(), '?', qstr])
def linkto(pagename, request, params=""):
_ = request.getText
if not request.cfg.chart_options:
return text(pagename, request)
if _debug:
return draw(pagename, request)
page = Page(request, pagename)
# Create escaped query string from dict and params
querystr = {"action": "chart", "type": "useragents"}
querystr = wikiutil.makeQueryString(querystr)
querystr = wikiutil.escape(querystr)
if params:
querystr += "&" + params
data = {"url": page.url(request, querystr)}
data.update(request.cfg.chart_options)
result = ('<img src="%(url)s" width="%(width)d" height="%(height)d"' ' alt="useragents chart">') % data
return result
def linkto(pagename, request, params=''):
_ = request.getText
if not request.cfg.chart_options:
return text(pagename, request)
if _debug:
return draw(pagename, request)
page = Page(request, pagename)
# Create escaped query string from dict and params
querystr = {'action': 'chart', 'type': 'useragents'}
querystr = wikiutil.makeQueryString(querystr)
querystr = wikiutil.escape(querystr)
if params:
querystr += '&' + params
data = {'url': page.url(request, querystr)}
data.update(request.cfg.chart_options)
result = ('<img src="%(url)s" width="%(width)d" height="%(height)d"'
' alt="useragents chart">') % data
return result
def _handle_add(self):
_ = self.request.getText
request = self.request
openid_id = request.form.get('openid_identifier', [''])[0]
if not openid_id:
return 'error', _("No OpenID given.")
if (hasattr(self.request.user, 'openids') and
openid_id in request.user.openids):
return 'error', _("OpenID is already present.")
oidconsumer = consumer.Consumer(request.session,
MoinOpenIDStore(self.request))
try:
oidreq = oidconsumer.begin(openid_id)
except HTTPFetchingError:
return 'error', _('Failed to resolve OpenID.')
except DiscoveryFailure:
return 'error', _('OpenID discovery failure, not a valid OpenID.')
else:
if oidreq is None:
return 'error', _("No OpenID given.") # ??
qstr = wikiutil.makeQueryString({'action': 'userprefs',
'handler': 'oid',
'oid.return': '1'})
return_to = request.getQualifiedURL(request.page.url(request, qstr))
trust_root = request.getBaseURL()
if oidreq.shouldSendRedirect():
redirect_url = oidreq.redirectURL(trust_root, return_to)
request.http_redirect(redirect_url)
else:
form_html = oidreq.formMarkup(trust_root, return_to,
form_tag_attrs={'id': 'openid_message'})
request.session['openid.prefs.form_html'] = form_html
def testMakeQueryString(self):
for qstr, in_str, in_unicode in self.tests:
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode)) == MultiDict(in_unicode)
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str)) == MultiDict(in_unicode)
def testMakeQueryStringFromKeywords(self):
""" util.web: make query sting from keywords """
expected = 'a=1&b=string'
result = wikiutil.makeQueryString(a=1, b='string')
self.assertEqual(result, expected,
'Expected "%(expected)s" but got "%(result)s"' % locals())
def testMakeQueryStringFromKeywords(self):
""" util.web: make query sting from keywords """
assert wikiutil.makeQueryString(a=1, b='string') == 'a=1&b=string'
def testMakeQueryString(self):
for qstr, in_str, in_unicode in self.tests:
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode, want_unicode=False), want_unicode=False) == in_str
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str, want_unicode=False), want_unicode=False) == in_str
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_unicode, want_unicode=True), want_unicode=True) == in_unicode
assert wikiutil.parseQueryString(wikiutil.makeQueryString(in_str, want_unicode=True), want_unicode=True) == in_unicode
def testMakeQueryStringFromKeywords(self):
""" util.web: make query sting from keywords """
assert wikiutil.makeQueryString(a=1, b='string') == 'a=1&b=string'
def url(request, key, do="get"):
""" return URL for the object cached for key """
return "%s/?%s" % (
request.getScriptname(),
wikiutil.makeQueryString(dict(action=action_name, do=do, key=key), want_unicode=False),
)
