def process_request(self, req):
req.perm.require('BROWSER_VIEW')
presel = req.args.get('preselected')
if presel and (presel + '/').startswith(req.href.browser() + '/'):
req.redirect(presel)
path = req.args.get('path', '/')
rev = req.args.get('rev', '')
if rev.lower() in ('', 'head'):
rev = None
format = req.args.get('format')
order = req.args.get('order', 'name').lower()
desc = req.args.has_key('desc')
xhr = req.get_header('X-Requested-With') == 'XMLHttpRequest'
rm = RepositoryManager(self.env)
all_repositories = rm.get_all_repositories()
reponame, repos, path = rm.get_repository_by_path(path)
# Repository index
show_index = not reponame and path == '/'
if show_index:
if repos and (as_bool(all_repositories[''].get('hidden'))
or not repos.is_viewable(req.perm)):
repos = None
if not repos and reponame:
raise ResourceNotFound(_("Repository '%(repo)s' not found",
repo=reponame))
if reponame and reponame != repos.reponame: # Redirect alias
qs = req.query_string
req.redirect(req.href.browser(repos.reponame or None, path)
+ ('?' + qs if qs else ''))
reponame = repos.reponame if repos else None
# Find node for the requested path/rev
context = web_context(req)
node = None
display_rev = lambda rev: rev
if repos:
try:
if rev:
rev = repos.normalize_rev(rev)
# If `rev` is `None`, we'll try to reuse `None` consistently,
# as a special shortcut to the latest revision.
rev_or_latest = rev or repos.youngest_rev
node = get_existing_node(req, repos, path, rev_or_latest)
except NoSuchChangeset, e:
raise ResourceNotFound(e.message,
_('Invalid changeset number'))
context = context.child(repos.resource.child('source', path,
version=rev_or_latest))
display_rev = repos.display_rev
def _get_remote_trac(self, rintertrac):
try:
intertrac = self._intertracs[rintertrac]
except KeyError:
raise ResourceNotFound("Remote Trac '%s' is unknown." % rintertrac,
"Invalid InterTrac alias")
try:
intertrac['url']
except KeyError:
raise ResourceNotFound(
"Remote Trac '%s' has no address configured." % rintertrac,
"Invalid InterTrac alias")
return intertrac
def id_is_valid(num):
try:
return 0 < int(num) <= 1L << 31
except ValueError:
raise ResourceNotFound(
_("TracForm %(form_id)s does not exist.", form_id=num),
_("Invalid form number"))
def load_manager(self, neighborhood):
"""Load global environment or product environment given its prefix
"""
if neighborhood._realm == 'global':
# FIXME: ResourceNotFound if neighborhood ID != None ?
prefix = GLOBAL_PRODUCT
elif neighborhood._realm == 'product':
prefix = neighborhood._id
else:
raise ResourceNotFound(_(u'Unsupported neighborhood %(realm)s',
realm=neighborhood._realm))
try:
return lookup_product_env(self.env, prefix)
except LookupError:
raise ResourceNotFound(_(u'Unknown product prefix %(prefix)s',
prefix=prefix))
def process_request(self, req):
page_name = req.args.get('page_name', '')
if page_name == '':
page_name = 'index'
# Add breadcrumb
package_name, filename = self._get_package_and_filename(page_name)
index_file = filename[:-len('.txt')] + '/index.txt'
if not self._resource_exists(package_name, filename):
# check if it is a folder, then match with index
if self._resource_exists(package_name, index_file):
filename = index_file
else:
error_msg = _('Page %(page_name)s not found',
page_name=page_name)
raise ResourceNotFound(error_msg)
utf8_string = resource_string(package_name, filename)
help_contents = utf8_string.decode('UTF-8')
# add navigation bar
self._set_prev_next(req)
data = dict(context=Context.from_request(req),
contents=help_contents,
page_name=page_name)
return ('agilo_help.html', data, 'text/html')
def __init__(self, env, name=None, db=None):
self.env = env
if name:
if not db:
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute("SELECT time,description,summery,header,body,argnum FROM blogpart "
"WHERE name=%s", (name,))
row = cursor.fetchone()
if not row:
raise ResourceNotFound(_('BlogPart %(name)s does not exist.',
name=name))
self.name = self._old_name = name
self.time = row[0] and datetime.fromtimestamp(int(row[0]), utc) or None
self.description = row[1] or ''
self.summery = row[2] or ''
self.header = row[3] or ''
self.body = row[4] or ''
self.argnum = row[5] or 0
else:
self.name = self._old_name = None
self.time = None
self.description = None
self.summery = None
self.header = None
self.body = None
self.argnum = None
def _fetch_ticket(self, tkt_id):
row = None
if self.id_is_valid(tkt_id):
# Fetch the standard ticket fields
for row in self.env.db_query(
"SELECT %s FROM ticket WHERE id=%%s" %
','.join(self.std_fields), (tkt_id, )):
break
if not row:
raise ResourceNotFound(
_("Ticket %(id)s does not exist.", id=tkt_id),
_("Invalid ticket number"))
self.id = tkt_id
for i, field in enumerate(self.std_fields):
value = row[i]
if field in self.time_fields:
self.values[field] = from_utimestamp(value)
elif value is None:
self.values[field] = empty
else:
self.values[field] = value
# Fetch custom fields if available
for name, value in self.env.db_query(
"""
SELECT name, value FROM ticket_custom WHERE ticket=%s
""", (tkt_id, )):
if name in self.custom_fields:
if name in self.time_fields:
self.values[name] = _db_str_to_datetime(value)
elif value is None:
self.values[name] = empty
else:
self.values[name] = value
def __init__(self,
env,
id=None,
title=u'',
author=u'',
mimetype='text/plain',
data=u'',
time=None):
self.env = env
self.id = None
self.title = title
self.author = author
self.mimetype = mimetype
self.data = data
self.time = time
self.resource = Resource('pastebin', self.id)
if id is not None and self.id_is_valid(id):
row = None
db = env.get_db_cnx()
cursor = db.cursor()
cursor.execute(
'SELECT title, author, mimetype, data, time '
'FROM pastes WHERE id = %s', (id, ))
row = cursor.fetchone()
if row:
self.id = id
self.title, self.author, self.mimetype, self.data, time = row
self.time = datetime.fromtimestamp(time, utc)
else:
raise ResourceNotFound(_('Paste %s does not exist.' % id),
_('Invalid Paste Number'))
def _get_tags(self, req, resource):
if not resource_exists(self.env, resource):
raise ResourceNotFound('Resource "%r" does not exists' % resource)
# Workaround for ServiceException when calling TagSystem.get_tags().
provider = [p for p in self.tag_system.tag_providers
if p.get_taggable_realm() == resource.realm][0]
# Type conversion needed for content transfer of Python set objects.
return list(provider.get_resource_tags(req, resource))
def deleteAttachment(self, req, ticket, filename):
""" Delete an attachment. """
if not model.Ticket(self.env, ticket).exists:
raise ResourceNotFound('Ticket "%s" does not exists' % ticket)
attachment = Attachment(self.env, 'ticket', ticket, filename)
req.perm(attachment.resource).require('ATTACHMENT_DELETE')
attachment.delete()
return True
def comment(self, req):
realm = req.args.get('obj_id')
object_id = req.path_info.split('/')[-1]
if realm == 'ticket':
return self._comment_ticket(req, object_id)
elif realm == 'milestone':
return self._comment_milestone(req, object_id)
raise ResourceNotFound('Unsupported realm %s.' % realm,
'Invalid Realm')
def _fetch(self, name, db=None):
for row in self.env.db_query("""
SELECT name, due, completed, description
FROM milestone WHERE name=%s
""", (name,)):
self._from_database(row)
break
else:
raise ResourceNotFound(_("Milestone %(name)s does not exist.",
name=name), _("Invalid milestone name"))
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 _comment_ticket(self, req, tkt_id):
tkt = Ticket(self.env, tkt_id)
if not tkt.exists:
raise ResourceNotFound('Ticket %s does not exist.' % tkt_id,
'Invalid Ticket Id')
req.perm.require('TICKET_MODIFY', Resource('ticket', tkt.resource))
changes = TicketModule(self.env).rendered_changelog_entries(req, tkt)
return 'itteco_ticket_comment.html', {
'ticket': tkt,
'changes': changes
}, 'text/html'
def process_request(self, req):
"""Override for TicketModule process_request"""
ticketid = req.args.get('id')
productid = req.args.get('productid', '')
if not ticketid:
# if /newticket is executed in global scope (from QCT), redirect
# the request to /products/<first_product_in_DB>/newticket
if not productid and \
not isinstance(self.env, ProductEnvironment):
default_product = self.env.config.get('ticket',
'default_product')
products = Product.select(self.env, {'fields': ['prefix']})
prefixes = [prod.prefix for prod in products]
if not default_product or default_product not in prefixes:
default_product = products[0].prefix
req.redirect(req.href.products(default_product, 'newticket'))
return self._process_newticket_request(req)
if req.path_info in ('/newticket', '/products'):
raise TracError(_("id can't be set for a new ticket request."))
if isinstance(self.env, ProductEnvironment):
ticket = Ticket(self.env, ticketid)
if productid and ticket['product'] != productid:
msg = "Ticket %(id)s in product '%(prod)s' does not exist."
raise ResourceNotFound(_(msg, id=ticketid, prod=productid),
_("Invalid ticket number"))
return self._process_ticket_request(req)
# executed in global scope -> assume ticketid=UID, redirect to product
with self.env.db_direct_query as db:
rows = db("""SELECT id,product FROM ticket WHERE uid=%s""",
(ticketid, ))
if not rows:
msg = "Ticket with uid %(uid)s does not exist."
raise ResourceNotFound(_(msg, uid=ticketid),
_("Invalid ticket number"))
tid, prefix = rows[0]
req.redirect(req.href.products(prefix, 'ticket', tid))
def _get_rtcc(self, status):
try:
rtcc = self._rtccs[status]
except KeyError:
raise ResourceNotFound("status '%s' is unknown." % status)
if not isinstance(rtcc, unicode):
try:
rtcc['component']
except KeyError:
raise ResourceNotFound("%s.component is unknown." % status)
try:
rtcc['local_cfield']
except KeyError:
raise ResourceNotFound("%s.local_cfield is unknown." % status)
try:
rtcc['remote_cfield']
except KeyError:
raise ResourceNotFound("%s.remote_cfield is unknown." % status)
try:
rtcc['remote_intertrac']
except KeyError:
raise ResourceNotFound("%s.remote_intertrac is unknown." %
status)
try:
rtcc['type']
except KeyError:
raise ResourceNotFound("%s.type is unknown." % status)
return rtcc
def get_existing_node(req, repos, path, rev):
try:
return repos.get_node(path, rev)
except NoSuchNode, e:
# TRANSLATOR: You can 'search' in the repository history... (link)
search_a = tag.a(_("search"),
href=req.href.log(repos.reponame or None, path,
rev=rev, mode='path_history'))
raise ResourceNotFound(tag(
tag.p(e.message, class_="message"),
tag.p(tag_("You can %(search)s in the repository history to see "
"if that path existed but was later removed",
search=search_a))))
def _comment_milestone(self, req, mil_id):
milestone = StructuredMilestone(self.env, mil_id)
if not milestone.exists:
raise ResourceNotFound('Milestone %s does not exist.' % mil_id,
'Invalid Milestone Name')
req.perm.require('MILESTONE_MODIFY', milestone.resource)
changes = TicketModule(self.env).rendered_changelog_entries(
req, milestone.ticket)
return 'itteco_milestone_comment.html', {
'milestone': milestone,
'changes': changes
}, 'text/html'
def _render_view(self, req, id):
"""Retrieve the report results and pre-process them for rendering."""
for title, sql, description in self.env.db_query("""
SELECT title, query, description from report WHERE id=%s
""", (id,)):
break
else:
raise ResourceNotFound(_("Report {%(num)s} does not exist.",
num=id), _("Invalid Report Number"))
try:
args = self.get_var_args(req)
except ValueError, e:
raise TracError(_("Report failed: %(error)s", error=e))
def get_report(self, id):
try:
number = int(id)
except (ValueError, TypeError):
pass
else:
for title, description, sql in self.env.db_query("""
SELECT title, description, query from report WHERE id=%s
""", (number,)):
return title, description, sql
raise ResourceNotFound(_("Report {%(num)s} does not exist.", num=id),
_("Invalid Report Number"))
def __init__(self, env, name=None, db=None):
self.env = env
self.name = self._old_name = self.time = self.description = None
if name:
for time, description in self.env.db_query("""
SELECT time, description FROM version WHERE name=%s
""", (name,)):
self.name = self._old_name = name
self.time = from_utimestamp(time) if time else None
self.description = description or ''
break
else:
raise ResourceNotFound(_("Version %(name)s does not exist.",
name=name))
def _fetch_crash_by_id(self, id, must_exist=True):
row = None
if self.id_is_valid(id):
# Fetch the standard crashdump fields
for row in self.env.db_query(
"SELECT id,%s FROM crashdump WHERE id=%%s" %
','.join(self.std_fields), (id, )):
break
if not row and must_exist:
raise ResourceNotFound(_("Crash %(id)s does not exist.", id=id),
_("Invalid crash identifier"))
if row:
self.id = id
self._load_from_record(row)
def __init__(self, env, name=None):
self.env = env
self.name = self._old_name = self.owner = self.description = None
if name:
for owner, description in self.env.db_query(
"""
SELECT owner, description FROM component WHERE name=%s
""", (name, )):
self.name = self._old_name = name
self.owner = owner or None
self.description = description or ''
break
else:
raise ResourceNotFound(
_("Component %(name)s does not exist.", name=name))
def __init__(self, env, name=None, db=None):
"""Create an undefined milestone or fetch one from the database,
if `name` is given.
In the latter case however, raise `~trac.resource.ResourceNotFound`
if a milestone of that name doesn't exist yet.
"""
self.env = env
if name:
if not self.cache.fetchone(name, self):
raise ResourceNotFound(
_("Milestone %(name)s does not exist.", name=name),
_("Invalid milestone name"))
else:
self.cache.factory((None, None, None, ''), self)
def process_request(self, req):
"""Override for TicketModule process_request"""
ticketid = req.args.get('id')
productid = req.args.get('productid', '')
if ticketid:
if req.path_info in ('/newticket', '/products'):
raise TracError(_("id can't be set for a new ticket request."))
ticket = Ticket(self.env, ticketid)
if productid and ticket['product'] != productid:
msg = "Ticket %(id)s in product '%(prod)' does not exist."
raise ResourceNotFound(_(msg, id=ticketid, prod=productid),
_("Invalid ticket number"))
return self._process_ticket_request(req)
return self._process_newticket_request(req)
def _refresh_ticket(self):
rts = RemoteTicketSystem(self.env)
remote_trac = rts.get_remote_trac(self.remote_name)['url']
xmlrpc_addr = Href(remote_trac).rpc()
server = xmlrpclib.ServerProxy(xmlrpc_addr)
try:
tkt_vals = server.ticket.get(self.id)
except xmlrpclib.ProtocolError, e:
msg = ("Could not contact remote Trac '%s' at %s. "
"Received error %s, %s")
log = ("XML-RPC ProtocolError contacting Trac %s at %s, "
"errcode=%s, errmsg='%s'")
args = (self.remote_name, xmlrpc_addr, e.errcode, e.errmsg)
self.env.log.warn(log, *args)
raise ResourceNotFound(msg % args, "Uncontactable server")
def _resolve_object_and_action(self, dbp):
self.action = self.req.args.get('action', None)
if not self.action in ['view', 'edit', 'list', 'new', 'delete', None]:
raise ValueError("Unknown action '%s'" % (self.action, ))
if self.resource_type is None:
self.obj = None
self.action = 'index'
elif self.resource_type == 'search':
if not self.resource_id in [
'no_spec', 'by_filter', 'artifact', 'spec', 'relatedpages',
'specdetails'
]:
raise Exception("Unknown search '%s'" % (self.resource_id, ))
self.obj = self.resource_id
self.action = 'list'
elif self.resource_type == 'pages':
self.obj = None
self.action = 'list'
elif self.resource_type == 'tracking':
self.obj = self.resource_id # start || end
self.action = 'new'
elif self.resource_type in ['spec', 'artifact']:
if self.resource_id is None:
if self.resource_type == 'spec':
self.obj = Entity
elif self.resource_type == 'artifact':
self.obj = Instance
else:
if not dbp:
raise ValueError(
"Cannot load the resource. No database pool provided.")
dbp.load_item(self.resource_id)
self.obj = dbp.pool.get_item(self.resource_id)
if self.obj is None:
raise ResourceNotFound(
"No resource found with identifier '%s'" %
(self.resource_id, ))
if self.action is None: # default action depends on the instance's meta-level
if self.obj is Entity:
self.action = 'index'
elif isinstance(self.obj, type):
self.action = 'list'
else:
self.action = 'view'
def process_request(self, req):
if not self.repository: # pragma: no cover
return super(GitHubBrowser, self).process_request(req)
rev = req.args.get('rev')
path = req.args.get('path')
rm = RepositoryManager(self.env)
reponame, repos, path = rm.get_repository_by_path(path)
key = 'repository' if is_default(reponame) else '%s.repository' % reponame
gh_repo = self.config.get('github', key)
try:
rev = repos.normalize_rev(rev)
except NoSuchChangeset, e:
raise ResourceNotFound(e.message, _('Invalid Changeset Number'))
def __init__(self, env, name=None, db=None):
if not self.ticket_col:
self.ticket_col = self.type
self.env = env
if name:
for value, in self.env.db_query("""
SELECT value FROM enum WHERE type=%s AND name=%s
""", (self.type, name)):
self.value = self._old_value = value
self.name = self._old_name = name
break
else:
raise ResourceNotFound(_("%(type)s %(name)s does not exist.",
type=self.type, name=name))
else:
self.value = self._old_value = None
self.name = self._old_name = None
def pre_process_request(self, req, handler):
"""pre process request filter"""
pid = None
match = PRODUCT_RE.match(req.path_info)
if match:
dispatcher = self.env[RequestDispatcher]
if dispatcher is None:
raise TracError('Unable to load RequestDispatcher.')
pid = match.group('pid')
if pid:
products = Product.select(self.env, where={'prefix': pid})
if pid and len(products) == 1:
req.args['productid'] = pid
req.args['product'] = products[0].name
if handler is self and match.group('pathinfo') not in ('',
'/'):
# select a new handler
environ = req.environ.copy()
pathinfo = environ['PATH_INFO'].split('/')
pathinfo = '/'.join(pathinfo[:1] + pathinfo[3:])
environ['PATH_INFO'] = pathinfo
newreq = Request(environ, lambda *args, **kwds: None)
new_handler = None
for hndlr in dispatcher.handlers:
if hndlr is not self and hndlr.match_request(newreq):
new_handler = hndlr
req.args.update(newreq.args)
break
if new_handler is None:
if req.path_info.endswith('/'):
target = req.path_info.rstrip('/').encode('utf-8')
if req.query_string:
target += '?' + req.query_string
req.redirect(req.href + target, permanent=True)
raise HTTPNotFound('No handler matched request to %s',
req.path_info)
handler = new_handler
else:
raise ResourceNotFound(
_("Product %(id)s does not exist.", id=pid),
_("Invalid product id"))
return handler
