def emails_for_person(person, session=None):
"""
Given a login, a full name, or an email, returns the corresponding email.
This function must be imported from a running app, or a session must
be provided.
"""
# we import the session here, to avoid the exception when debianutils is
# imported from elsewhere than the app
if session is None:
from firewoes.web.app import session
if "@" in person:
return [person]
results = (session.query(DebianMaintainer)
.filter(DebianMaintainer.name == person)
.all())
if results:
return [res.email for res in results]
result = (session.query(DebianMaintainer)
.filter(DebianMaintainer.email == person + "@debian.org")
.first())
if result:
return [result.email]
return []
def name_contains(self, name, limit=None):
""" returns the packages whose name contains name """
elems = session.query(Sut.name).filter(
Sut.name.contains(name)).distinct()
if limit is None:
elems = elems.all()
else:
elems = elems.limit(limit)
# we remove 'name' if it's here
elems = [e for e in elems if e.name != name]
return to_dict(elems)
def id(self, id):
try:
elem = session.query(self.fh_class).filter(
self.fh_class.id == id).first()
except:
raise Http500Error
try:
id = elem.id # raises error if the element doesn't exist
except:
raise Http404Error("This element (%s, %s) doesn't exist."
% (self.fh_class.__name__, id))
return to_dict(elem)
def _suggestions(self, current_args):
"""
Returns suggestions for the current search, with probably better
results.
"""
if current_args.get("sut_name"):
elems = (session.query(Sut.name,
func.count(Result.id).label("count"))
.filter(Sut.name.contains(current_args["sut_name"]))
.filter(Result.analysis_id == Analysis.id)
.filter(Analysis.metadata_id == Metadata.id)
.filter(Metadata.sut_id == Sut.id)
.group_by(Sut.name)
.order_by(desc("count"))
.all()
)
suggestions = [dict(sut_name=sut.name) for sut in elems]
elif current_args.get("maintainer"):
elems = (session.query(DebianMaintainer.name,
func.count(Result.id).label("count"))
.filter(DebianMaintainer.name.ilike(
"%" + current_args["maintainer"] + "%"))
# maybe postgresql-specific
.filter(Result.analysis_id == Analysis.id)
.filter(Analysis.metadata_id == Metadata.id)
.filter(Metadata.sut_id == Sut.id)
.filter(Sut.name == DebianPackagePeopleMapping.package_name)
.filter(DebianPackagePeopleMapping.maintainer_email ==
DebianMaintainer.email)
.group_by(DebianMaintainer.name)
.order_by(desc("count"))
.all()
)
suggestions = [dict(maintainer=maint.name) for maint in elems]
else:
suggestions = []
return suggestions
def count_per_generator(self):
elems = (
session.query(Generator.name,
func.count(Result.id).label("count"))
.join(Sut, Sut.id == self.package_id)
.join(Metadata, and_(Sut.id == Metadata.sut_id,
Metadata.generator_id==Generator.id))
.join(Analysis, Analysis.metadata_id == Metadata.id)
.outerjoin(Result, Result.analysis_id == Analysis.id)
.group_by(Generator.name)
.order_by(desc("count"))
.all())
return elems
def with_most_results(self, limit=5):
"""
Returns the list of packages which have the most results.
"""
elems = (session.query(Sut.name, func.count(Result.id).label("count"))
.filter(Result.analysis_id == Analysis.id)
.filter(Analysis.metadata_id == Metadata.id)
.filter(Metadata.sut_id == Sut.id)
.group_by(Sut.name)
.order_by(desc("count"))
.limit(limit)
.all()
)
return to_dict(elems)
def random_results(self, limit=5):
"""
Returns the last results.
"""
elems = (session.query(Result.id, Message.text, Sut.name)
.filter(Result.message_id == Message.id)
.filter(Result.analysis_id == Analysis.id)
.filter(Analysis.metadata_id == Metadata.id)
.filter(Metadata.sut_id == Sut.id)
.order_by(func.random())
# PostgreSQL-specific, maybe func.rand() for other back-ends
.limit(limit)
.all()
)
return to_dict(elems)
def versions(self, name):
elems = session.query(Generator.version).filter(
Generator.name == name).all()
return to_dict(elems)
def unique_by_name(self):
elems = session.query(Generator.name).distinct().all()
return to_dict(elems)
def all(self):
elems = session.query(self.fh_class).order_by(Generator.name).all()
return to_dict(elems)
def all(self):
elem = session.query(self.fh_class).all()
return to_dict(elem)
def filter(self, request_args, offset=None):
"""
returns the results corresponding to the args in request_args,
along with a drill down menu
request_args: GET variables dict (?generator_name=foo&bar=foobar...)
offset: number of results (if not set, this value is read in config)
"""
import filters
# we need the arguments without "page" for the menu
# ("page" would add page=foo on the menu links, which we don't want)
args_without_page = request_args.copy()
try:
del(args_without_page["page"])
except:
pass
query = (session.query(
Result.id,
Result.type.label("result_type"),
File.givenpath.label("location_file"),
Function.name.label("location_function"),
Message.text.label("message_text"),
Message.id.label("message_id"),
Point, Range,
Sut.name.label("sut_name"),
Sut.version.label("sut_version"),
Sut.type.label("sut_type"),
Sut.release.label("sut_release"),
Sut.buildarch.label("sut_buildarch"),
Generator.name.label("generator_name"),
Generator.version.label("generator_version"),
Result.testid.label("testid"))
.outerjoin(Location, File, Function, Point, Analysis,
Metadata, Generator, Sut, Message)
.outerjoin(Range, Location.range_id==Range.id)
)
menu = filters.Menu(args_without_page)
query = menu.filter_sqla_query(query)
# we get the page number and the offset
try: page = int(request_args["page"])
except: page = 1
try: offset = int(request_args["offset"])
except: offset = offset or app.config["SEARCH_RESULTS_OFFSET"]
# we calculate the range of results
start = (page - 1) * offset
end = start + offset
menu=menu.get(session,
max_items=app.config["SEARCH_MENU_MAX_NUMBER_OF_ELEMENTS"])
results_all_count = query.count()
results=to_dict(query.slice(start, end).all())
# do we need to suggest things?
if len(results) == 0:
suggestions = self._suggestions(request_args)
else:
suggestions = []
return dict(results=results,
menu=menu,
page=page,
offset=offset,
results_all_count=results_all_count,
results_range = (start+1, start+len(results)),
# to avoid 1-10 of 5 results
suggestions=suggestions,
)
def all(self):
elems = session.query(Result.id).all()
return to_dict(elems)
def versions(self, name):
elems = session.query(Sut).filter(
Sut.name==name).order_by(Sut.version).all()
return to_dict(elems)
def id(self, id):
elem = session.query(Analysis).filter(Analysis.id == id).first()
elem = to_dict(elem)
elem['results'] = to_dict(session.query(
Result.id).filter(Result.analysis_id == id).all())
return elem
def all(self):
elems = session.query(Analysis.id,
Generator.name.label("generator_name")).filter(
and_(Analysis.metadata_id == Metadata.id,
Metadata.generator_id == Generator.id)).all()
return to_dict(elems)
