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 = 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')
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))