def get_tagged_resources(self, req, tags=None, filter=None):
if not self._check_permission(req, None, 'view'):
return
if not tags:
# Cache 'all tagged resources' for better performance.
for resource, tags in self._tagged_resources:
if self.fast_permcheck or \
self._check_permission(req, resource, 'view'):
yield resource, tags
else:
db = self.env.get_db_cnx()
cursor = db.cursor()
sql = """
SELECT ts.name, ts.tag
FROM tags
LEFT JOIN tags ts ON (
tags.tagspace=ts.tagspace AND tags.name=ts.name)
WHERE tags.tagspace=%%s AND tags.tag IN (%s)
ORDER by ts.name
""" % ', '.join(['%s' for t in tags])
args = [self.realm] + list(tags)
cursor.execute(sql, args)
for name, tags in groupby(cursor, lambda row: row[0]):
resource = Resource(self.realm, name)
if self.fast_permcheck or \
self._check_permission(req, resource, 'view'):
yield resource, set([tag[1] for tag in tags])
def get_tagged_resources(self, req, tags):
if not self.check_permission(req.perm, "view"):
return
db = self.env.get_db_cnx()
cursor = db.cursor()
args = [self.realm]
sql = "SELECT DISTINCT name FROM tags WHERE tagspace=%s"
if tags:
sql += " AND tags.tag IN (%s)" % ", ".join(["%s" for t in tags])
args += tags
sql += " ORDER by name"
cursor.execute(sql, args)
resources = {}
for (name,) in cursor:
resource = Resource(self.realm, name)
if self.check_permission(req.perm(resource), "view"):
resources[resource.id] = resource
if not resources:
return
args = [self.realm] + list(resources)
# XXX Is this going to be excruciatingly slow?
sql = "SELECT DISTINCT name, tag FROM tags WHERE tagspace=%%s AND " "name IN (%s) ORDER BY name" % ", ".join(
["%s" for _ in resources]
)
cursor.execute(sql, args)
for name, tags in groupby(cursor, lambda row: row[0]):
resource = resources[name]
yield resource, set([tag[1] for tag in tags])
def get_tagged_resources(self, req, tags):
if not self.check_permission(req.perm, 'view'):
return
db = self.env.get_db_cnx()
cursor = db.cursor()
args = [self.realm]
sql = 'SELECT DISTINCT name FROM tags WHERE tagspace=%s'
if tags:
sql += ' AND tags.tag IN (%s)' % ', '.join(['%s' for t in tags])
args += tags
sql += ' ORDER by name'
cursor.execute(sql, args)
resources = {}
for name, in cursor:
resource = Resource(self.realm, name)
if self.check_permission(req.perm(resource), 'view'):
resources[resource.id] = resource
if not resources:
return
args = [self.realm] + list(resources)
# XXX Is this going to be excruciatingly slow?
sql = 'SELECT DISTINCT name, tag FROM tags WHERE tagspace=%%s AND ' \
'name IN (%s) ORDER BY name' % ', '.join(['%s' for _ in resources])
cursor.execute(sql, args)
for name, tags in groupby(cursor, lambda row: row[0]):
resource = resources[name]
yield resource, set([tag[1] for tag in tags])
def get_timeline_events(self, req, start, stop, filters):
if 'changeset' in filters:
show_files = self.timeline_show_files
show_location = show_files == 'location'
if show_files in ('-1', 'unlimited'):
show_files = -1
elif show_files.isdigit():
show_files = int(show_files)
else:
show_files = 0 # disabled
repos = self.env.get_repository(req.authname)
if self.timeline_collapse:
collapse_changesets = lambda c: (c.author, c.message)
else:
collapse_changesets = lambda c: c.rev
for _, changesets in groupby(repos.get_changesets(start, stop),
key=collapse_changesets):
permitted_changesets = []
for chgset in changesets:
if 'CHANGESET_VIEW' in req.perm('changeset', chgset.rev):
permitted_changesets.append(chgset)
if permitted_changesets:
chgset = permitted_changesets[-1]
yield ('changeset', chgset.date, chgset.author,
(permitted_changesets, chgset.message or '',
show_location, show_files))
def tagged_resources(env,
perm_check,
perm,
realm,
tags=None,
filter=None,
db=None):
"""Return Trac resources including their associated tags.
This is currently known to be a major performance hog.
"""
db = _get_db(env, db)
cursor = db.cursor()
args = [realm]
sql = """
SELECT DISTINCT name
FROM tags
WHERE tagspace=%s"""
if filter:
sql += ''.join([" AND %s" % f for f in filter])
if tags:
sql += " AND tags.tag IN (%s)" % ','.join(['%s' for tag in tags])
args += tags
sql += " ORDER by name"
cursor.execute(sql, args)
# Inlined permission check for efficiency.
resources = {}
for name, in cursor:
resource = Resource(realm, name)
if perm_check(perm(resource), 'view'):
resources[resource.id] = resource
if not resources:
return
args = [realm] + resources.keys()
# DEVEL: Is this going to be excruciatingly slow?
# The explicite resource ID list might even grow beyond some limit.
sql = """
SELECT DISTINCT name, tag
FROM tags
WHERE tagspace=%%s
AND name IN (%s)
ORDER BY name
""" % ', '.join(['%s' for resource in resources])
cursor.execute(sql, args)
for name, tags in groupby(cursor, lambda row: row[0]):
resource = resources[name]
yield resource, set([tag[1] for tag in tags])
def split_in_groups(group):
"""Return list of pagename or (key, sublist) elements"""
groups = []
for key, subgrp in groupby(group, lambda (k,p): k and k[0] or ''):
subgrp = [(k[1:],p) for k,p in subgrp]
if key and len(subgrp) >= minsize:
sublist = split_in_groups(sorted(subgrp))
if len(sublist) == 1:
elt = (key+sublist[0][0], sublist[0][1])
else:
elt = (key, sublist)
groups.append(elt)
else:
for elt in subgrp:
groups.append(elt[1])
def ticket_groups():
groups = []
for v, g in groupby(tickets, lambda t: t[query.group]):
q = Query.from_string(self.env, query_string)
# produce the hint for the group
q.group = q.groupdesc = None
order = q.order
q.order = None
title = _("%(groupvalue)s %(groupname)s tickets matching "
"%(query)s", groupvalue=v, groupname=query.group,
query=q.to_string())
# produce the href for the query corresponding to the group
q.constraints[str(query.group)] = v
q.order = order
href = q.get_href(formatter.context)
groups.append((v, [t for t in g], href, title))
return groups
def tagged_resources(env, perm_check, perm, realm, tags=None, filter=None,
db=None):
"""Return Trac resources including their associated tags.
This is currently known to be a major performance hog.
"""
db = _get_db(env, db)
cursor = db.cursor()
args = [realm]
sql = """
SELECT DISTINCT name
FROM tags
WHERE tagspace=%s"""
if filter:
sql += ''.join([" AND %s" % f for f in filter])
if tags:
sql += " AND tags.tag IN (%s)" % ','.join(['%s' for tag in tags])
args += tags
sql += " ORDER by name"
cursor.execute(sql, args)
# Inlined permission check for efficiency.
resources = {}
for name, in cursor:
resource = Resource(realm, name)
if perm_check(perm(resource), 'view'):
resources[resource.id] = resource
if not resources:
return
args = [realm] + resources.keys()
# DEVEL: Is this going to be excruciatingly slow?
# The explicite resource ID list might even grow beyond some limit.
sql = """
SELECT DISTINCT name, tag
FROM tags
WHERE tagspace=%%s
AND name IN (%s)
ORDER BY name
""" % ', '.join(['%s' for resource in resources])
cursor.execute(sql, args)
for name, tags in groupby(cursor, lambda row: row[0]):
resource = resources[name]
yield resource, set([tag[1] for tag in tags])
def _tagged_resources(self, db=None):
"""The old, uncached method."""
db = self.env.get_db_cnx()
cursor = db.cursor()
sql = """
SELECT name, tag
FROM tags
WHERE tagspace=%s
ORDER by name
"""
self.log.debug('ENTER_PER_REQ_TAG_DB_CHECKOUT')
cursor.execute(sql, (self.realm, ))
self.log.debug('EXIT_PER_REQ_TAG_DB_CHECKOUT')
self.log.debug('ENTER_TAG_GRID_MAKER_UNCACHED')
for name, tags in groupby(cursor, lambda row: row[0]):
resource = Resource(self.realm, name)
yield resource, set([tag[1] for tag in tags])
self.log.debug('EXIT_TAG_GRID_MAKER_UNCACHED')
def _tagged_resources(self, db=None):
"""Cached version."""
db = self.env.get_db_cnx()
cursor = db.cursor()
sql = """
SELECT name, tag
FROM tags
WHERE tagspace=%s
ORDER by name
"""
self.log.debug('ENTER_TAG_DB_CHECKOUT')
cursor.execute(sql, (self.realm, ))
self.log.debug('EXIT_TAG_DB_CHECKOUT')
resources = []
self.log.debug('ENTER_TAG_GRID_MAKER')
counter = 0
for name, tags in groupby(cursor, lambda row: row[0]):
resource = Resource(self.realm, name)
resources.append((resource, set([tag[1] for tag in tags])))
counter += 1
self.log.debug('TAG_GRID_COUNTER: ' + str(counter))
self.log.debug('EXIT_TAG_GRID_MAKER')
return resources
