def _render_feeds(self, req, content):
wiki = WikiSystem(self.env)
prefix = req.args['page'].value
if not prefix.endswith('/'):
prefix += '/'
pages = sorted(page for page in wiki.get_pages(prefix) if page != prefix)
buf = StringIO()
print >>buf, '<h1>Available Feeds</h1>'
if pages:
print >>buf, '<ul>'
href = self.env.href
for page in pages:
rel_name = page[len(prefix):]
print >>buf, Markup(
'<li><a href="%s">%s</a> <a href="%s">[rss]</a> <a href="%s">[edit]</a></li>',
href.wiki(page), rel_name, href.changesetrss(page), href.wiki(page, action='edit')
)
print >>buf, '</ul>'
else:
print >>buf, '<p>None</p>'
print >>buf, Markup('''<script type="text/javascript">
var new_filter = function(form) {
window.location = '%s'.replace(/deadbeef/, form.page_name.value);
};
</script>
''', href.wiki(prefix + 'deadbeef', action='edit', text=DEFAULT_CONTENT)
)
print >>buf, Markup('''<form onsubmit="new_filter(this); return false;">
<input type="text" name="page_name">
<input type="submit" value="Add Filter">
</form>
''')
return buf.getvalue()
class extendedcamelcase(Component):
implements(IWikiSyntaxProvider)
def __init__(self):
self.wikisys = WikiSystem(self.env)
# IWikiSyntaxProvider methods
def get_wiki_syntax(self):
# copied and modified from trac/wiki/api.py
from trac.wiki.formatter import Formatter
def wikipagename_link(formatter, match, fullmatch):
return self._format_link(formatter, 'wiki', match, match)
yield (r"(?P<name>\b([A-Z]+[a-z0-9]*)+[A-Z]+[a-z0-9]+\b)" , wikipagename_link)
def get_link_resolvers(self):
return []
def _format_link(self, formatter, ns, page, label):
# copied and modified from trac/wiki/api.py
page, query, fragment = formatter.split_link(page)
link = False
if self.wikisys.has_page(page):
link = True
elif page[-1] == 's' and self.wikisys.has_page(page[:-1]):
# if the page name ends in 's', see if there is a wiki page with the same name minus the 's'
# if there is, it will be linked
page = page[:-1]
link = True
href = formatter.href.wiki(page)+fragment
if link:
return html.A(label, href=href, class_='wiki')
else:
return html.A(label+'?', href=href, class_='missing wiki', rel='nofollow')
def expand_macro(self, formatter, name, args):
curpage = formatter.resource.id
# scoped TOC (e.g. TranslateRu/Guide or 0.X/Guide ...)
prefix = ''
guideprefix = GUIDE_NAME + '/'
data = {
'guide': GUIDE_NAME,
}
idx = curpage.find('/')
if idx > 0:
prefix = curpage[:idx + 1]
if prefix.endswith(guideprefix):
prefix = prefix[:len(prefix) - len(guideprefix)]
ws = WikiSystem(self.env)
return tag.div(
tag.h4(_('Table of Contents')),
tag.ul([
tag.li(tag.a(title,
href=formatter.href.wiki(prefix + ref % data),
class_=(not ws.has_page(prefix + ref % data)
and 'missing')),
class_=(prefix + ref % data == curpage and 'active'))
for ref, title in self.TOC
]),
class_='wiki-toc')
def _get_page_operations(self, source_env, local_env):
operations = {}
# Open source and destination wikis
source_wiki_system = WikiSystem(source_env)
dest_wiki_system = WikiSystem(local_env)
# Extract wiki pages from both wikis
local_pages = []
for page in dest_wiki_system.get_pages():
local_pages.append(page)
source_pages = []
for page in source_wiki_system.get_pages():
source_pages.append(page)
operations[page] = 'create'
# Create operations list
for page in local_pages:
if page in source_pages:
operations[page] = 'update'
# Do not update pages with identical contents
for page, operation in operations.items():
local_page = WikiPage(self.env, page)
source_page = WikiPage(source_env, page)
if local_page.text == source_page.text:
del operations[page]
return operations
def get_timeline_events(self, req, start, stop, filters):
# timeline动作的输入
if 'wiki' in filters:
wiki = WikiSystem(self.env)
format = req.args.get('format')
href = format == 'rss' and req.abs_href or req.href
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("SELECT time,name,comment,author,version "
"FROM wiki WHERE time>=%s AND time<=%s",
(start, stop))
for t,name,comment,author,version in cursor:
title = Markup('<em>%s</em> '+ u"编辑者 %s",
wiki.format_page_name(name), author)
diff_link = html.A(u'变化', href=href.wiki(name, action='diff',
version=version))
if format == 'rss':
comment = wiki_to_html(comment or '--', self.env, req, db,
absurls=True)
else:
comment = wiki_to_oneliner(comment, self.env, db,
shorten=True)
if version > 1:
comment = Markup('%s (%s)', comment, diff_link)
yield 'wiki', href.wiki(name), title, t, author, comment
# Attachments
att = AttachmentModule(self.env)
for event in att.get_timeline_events(req, db, 'wiki', format,
start, stop,
lambda id: html.EM(id)):
yield event
def rename(self, new_name):
"""Rename wiki page in-place, keeping the history intact.
Renaming a page this way will eventually leave dangling references
to the old page - which literally doesn't exist anymore.
"""
if not self.exists:
raise TracError(_("Cannot rename non-existent page"))
if not validate_page_name(new_name):
raise TracError(
_("Invalid Wiki page name '%(name)s'", name=new_name))
old_name = self.name
with self.env.db_transaction as db:
new_page = WikiPage(self.env, new_name)
if new_page.exists:
raise TracError(
_("Can't rename to existing %(name)s page.",
name=new_name))
db("UPDATE wiki SET name=%s WHERE name=%s", (new_name, old_name))
# Invalidate page name cache
del WikiSystem(self.env).pages
# Reparent attachments
from trac.attachment import Attachment
Attachment.reparent_all(self.env, self.realm, old_name, self.realm,
new_name)
self.name = new_name
self.env.log.info("Renamed page %s to %s", old_name, new_name)
for listener in WikiSystem(self.env).change_listeners:
if hasattr(listener, 'wiki_page_renamed'):
listener.wiki_page_renamed(self, old_name)
def load_conf(self):
self.styles = {}
self.template_filename = None
wiki_system = WikiSystem(self.env)
if not wiki_system.has_page('PageToOdtStyles'):
raise Exception, 'Please create a PageToOdtStyles wiki page.'
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"SELECT text FROM wiki WHERE name = 'PageToOdtStyles' ORDER BY version DESC LIMIT 1"
)
for (text, ) in cursor:
page_content = text
break
for line in page_content.strip().splitlines():
if line.find('=') != -1:
name, value = [token.strip() for token in line.split("=", 2)]
if name.startswith('style_'):
self.styles[name[6:]] = value
elif name == 'template':
self.template_filename = os.path.join(
self.env.path, 'attachments', 'wiki',
'PageToOdtStyles', value)
def delete(self, version=None, db=None):
assert self.exists, 'Cannot delete non-existent page'
@self.env.with_transaction(db)
def do_delete(db):
cursor = db.cursor()
if version is None:
# Delete a wiki page completely
cursor.execute("DELETE FROM wiki WHERE name=%s", (self.name, ))
self.env.log.info('Deleted page %s' % self.name)
else:
# Delete only a specific page version
cursor.execute("DELETE FROM wiki WHERE name=%s and version=%s",
(self.name, version))
self.env.log.info('Deleted version %d of page %s' %
(version, self.name))
if version is None or version == self.version:
self._fetch(self.name, None, db)
if not self.exists:
# Invalidate page name cache
del WikiSystem(self.env).pages
# Delete orphaned attachments
from trac.attachment import Attachment
Attachment.delete_all(self.env, 'wiki', self.name, db)
# Let change listeners know about the deletion
if not self.exists:
for listener in WikiSystem(self.env).change_listeners:
listener.wiki_page_deleted(self)
else:
for listener in WikiSystem(self.env).change_listeners:
if hasattr(listener, 'wiki_page_version_deleted'):
listener.wiki_page_version_deleted(self)
def render_macro(self, req, name, content):
prefix = content or None
wiki = WikiSystem(self.env)
return html.UL([html.LI(html.A(wiki.format_page_name(page),
href=req.href.wiki(page)))
for page in sorted(wiki.get_pages(prefix))])
def render_macro(self, req, name, content):
prefix = content or None
wiki = WikiSystem(self.env)
return html.UL([html.LI(html.A(wiki.format_page_name(page),
href=req.href.wiki(page)))
for page in sorted(wiki.get_pages(prefix))])
def render_macro(self, req, name, content):
prefix = limit = None
if content:
argv = [arg.strip() for arg in content.split(",")]
if len(argv) > 0:
prefix = argv[0]
if len(argv) > 1:
limit = int(argv[1])
db = self.env.get_db_cnx()
cursor = db.cursor()
sql = "SELECT name, " " max(version) AS max_version, " " max(time) AS max_time " "FROM wiki"
args = []
if prefix:
sql += " WHERE name LIKE %s"
args.append(prefix + "%")
sql += " GROUP BY name ORDER BY max_time DESC"
if limit:
sql += " LIMIT %s"
args.append(limit)
cursor.execute(sql, args)
entries_per_date = []
prevdate = None
for name, version, time in cursor:
date = format_date(time)
if date != prevdate:
prevdate = date
entries_per_date.append((date, []))
entries_per_date[-1][1].append((name, int(version)))
wiki = WikiSystem(self.env)
return html.DIV(
[
html.H3(date)
+ html.UL(
[
html.LI(
html.A(wiki.format_page_name(name), href=req.href.wiki(name)),
" ",
version > 1
and html.SMALL(
"(", html.A("diff", href=req.href.wiki(name, action="diff", version=version)), ")"
)
or None,
)
for name, version in entries
]
)
for date, entries in entries_per_date
]
)
def filter_stream(self, req, method, filename, stream, data):
if req.path_info.startswith('/wiki/'):
if data and data.has_key('page') and hasattr(
data['page'], 'resource'):
title = data['title']
filter = Transformer('//div[@id="pagepath"]')
filter = filter.empty()
filter = filter.append(
tag.a('wiki:',
href=req.href.wiki(),
class_='pathentry first'))
resource = data['page'].resource
relation_system = ResourceRelationSystem(self.env)
tree = relation_system.get_cached_tree(req)
add_stylesheet(req, 'wikimenu/css/superfish.css')
add_script(req, 'wikimenu/js/jquery.bgiframe.min.js')
add_script(req, 'wikimenu/js/superfish.js')
add_script(req, 'wikimenu/js/popup.js')
resources = []
for res in relation_system.get_ancestors(resource, tree=tree):
resources.append(res)
for res in reversed(resources):
label = get_resource_description(self.env, res)
if res.realm == 'wiki':
if res.id and WikiSystem(self.env).has_page(res.id):
menu = tag.ul()
for res_child in relation_system.get_children(res):
child_label = get_resource_description(
self.env, res_child)
if res_child.realm == 'wiki':
if res_child.id and WikiSystem(
self.env).has_page(res_child.id):
anc = tag.a(
child_label,
href=req.href.wiki(child_label))
menu.append(tag.li(anc))
filter = filter.append(
tag.ul(tag.li(
tag.a(label, href=req.href.wiki(label)),
menu),
class_='wiki_menu'))
if title != label:
filter = filter.append(
tag.span(' / ', class_='pathentry sep'))
remove_tran = '//a[@title="View ' + title + '"]'
return stream | filter
return stream
def save(self, author, comment, remote_addr=None, t=None):
"""Save a new version of a page.
:since 1.0.3: `remote_addr` is optional and deprecated, and will be
removed in 1.3.1
"""
if not validate_page_name(self.name):
raise TracError(
_("Invalid Wiki page name '%(name)s'", name=self.name))
new_text = self.text != self.old_text
if not new_text and self.readonly == self.old_readonly:
raise TracError(_("Page not modified"))
t = t or datetime_now(utc)
with self.env.db_transaction as db:
if new_text:
db(
"""INSERT INTO wiki (name, version, time, author, ipnr,
text, comment, readonly)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
""",
(self.name, self.version + 1, to_utimestamp(t), author,
remote_addr, self.text, comment, self.readonly))
self.version += 1
else:
db("UPDATE wiki SET readonly=%s WHERE name=%s",
(self.readonly, self.name))
if self.version == 1:
# Invalidate page name cache
del WikiSystem(self.env).pages
self.author = author
self.comment = comment
self.time = t
for listener in WikiSystem(self.env).change_listeners:
if self.version == 1:
listener.wiki_page_added(self)
else:
from trac.util import arity
if arity(listener.wiki_page_changed) == 6:
listener.wiki_page_changed(self, self.version, t, comment,
author, remote_addr)
else:
listener.wiki_page_changed(self, self.version, t, comment,
author)
self.old_readonly = self.readonly
self.old_text = self.text
def render_macro(self, req, name, content):
prefix = limit = None
if content:
argv = [arg.strip() for arg in content.split(',')]
if len(argv) > 0:
prefix = argv[0]
if len(argv) > 1:
limit = int(argv[1])
db = self.env.get_db_cnx()
cursor = db.cursor()
sql = 'SELECT name, ' \
' max(version) AS max_version, ' \
' max(time) AS max_time ' \
'FROM wiki'
args = []
if prefix:
sql += ' WHERE name LIKE %s'
args.append(prefix + '%')
sql += ' GROUP BY name ORDER BY max_time DESC'
if limit:
sql += ' LIMIT %s'
args.append(limit)
cursor.execute(sql, args)
entries_per_date = []
prevdate = None
for name, version, time in cursor:
date = format_date(time)
if date != prevdate:
prevdate = date
entries_per_date.append((date, []))
entries_per_date[-1][1].append((name, int(version)))
wiki = WikiSystem(self.env)
return html.DIV(
[html.H3(date) +
html.UL([html.LI(
html.A(wiki.format_page_name(name), href=req.href.wiki(name)),
' ',
version > 1 and
html.SMALL('(', html.A('diff',
href=req.href.wiki(name, action='diff',
version=version)), ')') \
or None)
for name, version in entries])
for date, entries in entries_per_date])
def _render_book(self, req, cat, page, component):
req.perm.assert_permission('WIKIPRINTLATEX_BOOK')
data = {}
allpages = list(WikiSystem(self.env).get_pages())
rightpages = [
x for x in req.session.get('wikiprint_rightpages', '').split(',')
if x
]
if req.method == 'POST' and req.args.get('create'):
rightpages = req.args.get('rightpages_all')
title = req.args.get('title') or self.env.project_name
subject = req.args.get('subject')
date = req.args.get('date')
version = req.args.get('version')
req.session['wikiprint_rightpages'] = rightpages
rightpages = rightpages.split(',')
pdfbookname = title.replace(' ',
'_').replace(':',
'_').replace(',', '_')
return self.process_wikiprintlatex(req, title, subject, rightpages,
version, date, pdfbookname)
data['allpages'] = allpages
leftpages = [x for x in allpages if x not in rightpages]
leftpages.sort()
data['leftpages'] = leftpages
data['rightpages'] = rightpages
add_script(req, 'wikiprint/js/admin_wikiprintlatex.js')
return 'admin_makebook.html', data
def rename(self, new_name):
"""Rename wiki page in-place, keeping the history intact.
Renaming a page this way will eventually leave dangling references
to the old page - which litterally doesn't exist anymore.
"""
assert self.exists, 'Cannot rename non-existent page'
old_name = self.name
@self.env.with_transaction()
def do_rename(db):
cursor = db.cursor()
new_page = WikiPage(self.env, new_name, db=db)
if new_page.exists:
raise TracError(
_("Can't rename to existing %(name)s page.",
name=new_name))
cursor.execute("UPDATE wiki SET name=%s WHERE name=%s",
(new_name, old_name))
# Invalidate page name cache
del WikiSystem(self.env).pages
# Reparent attachments
from trac.attachment import Attachment
Attachment.reparent_all(self.env, 'wiki', old_name, 'wiki',
new_name)
self.name = new_name
self.env.log.info('Renamed page %s to %s', old_name, new_name)
for listener in WikiSystem(self.env).change_listeners:
if hasattr(listener, 'wiki_page_renamed'):
listener.wiki_page_renamed(self, old_name)
def _get_translations(self, prefix, base_page_name):
res = []
for l in sorted(self.languages.keys()):
tr = self._get_translated_page(prefix, base_page_name, l)
if WikiSystem(self.env).has_page(tr):
res.append(l)
return res
def do_import(db):
cursor = db.cursor()
# Make sure we don't insert the exact same page twice
cursor.execute("SELECT text FROM wiki WHERE name=%s "
"ORDER BY version DESC LIMIT 1",
(title,))
old = list(cursor)
if old and title in create_only:
printout(_(' %(title)s already exists', title=title))
result[0] = False
return
if old and data == old[0][0]:
printout(_(' %(title)s is already up to date', title=title))
result[0] = False
return
if replace and old:
cursor.execute("UPDATE wiki SET text=%s WHERE name=%s "
" AND version=(SELECT max(version) FROM wiki "
" WHERE name=%s)",
(data, title, title))
else:
cursor.execute("INSERT INTO wiki(version,name,time,author,"
" ipnr,text) "
"SELECT 1+COALESCE(max(version),0),%s,%s,"
" 'trac','127.0.0.1',%s FROM wiki "
"WHERE name=%s",
(title, to_utimestamp(datetime.now(utc)), data,
title))
if not old:
del WikiSystem(self.env).pages
def trac_get_reference(env, context, rawtext, target, text):
fulltext = target + ' ' + text if text else target
link = extract_link(env, context, fulltext)
uri = None
missing = False
if isinstance(link, (Element, Fragment)):
linktext = Markup(link).striptags()
# the following is a bit hackish, but it takes into account:
# - an eventual trailing '?' for missing wiki pages
# - space eventually introduced due to split_page_names option
if linktext.rstrip('?').replace(' ', '') != target:
text = linktext
elt = find_element(link, 'href', 'missing')
if elt is not None:
uri = elt.attrib.get('href', '')
missing = 'missing' in elt.attrib.get('class', '').split()
else:
uri = context.href.wiki(target)
missing = not WikiSystem(env).has_page(target)
if uri or missing:
reference = nodes.reference(rawtext, text or target)
reference['refuri'] = uri
if missing:
reference['classes'].append('missing')
return reference
def save(self, req):
if req.args and req.args.has_key('action') \
and req.args['action'] == 'save':
for key in SESSION_KEYS.values():
if req.args.has_key(key):
if key == 'wiki.href':
wiki_href = req.args[key]
if wiki_href == '':
req.session[key] = ''
continue
validated = WikiSystem(self.env).has_page(wiki_href)
if validated:
req.session[key] = req.args[key]
else:
add_warning(req, Markup(tag.span(Markup(_(
"%(page)s is not a valid Wiki page",
page=tag.b(wiki_href)
)))))
elif key == 'tickets.href':
ticket_href = req.args[key]
if ticket_href == '':
req.session[key] = ''
continue
reports = self.get_report_list()
self.log.info('reports: %s' % reports)
if ticket_href in ('report', 'query') \
or as_int(ticket_href, 0) in reports:
req.session[key] = req.args[key]
else:
add_warning(req, Markup(tag.span(Markup(_(
"%(report)s is not a valid report",
report=tag.b(ticket_href)
)))))
else:
req.session[key] = req.args[key]
def render_macro(self, req, name, args):
# Args seperated by commas:
# prefix,level
#
# Page Name prefix to search for.
# how many 'levels' in the hierarchy to go down.
prefix = req.hdf.getValue('wiki.page_name', '') + '/'
level = 0
if args:
args = args.replace('\'', '\'\'')
args = args.split(',')
if args[0] != 'None':
prefix = args[0]
if len(args) > 1 and args[1] != 'None':
level = int(args[1])
pages = WikiSystem(self.env).get_pages(prefix)
good_pages = []
for p in pages:
if level:
len_name = p.split('/')
if len(len_name) > level+1:
continue
page = WikiPage(self.env, p)
md = self.TITLE_RE.search(page.text)
title = ''
if md:
title = md.group(1)
good_pages.append((p, title))
return html.UL([html.LI(html.A(p, title=t, href=req.href.wiki(p)), ' ', t) for p,t in good_pages])
def __loadTemplatePage(self,pagina):
""" Carga la plantilla desde los adjuntos de una página wiki concreta
"""
page_content = ''
template_list = []
template_file = []
wiki_system = WikiSystem(self.env)
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(self.CONF_QUERY)
for (text, ) in cursor:
page_content = text
self.env.log.debug('Accedo a la pagina de plantillas %s', page_content)
break
for line in page_content.strip().splitlines():
if line.find('=') != -1:
name, value = [token.strip()
for token in line.split("=", 2)]
self.env.log.debug('-------> %s %s',name, value)
if name == 'template_list':
template_list = value.split(', ')
if name == 'template_file':
template_file = value.split(', ')
i = 0
for element in template_list:
self.env.log.debug('->>>>>>> %s', pagina)
if re.match('.*' + element + '.*', pagina):
return os.path.join(self.env.path, 'attachments', 'wiki','WikiTemplateConf', template_file[i])
i = i + 1
return None
def _set_title(self, req, page, action):
title = name = WikiSystem(self.env).format_page_name(page.name)
if action:
title += ' (%s)' % action
req.hdf['wiki.page_name'] = name
req.hdf['title'] = title
return title
def save(self, author, comment, t=None, replace=False):
"""Save a new version of a page."""
if not validate_page_name(self.name):
raise TracError(
_("Invalid Wiki page name '%(name)s'", name=self.name))
new_text = self.text != self.old_text
if not new_text and self.readonly == self.old_readonly:
raise TracError(_("Page not modified"))
t = t or datetime_now(utc)
with self.env.db_transaction as db:
if new_text:
if replace and self.version != 0:
db(
"""
UPDATE wiki SET text=%s WHERE name=%s AND version=%s
""", (self.text, self.name, self.version))
else:
self.version += 1
db(
"""INSERT INTO wiki
(name,version,time,author,text,comment,readonly)
VALUES (%s,%s,%s,%s,%s,%s,%s)
""", (self.name, self.version, to_utimestamp(t),
author, self.text, comment, self.readonly))
else:
db("UPDATE wiki SET readonly=%s WHERE name=%s",
(self.readonly, self.name))
if self.version == 1:
# Invalidate page name cache
del WikiSystem(self.env).pages
self.author = author
self.comment = comment
self.time = t
for listener in WikiSystem(self.env).change_listeners:
with self.env.component_guard(listener):
if self.version == 1:
listener.wiki_page_added(self)
else:
listener.wiki_page_changed(self, self.version, t, comment,
author)
self.old_readonly = self.readonly
self.old_text = self.text
def _get_problems(self, silent):
res = u""
resargs = u""
respages = u""
base_pages = []
for page in sorted(WikiSystem(self.env).get_pages()):
for line in WikiPage(self.env, page).text.replace('\r',
'').split(u'\n'):
regres = self.macro_re.search(line)
if regres != None:
(prefix, base_page_name,
lang_code) = self._get_page_info(page)
basename = self._get_translated_page(prefix, \
base_page_name, self.base_lang)
if not basename in base_pages:
base_pages.append(basename)
resargs += self._check_args(page, regres.group(1),
lang_code)
if self.languages.get(lang_code, None) == None:
respages += "||[[wiki:/%s]]||Translated page language code unknown||\n" % page
base_pages.sort()
for base_page in base_pages:
(prefix, page, lang_code) = self._get_page_info(base_page)
translations = self._get_translations(prefix, page)
basever = 0
if not self.base_lang in translations:
respages += "||[[wiki:/%s]]||Base language is missing for translated pages||\n" % base_page
else:
basever = WikiPage(self.env, base_page).version
for translation in translations:
transpage = self._get_translated_page(prefix, page,
translation)
regres = self.macro_re.search(
WikiPage(self.env, transpage).text)
if regres != None:
argstr = regres.group(1)
if argstr != None and len(argstr) > 0:
args, kw = parse_args(argstr)
try:
rev = int(kw[u'revision'])
if rev != 0 and rev > basever:
respages += "||[[wiki:/%s]]||Revision %s is higher than base revision %s||\n" \
% (transpage, rev, basever)
except:
pass
else:
respages += "||[[wiki:/%s]]||Translated page misses macro 'TranslatedPages'||\n" % transpage
if len(resargs):
res += u"=== Errors in supplied arguments ===\n||= Page =||= Arguments =||= Issue =||\n" + resargs
if len(respages):
res += u"=== Errors in page structure ===\n||= Page =||= Issue =||\n" + respages
if not len(res):
if (silent):
return u" "
res = u'none\n'
return u"== Problem pages ==\n" + res
def render(self, context, mimetype, content, filename=None, rev=None):
# Minimize visual impact of errors
class TracHTMLTranslator(html4css1.HTMLTranslator):
"""Specialized translator with unobtrusive error reporting
and some extra security features"""
def __init__(self, *args, **kwargs):
self._render_unsafe_content = wikisys.render_unsafe_content
self._safe_schemes = set(wikisys.safe_schemes)
html4css1.HTMLTranslator.__init__(self, *args, **kwargs)
def visit_system_message(self, node):
paragraph = node.children.pop(0)
message = escape(paragraph.astext()) if paragraph else ''
backrefs = node['backrefs']
if backrefs:
span = ('<span class="system-message">%s</span>' %
(''.join('<a href="#%s" title="%s">?</a>' %
(backref, message)
for backref in backrefs)))
else:
span = ('<span class="system-message" title="%s">?</span>'
% message)
self.body.append(span)
def depart_system_message(self, node):
pass
def visit_image(self, node):
html4css1.HTMLTranslator.visit_image(self, node)
uri = node.attributes.get('uri')
if not wikisys.is_safe_origin(uri, context.req):
self.body[-1] = self.body[-1].replace(
'<img ', '<img crossorigin="anonymous" ')
def visit_reference(self, node):
if self._is_safe_uri(node.get('refuri')):
html4css1.HTMLTranslator.visit_reference(self, node)
def depart_reference(self, node):
if self._is_safe_uri(node.get('refuri')):
html4css1.HTMLTranslator.depart_reference(self, node)
def _is_safe_uri(self, uri):
if self._render_unsafe_content or not uri:
return True
else:
pos = uri.find(':')
return pos < 0 or uri[0:pos] in self._safe_schemes
wikisys = WikiSystem(self.env)
writer = html4css1.Writer()
writer.translator_class = TracHTMLTranslator
inliner = rst.states.Inliner()
inliner.trac = (self.env, context)
parser = rst.Parser(inliner=inliner)
content = content_to_unicode(self.env, content, mimetype)
# The default Reader is explicitly passed as a workaround for #11248
parts = publish_parts(content, writer=writer, parser=parser,
reader=standalone.Reader(parser),
settings_overrides={'halt_level': 6,
'file_insertion_enabled': 0,
'raw_enabled': 0,
'warning_stream': False})
return parts['html_body']
def pages(self, db):
# retrieve wiki contents for field help
pages = {}
prefix_len = len(FieldTooltip._wiki_prefix)
wiki_pages = WikiSystem(self.env).get_pages(FieldTooltip._wiki_prefix)
for page in wiki_pages:
pages[page[prefix_len:]] = WikiPage(self.env, page, db=db).text
return pages
def _reindex_wiki(self, realm, feedback, finish_fb):
def check(page, status):
return status is None or page.time > to_datetime(int(status))
resources = (WikiPage(self.env, name)
for name in WikiSystem(self.env).get_pages())
index = self.wiki_page_added
return self._index(realm, resources, check, index, feedback, finish_fb)
def save(self, author, comment, remote_addr, t=None, db=None):
"""Save a new version of a page.
:since 0.13: the `db` parameter is no longer needed and will be removed
in version 0.14
"""
if not validate_page_name(self.name):
raise TracError(
_("Invalid Wiki page name '%(name)s'", name=self.name))
new_text = self.text != self.old_text
if not new_text and self.readonly == self.old_readonly:
raise TracError(_("Page not modified"))
t = t or datetime.now(utc)
with self.env.db_transaction as db:
if new_text:
db(
"""INSERT INTO wiki (name, version, time, author, ipnr,
text, comment, readonly)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
""",
(self.name, self.version + 1, to_utimestamp(t), author,
remote_addr, self.text, comment, self.readonly))
self.version += 1
self.resource = self.resource(version=self.version)
else:
db("UPDATE wiki SET readonly=%s WHERE name=%s",
(self.readonly, self.name))
if self.version == 1:
# Invalidate page name cache
del WikiSystem(self.env).pages
self.author = author
self.comment = comment
self.time = t
for listener in WikiSystem(self.env).change_listeners:
if self.version == 1:
listener.wiki_page_added(self)
else:
listener.wiki_page_changed(self, self.version, t, comment,
author, remote_addr)
self.old_readonly = self.readonly
self.old_text = self.text
def _known_macros(self):
macros = {}
macros.update((name, '(built-in)') for name in self._builtin_macros)
macros.update((name, provider.get_macro_description(name))
for provider in WikiSystem(self.env).macro_providers
for name in provider.get_macros() or ()
if name not in macros)
return macros
def get_wikipages(self):
"""
yield all the tickets per self._env and self._milestones
"""
w = WikiSystem(self._env)
for page in w.pages:
page = WikiPage(self._env, page)
yield page
def sanitize_attrib(env, element):
if not WikiSystem(env).render_unsafe_content:
sanitized = getattr(tag, element.tag.localname)
for k, data, pos in (Stream(element) | TracHTMLSanitizer()):
sanitized.attrib = data[1]
break # only look at START
element = sanitized
return element
def process_request(self, req):
req.hdf['trac.href.blog'] = req.href.blog()
entries = []
for page_name in WikiSystem(self.env).get_pages(prefix='Blog'):
page = WikiPage(self.env, page_name)
title = page_name
text = page.text
match = title_split_match(page.text)
if match:
title = match.group(1)
text = match.group(2)
comments = text.count('[[SimpleBlogComment(')
cutoff = text.find('[[SimpleBlogComment(')
if cutoff >= 0:
text = text[:cutoff].rstrip()
description = wiki_to_html(text, self.env, req)
original = self._get_original_post_info(page_name)
event = {
'href': self.env.href.wiki(page_name),
'title': title,
'description': description,
'escaped': Markup.escape(unicode(description)),
'date': format_datetime(original['time']),
'rfcdate': http_date(original['time']),
'author': original['author'],
'comment': original['comment'],
'comments': comments,
}
if page.version > 1:
event['updated.version'] = page.version
event['updated.date'] = format_datetime(page.time)
event['updated.rfcdate'] = http_date(page.time)
event['updated.author'] = page.author
event['updated.comment'] = page.comment
entries.append((original['time'], event))
entries.sort()
entries.reverse()
max_count = 20
if len(entries) > max_count:
entries = entries[:max_count]
events = []
for date, event in entries:
events.append(event)
req.hdf['blog.events'] = events
format = req.args.get('format')
if format == 'rss':
return 'blog_rss.cs', 'application/rss+xml'
add_link(req, 'alternate', self.env.href.blog(format='rss'),
'RSS Feed', 'application/rss+xml', 'rss')
return 'blog.cs', None
def link_resolvers(self):
if not self._link_resolvers:
from trac.wiki.api import WikiSystem
resolvers = {}
for resolver in WikiSystem(self.env).syntax_providers:
for namespace, handler in resolver.get_link_resolvers() or []:
resolvers[namespace] = handler
self._link_resolvers = resolvers
return self._link_resolvers
def expand_macro(self, formatter, name, content):
curpage = formatter.resource.id
# scoped TOC (e.g. TranslateRu/TracGuide or 0.11/TracGuide ...)
prefix = ''
idx = curpage.find('/')
if idx > 0:
prefix = curpage[:idx+1]
ws = WikiSystem(self.env)
return tag.div(
tag.h4(_('Table of Contents')),
tag.ul([tag.li(tag.a(title, href=formatter.href.wiki(prefix+ref),
class_=(not ws.has_page(prefix+ref) and
'missing')),
class_=(prefix+ref == curpage and 'active'))
for ref, title in self.TOC]),
class_='wiki-toc')
def expand_macro(self, formatter, name, content):
curpage = formatter.resource.id
# scoped TOC (e.g. TranslateRu/TracGuide or 0.11/TracGuide ...)
prefix = ''
idx = curpage.find('/')
if idx > 0:
prefix = curpage[:idx+1]
ws = WikiSystem(self.env)
return tag.div(
tag.h4(_('Table of Contents')),
tag.ul([tag.li(tag.a(title, href=formatter.href.wiki(prefix+ref),
class_=(not ws.has_page(prefix+ref) and
'missing')),
class_=(prefix+ref == curpage and 'active'))
for ref, title in self.TOC]),
class_='wiki-toc')
class AutoLinksModule(Component):
implements(IWikiSyntaxProvider)
def __init__(self):
self.wikisys = WikiSystem(self.env)
# IWikiSyntaxProvider methods
def get_wiki_syntax(self):
# copied and modified from trac/wiki/api.py
from trac.wiki.formatter import Formatter
wiki_page_name = (
r"(([A-Z]+[a-z]{2,})|([A-Z]{3,}s?))"
r"(?:#[\w:](?<!\d)(?:[\w:.-]*[\w-])?)?" # optional fragment id
r"(?=:(?:\Z|\s)|[^:a-zA-Z]|\s|\Z)" # what should follow it
)
def wikipagename_link(formatter, match, fullmatch):
return self._format_link(formatter, 'wiki', match, match)
yield (r"!?(?<![/\-])\b" + wiki_page_name, wikipagename_link)
def get_link_resolvers(self):
return []
def _format_link(self, formatter, ns, page, label):
# copied and modified from trac/wiki/api.py
page, query, fragment = formatter.split_link(page)
link = False
if self.wikisys.has_page(page):
link = True
elif page[-1] == 's' and self.wikisys.has_page(page[:-1]):
# if the page name ends in 's', see if there is a wiki page with the same name minus the 's'
# if there is, it will be linked
page = page[:-1]
link = True
if link:
href = formatter.href.wiki(page) + fragment
return html.A(label, href=href, class_='wiki')
else:
return label
def post_process_request(self, req, template, data, content_type):
if data and 'context' in data and \
data['context'].resource.realm == 'wiki' and \
'action' not in req.args and \
'version' not in req.args:
page = data['page']
prefix = '/' in page.name and page.name[:page.name.rindex('/') + 1] or ''
wiki = WikiSystem(self.env)
start = prefix.count('/')
pages = sorted(page for page in wiki.get_pages(prefix) \
if (start >= page.count('/'))
and 'WIKI_VIEW' in req.perm('wiki', page))
if page.name in pages:
index = pages.index(page.name)
if index > 0:
add_link(req, 'prev', req.href.wiki(pages[index - 1]))
if index < len(pages) - 1:
add_link(req, 'next', req.href.wiki(pages[index + 1]))
prevnext_nav(req, _('Previous Page'), _('Next Page'))
return template, data, content_type
def expand_macro(self, formatter, name, args):
curpage = formatter.resource.id
# scoped TOC (e.g. TranslateRu/Guide or 0.X/Guide ...)
prefix = ''
guideprefix = GUIDE_NAME + '/'
data = {'guide': GUIDE_NAME,}
idx = curpage.find('/')
if idx > 0:
prefix = curpage[:idx+1]
if prefix.endswith(guideprefix):
prefix = prefix[:len(prefix)-len(guideprefix)]
ws = WikiSystem(self.env)
return tag.div(
tag.h4(_('Table of Contents')),
tag.ul([tag.li(tag.a(title,
href=formatter.href.wiki(prefix+ref % data),
class_=(not ws.has_page(prefix+ref % data) and
'missing')),
class_=(prefix+ref % data== curpage and 'active'))
for ref, title in self.TOC]),
class_='wiki-toc')
def load_conf(self):
self.styles = {}
self.template_filename = None
wiki_system = WikiSystem(self.env)
if not wiki_system.has_page('PageToOdtStyles'):
raise Exception, 'Please create a PageToOdtStyles wiki page.'
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("SELECT text FROM wiki WHERE name = 'PageToOdtStyles' ORDER BY version DESC LIMIT 1")
for (text,) in cursor:
page_content = text
break
for line in page_content.strip().splitlines():
if line.find('=') != -1:
name, value = [token.strip()
for token in line.split("=", 2)]
if name.startswith('style_'):
self.styles[ name[6:] ] = value
elif name == 'template':
self.template_filename = os.path.join(
self.env.path, 'attachments', 'wiki',
'PageToOdtStyles', value)
class WikiExtRPC(Component):
""" Additional Wiki XML-RPC API. """
implements(IXMLRPCHandler)
VERSION = '1.0'
def __init__(self):
self.wiki = WikiSystem(self.env)
def xmlrpc_namespace(self):
return 'wikiext'
def xmlrpc_methods(self):
yield ('WIKI_VIEW', ((list, str), ), self.getPageVersions)
yield ('WIKI_VIEW', ((bool, str), ), self.hasChildren)
yield ('WIKI_VIEW', ((list, str), ), self.getChildren)
yield ('WIKI_VIEW', ((dict,), ), self.getMacros)
yield ('WIKI_VIEW', ((dict,), ), self.getVersion)
def _page_info(self, name, time, author, version, comment=''):
return dict(name=name,
lastModified=xmlrpclib.DateTime(int(time)),
author=author,
version=int(version),
comment=(comment or '') )
def getPage(self, req, pagename, version=None):
""" Get the raw Wiki text of page, latest version. """
page = WikiPage(self.env, pagename, version)
if page.exists:
return page.text
else:
msg = 'Wiki page "%s" does not exist' % pagename
if version is not None:
msg += ' at version %s' % version
raise xmlrpclib.Fault(0, msg)
def getPageVersions(self, req, pagename):
'''Return an array of page versions info'''
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('SELECT version, author, comment, time FROM wiki'
' WHERE name = %s ORDER BY version DESC', (pagename,))
result = []
for version, author, comment, time in cursor:
result.append(self._page_info(pagename, time, author, version, comment))
return result
def hasChildren(self, req, pagename):
""" Returns true if the page has children. """
if pagename: pagename += '/'
res = False
for i in self.wiki.get_pages( pagename ):
res = True
break
return res
def getChildren(self, req, pagename):
""" Returns a list of all pages. The result is an array of utf8 pagenames. """
cond = ''
# params = ()
if pagename:
pagename += '/'
cond = "WHERE name LIKE '%s%%'" % pagename
# params = (pagename,)
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("SELECT name, MAX(version) FROM wiki %s GROUP BY name" % cond )
pages = []
for name, version in cursor:
pages.append( (name, version) )
children = {}
for page, version in pages:
relname = page.replace( pagename, '' )
if relname.find( '/' ) == -1:
# We only look for direct children
children[ page ] = { 'exists' : True,
'hasChildren' : False,
'version' : version }
else:
# The page does not really exists, but it does have
# children, so we have to return it,
name = pagename + relname.split( '/', 1 )[0]
if not children.has_key( name ):
children[ name ] = { 'exists' : False,
'hasChildren' : True,
'version' : version }
else:
children[ name ][ 'hasChildren' ] = True
return children
def getMacros(self, req):
'''Return the list of registered wiki macros'''
macros = {}
for plugin in self.wiki.macro_providers:
for macro in plugin.get_macros():
desc = plugin.get_macro_description( macro )
if not desc:
desc = ''
macros[ macro ] = desc
return macros
def getVersion( self, req ):
'''Return the module version'''
return { 'version' : self.VERSION }
def __init__(self):
self.wiki = WikiSystem(self.env)
class WikiRPC(Component):
""" Implementation of the [http://www.jspwiki.org/Wiki.jsp?page=WikiRPCInterface2 WikiRPC API]. """
implements(IXMLRPCHandler)
def __init__(self):
self.wiki = WikiSystem(self.env)
def xmlrpc_namespace(self):
return 'wiki'
def xmlrpc_methods(self):
yield ('WIKI_VIEW', ((dict, xmlrpclib.DateTime),), self.getRecentChanges)
yield ('WIKI_VIEW', ((int,),), self.getRPCVersionSupported)
yield ('WIKI_VIEW', ((str, str), (str, str, int),), self.getPage)
yield ('WIKI_VIEW', ((str, str, int),), self.getPage, 'getPageVersion')
yield ('WIKI_VIEW', ((str, str), (str, str, int)), self.getPageHTML)
yield ('WIKI_VIEW', ((str, str), (str, str, int)), self.getPageHTML, 'getPageHTMLVersion')
yield ('WIKI_VIEW', ((list,),), self.getAllPages)
yield ('WIKI_VIEW', ((dict, str), (dict, str, int)), self.getPageInfo)
yield ('WIKI_VIEW', ((dict, str, int),), self.getPageInfo, 'getPageInfoVersion')
yield ('WIKI_CREATE', ((bool, str, str, dict),), self.putPage)
yield ('WIKI_VIEW', ((list, str),), self.listAttachments)
yield ('WIKI_VIEW', ((xmlrpclib.Binary, str),), self.getAttachment)
yield ('WIKI_MODIFY', ((bool, str, xmlrpclib.Binary),), self.putAttachment)
yield ('WIKI_MODIFY', ((bool, str, str, str, xmlrpclib.Binary),
(bool, str, str, str, xmlrpclib.Binary, bool)),
self.putAttachmentEx)
yield ('WIKI_DELETE', ((bool, str),), self.deleteAttachment)
yield ('WIKI_VIEW', ((list, str),), self.listLinks)
yield ('WIKI_VIEW', ((str, str),), self.wikiToHtml)
def _page_info(self, name, time, author, version):
return dict(name=name, lastModified=xmlrpclib.DateTime(int(time)),
author=author, version=int(version))
def getRecentChanges(self, req, since):
""" Get list of changed pages since timestamp """
since = to_timestamp(since)
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute('SELECT name, max(time), author, version FROM wiki'
' WHERE time >= %s GROUP BY name ORDER BY max(time) DESC', (since,))
result = []
for name, time, author, version in cursor:
result.append(self._page_info(name, time, author, version))
return result
def getRPCVersionSupported(self, req):
""" Returns 2 with this version of the Trac API. """
return 2
def getPage(self, req, pagename, version=None):
""" Get the raw Wiki text of page, latest version. """
page = WikiPage(self.env, pagename, version)
if page.exists:
return page.text
else:
msg = 'Wiki page "%s" does not exist' % pagename
if version is not None:
msg += ' at version %s' % version
raise xmlrpclib.Fault(0, msg)
def getPageHTML(self, req, pagename, version=None):
""" Return page in rendered HTML, latest version. """
text = self.getPage(req, pagename, version)
html = wiki_to_html(text, self.env, req, absurls=1)
return '<html><body>%s</body></html>' % html
def getAllPages(self, req):
""" Returns a list of all pages. The result is an array of utf8 pagenames. """
return list(self.wiki.get_pages())
def getPageInfo(self, req, pagename, version=None):
""" Returns information about the given page. """
page = WikiPage(self.env, pagename, version)
if page.exists:
last_update = page.get_history().next()
return self._page_info(page.name, last_update[1], last_update[2],
page.version)
def putPage(self, req, pagename, content, attributes):
""" writes the content of the page. """
page = WikiPage(self.env, pagename)
if page.readonly:
req.perm.assert_permission('WIKI_ADMIN')
elif not page.exists:
req.perm.assert_permission('WIKI_CREATE')
else:
req.perm.assert_permission('WIKI_MODIFY')
page.text = content
if req.perm.has_permission('WIKI_ADMIN'):
page.readonly = attributes.get('readonly') and 1 or 0
page.save(attributes.get('author', req.authname),
attributes.get('comment'),
req.remote_addr)
return True
def listAttachments(self, req, pagename):
""" Lists attachments on a given page. """
return [pagename + '/' + a.filename for a in Attachment.select(self.env, 'wiki', pagename)]
def getAttachment(self, req, path):
""" returns the content of an attachment. """
pagename, filename = posixpath.split(path)
attachment = Attachment(self.env, 'wiki', pagename, filename)
return xmlrpclib.Binary(attachment.open().read())
def putAttachment(self, req, path, data):
""" (over)writes an attachment. Returns True if successful.
This method is compatible with WikiRPC. `putAttachmentEx` has a more
extensive set of (Trac-specific) features. """
pagename, filename = posixpath.split(path)
self.putAttachmentEx(req, pagename, filename, None, data)
return True
def putAttachmentEx(self, req, pagename, filename, description, data, replace=True):
""" Attach a file to a Wiki page. Returns the (possibly transformed)
filename of the attachment.
Use this method if you don't care about WikiRPC compatibility. """
if not WikiPage(self.env, pagename).exists:
raise TracError, 'Wiki page "%s" does not exist' % pagename
if replace:
try:
attachment = Attachment(self.env, 'wiki', pagename, filename)
attachment.delete()
except TracError:
pass
attachment = Attachment(self.env, 'wiki', pagename)
attachment.author = req.authname or 'anonymous'
attachment.description = description
attachment.insert(filename, StringIO(data.data), len(data.data))
return attachment.filename
def deleteAttachment(self, req, path):
""" Delete an attachment. """
pagename, filename = posixpath.split(path)
if not WikiPage(self.env, pagename).exists:
raise TracError, 'Wiki page "%s" does not exist' % pagename
attachment = Attachment(self.env, 'wiki', pagename, filename)
attachment.delete()
return True
def listLinks(self, req, pagename):
""" ''Not implemented'' """
return []
def wikiToHtml(self, req, text):
""" Render arbitrary Wiki text as HTML. """
return unicode(wiki_to_html(text, self.env, req, absurls=1))
def _render_view(self, req, page):
version = page.resource.version
# Add registered converters
if page.exists:
for conversion in Mimeview(self.env).get_supported_conversions(
'text/x-trac-wiki'):
conversion_href = req.href.wiki(page.name, version=version,
format=conversion[0])
# or...
conversion_href = get_resource_url(self.env, page.resource,
req.href, format=conversion[0])
add_link(req, 'alternate', conversion_href, conversion[1],
conversion[3])
data = self._page_data(req, page)
if page.name == 'WikiStart':
data['title'] = ''
ws = WikiSystem(self.env)
context = web_context(req, page.resource)
higher, related = [], []
if not page.exists:
if 'WIKI_CREATE' not in req.perm(page.resource):
raise ResourceNotFound(_('Page %(name)s not found',
name=page.name))
formatter = OneLinerFormatter(self.env, context)
if '/' in page.name:
parts = page.name.split('/')
for i in range(len(parts) - 2, -1, -1):
name = '/'.join(parts[:i] + [parts[-1]])
if not ws.has_page(name):
higher.append(ws._format_link(formatter, 'wiki',
'/' + name, name, False))
else:
name = page.name
name = name.lower()
related = [each for each in ws.pages
if name in each.lower()
and 'WIKI_VIEW' in req.perm('wiki', each)]
related.sort()
related = [ws._format_link(formatter, 'wiki', '/' + each, each,
False)
for each in related]
latest_page = WikiPage(self.env, page.name, version=None)
req.perm(latest_page.resource).require('WIKI_VIEW')
prev_version = next_version = None
if version:
try:
version = int(version)
for hist in latest_page.get_history():
v = hist[0]
if v != version:
if v < version:
if not prev_version:
prev_version = v
break
else:
next_version = v
except ValueError:
version = None
prefix = self.PAGE_TEMPLATES_PREFIX
templates = [template[len(prefix):]
for template in ws.get_pages(prefix)
if 'WIKI_VIEW' in req.perm('wiki', template)]
# -- prev/up/next links
if prev_version:
add_link(req, 'prev',
req.href.wiki(page.name, version=prev_version),
_('Version %(num)s', num=prev_version))
parent = None
if version:
add_link(req, 'up', req.href.wiki(page.name, version=None),
_('View latest version'))
elif '/' in page.name:
parent = page.name[:page.name.rindex('/')]
add_link(req, 'up', req.href.wiki(parent, version=None),
_("View parent page"))
if next_version:
add_link(req, 'next',
req.href.wiki(page.name, version=next_version),
_('Version %(num)s', num=next_version))
# Add ctxtnav entries
if version:
prevnext_nav(req, _('Previous Version'), _('Next Version'),
_('View Latest Version'))
else:
if parent:
add_ctxtnav(req, _('Up'), req.href.wiki(parent))
self._wiki_ctxtnav(req, page)
# Plugin content validation
fields = {'text': page.text}
for manipulator in self.page_manipulators:
manipulator.prepare_wiki_page(req, page, fields)
text = fields.get('text', '')
data.update({
'context': context,
'text': text,
'latest_version': latest_page.version,
'attachments': AttachmentModule(self.env).attachment_data(context),
'default_template': self.DEFAULT_PAGE_TEMPLATE,
'templates': templates,
'version': version,
'higher': higher, 'related': related,
'resourcepath_template': 'wiki_page_path.html',
})
add_script(req, 'common/js/folding.js')
return 'wiki_view.html', data, None
def expand_macro(self, formatter, name, content):
env = formatter.env
req = formatter.req
if not content:
args = []
kw = {}
else:
args, kw = parse_args(content)
if name == 'ProjectStats':
if 'wiki' in kw.keys():
prefix = 'prefix' in kw.keys() and kw['prefix'] or None
wiki = WikiSystem(env)
if kw['wiki'] == 'count' or 'count' in args:
return tag(len(list(wiki.get_pages(prefix))))
elif name == 'UserQuery':
msg_no_perm = tag.p(tag_("(required %(perm)s missing)",
perm=tag.strong('USER_VIEW')),
class_='hint')
if 'perm' in kw.keys():
perm_sys = PermissionSystem(self.env)
users = perm_sys.get_users_with_permission(kw['perm'].upper())
else:
acct_mgr = AccountManager(env)
users = list(set(acct_mgr.get_users()))
if 'locked' in kw.keys() or 'locked' in args:
guard = AccountGuard(env)
locked = []
for user in users:
if guard.user_locked(user):
locked.append(user)
if kw.get('locked', 'True').lower() in ('true', 'yes', '1'):
users = locked
else:
users = list(set(users) - set(locked))
elif 'visit' in kw.keys() or 'visit' in args:
if 'USER_VIEW' not in req.perm:
return msg_no_perm
cols = []
data = {'accounts': fetch_user_data(env, req), 'cls': 'wiki'}
for col in ('email', 'name'):
if col in args:
cols.append(col)
data['cols'] = cols
return Chrome(env).render_template(
req, 'user_table.html', data, 'text/html', True)
if kw.get('format') == 'count' or 'count' in args:
return tag(len(users))
if 'USER_VIEW' not in req.perm:
return msg_no_perm
if 'email' in args or 'name' in args:
# Replace username with full name, add email if available.
for username, name, email in self.env.get_known_users():
if username in users:
if 'name' not in args or name is None:
name = username
if 'email' in args and email is not None:
email = ''.join(['<', email, '>'])
name = ' '.join([name, email])
if not username == name:
users.pop(users.index(username))
users.append(name)
if not users and 'nomatch' in kw.keys():
return format_to_oneliner(env, formatter.context,
kw['nomatch'])
users = sorted(users)
if kw.get('format') == 'list':
return tag.ul([tag.li(Chrome(env).format_author(req, user))
for user in users])
else:
# Default output format: comma-separated list.
return tag(', '.join([Chrome(env).format_author(req, user)
for user in users]))
class WikiRPC(Component):
"""Superset of the
[http://www.jspwiki.org/Wiki.jsp?page=WikiRPCInterface2 WikiRPC API]. """
implements(IXMLRPCHandler)
manipulators = ExtensionPoint(IWikiPageManipulator)
def __init__(self):
self.wiki = WikiSystem(self.env)
def xmlrpc_namespace(self):
return "wiki"
def xmlrpc_methods(self):
yield (None, ((dict, datetime),), self.getRecentChanges)
yield ("WIKI_VIEW", ((int,),), self.getRPCVersionSupported)
yield (None, ((str, str), (str, str, int)), self.getPage)
yield (None, ((str, str, int),), self.getPage, "getPageVersion")
yield (None, ((str, str), (str, str, int)), self.getPageHTML)
yield (None, ((str, str), (str, str, int)), self.getPageHTML, "getPageHTMLVersion")
yield (None, ((list,),), self.getAllPages)
yield (None, ((dict, str), (dict, str, int)), self.getPageInfo)
yield (None, ((dict, str, int),), self.getPageInfo, "getPageInfoVersion")
yield (None, ((bool, str, str, dict),), self.putPage)
yield (None, ((list, str),), self.listAttachments)
yield (None, ((Binary, str),), self.getAttachment)
yield (None, ((bool, str, Binary),), self.putAttachment)
yield (None, ((bool, str, str, str, Binary), (bool, str, str, str, Binary, bool)), self.putAttachmentEx)
yield (None, ((bool, str), (bool, str, int)), self.deletePage)
yield (None, ((bool, str),), self.deleteAttachment)
yield ("WIKI_VIEW", ((list, str),), self.listLinks)
yield ("WIKI_VIEW", ((str, str),), self.wikiToHtml)
def _fetch_page(self, req, pagename, version=None):
# Helper for getting the WikiPage that performs basic checks
page = WikiPage(self.env, pagename, version)
req.perm(page.resource).require("WIKI_VIEW")
if page.exists:
return page
else:
msg = 'Wiki page "%s" does not exist' % pagename
if version is not None:
msg += " at version %s" % version
raise ResourceNotFound(msg)
def _page_info(self, name, when, author, version, comment):
return dict(name=name, lastModified=when, author=author, version=int(version), comment=comment)
def getRecentChanges(self, req, since):
""" Get list of changed pages since timestamp """
since = to_utimestamp(since)
wiki_realm = Resource("wiki")
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
"SELECT name, time, author, version, comment "
"FROM wiki w1 "
"WHERE time >= %s "
"AND version = (SELECT MAX(version) "
" FROM wiki w2 "
" WHERE w2.name=w1.name) "
"ORDER BY time DESC",
(since,),
)
result = []
for name, when, author, version, comment in cursor:
if "WIKI_VIEW" in req.perm(wiki_realm(id=name, version=version)):
result.append(self._page_info(name, from_utimestamp(when), author, version, comment))
return result
def getRPCVersionSupported(self, req):
""" Returns 2 with this version of the Trac API. """
return 2
def getPage(self, req, pagename, version=None):
""" Get the raw Wiki text of page, latest version. """
page = self._fetch_page(req, pagename, version)
return page.text
def getPageHTML(self, req, pagename, version=None):
""" Return latest version of page as rendered HTML, utf8 encoded. """
page = self._fetch_page(req, pagename, version)
fields = {"text": page.text}
for manipulator in self.manipulators:
manipulator.prepare_wiki_page(req, page, fields)
context = Context.from_request(req, page.resource, absurls=True)
html = format_to_html(self.env, context, fields["text"])
return "<html><body>%s</body></html>" % html.encode("utf-8")
def getAllPages(self, req):
""" Returns a list of all pages. The result is an array of utf8 pagenames. """
pages = []
for page in self.wiki.get_pages():
if "WIKI_VIEW" in req.perm(Resource("wiki", page)):
pages.append(page)
return pages
def getPageInfo(self, req, pagename, version=None):
""" Returns information about the given page. """
page = WikiPage(self.env, pagename, version)
req.perm(page.resource).require("WIKI_VIEW")
if page.exists:
last_update = page.get_history().next()
return self._page_info(page.name, last_update[1], last_update[2], page.version, page.comment)
def putPage(self, req, pagename, content, attributes):
""" writes the content of the page. """
page = WikiPage(self.env, pagename)
if page.readonly:
req.perm(page.resource).require("WIKI_ADMIN")
elif not page.exists:
req.perm(page.resource).require("WIKI_CREATE")
else:
req.perm(page.resource).require("WIKI_MODIFY")
page.text = content
if req.perm(page.resource).has_permission("WIKI_ADMIN"):
page.readonly = attributes.get("readonly") and 1 or 0
page.save(attributes.get("author", req.authname), attributes.get("comment"), req.remote_addr)
return True
def deletePage(self, req, name, version=None):
"""Delete a Wiki page (all versions) or a specific version by
including an optional version number. Attachments will also be
deleted if page no longer exists. Returns True for success."""
wp = WikiPage(self.env, name, version)
req.perm(wp.resource).require("WIKI_DELETE")
try:
wp.delete(version)
return True
except:
return False
def listAttachments(self, req, pagename):
""" Lists attachments on a given page. """
for a in Attachment.select(self.env, "wiki", pagename):
if "ATTACHMENT_VIEW" in req.perm(a.resource):
yield pagename + "/" + a.filename
def getAttachment(self, req, path):
""" returns the content of an attachment. """
pagename, filename = os.path.split(path)
attachment = Attachment(self.env, "wiki", pagename, filename)
req.perm(attachment.resource).require("ATTACHMENT_VIEW")
return Binary(attachment.open().read())
def putAttachment(self, req, path, data):
""" (over)writes an attachment. Returns True if successful.
This method is compatible with WikiRPC. `putAttachmentEx` has a more
extensive set of (Trac-specific) features. """
pagename, filename = os.path.split(path)
self.putAttachmentEx(req, pagename, filename, None, data)
return True
def putAttachmentEx(self, req, pagename, filename, description, data, replace=True):
""" Attach a file to a Wiki page. Returns the (possibly transformed)
filename of the attachment.
Use this method if you don't care about WikiRPC compatibility. """
if not WikiPage(self.env, pagename).exists:
raise ResourceNotFound, 'Wiki page "%s" does not exist' % pagename
if replace:
try:
attachment = Attachment(self.env, "wiki", pagename, filename)
req.perm(attachment.resource).require("ATTACHMENT_DELETE")
attachment.delete()
except TracError:
pass
attachment = Attachment(self.env, "wiki", pagename)
req.perm(attachment.resource).require("ATTACHMENT_CREATE")
attachment.author = req.authname
attachment.description = description
attachment.insert(filename, StringIO(data.data), len(data.data))
return attachment.filename
def deleteAttachment(self, req, path):
""" Delete an attachment. """
pagename, filename = os.path.split(path)
if not WikiPage(self.env, pagename).exists:
raise ResourceNotFound, 'Wiki page "%s" does not exist' % pagename
attachment = Attachment(self.env, "wiki", pagename, filename)
req.perm(attachment.resource).require("ATTACHMENT_DELETE")
attachment.delete()
return True
def listLinks(self, req, pagename):
""" ''Not implemented'' """
return []
def wikiToHtml(self, req, text):
""" Render arbitrary Wiki text as HTML. """
return unicode(wiki_to_html(text, self.env, req, absurls=1))
