def search(self, query, vocab_filter=None):
"""Return a resultset of archives.
This is a helper required by `SQLObjectVocabularyBase.searchForTerms`.
"""
if not query:
return self.emptySelectResults()
query = query.lower()
if query.startswith('~'):
query = query.strip('~')
if query.startswith('ppa:'):
query = query[4:]
try:
query_split = query.split('/')
if len(query_split) == 3:
owner_name, distro_name, archive_name = query_split
else:
owner_name, archive_name = query_split
except ValueError:
search_clause = Or(
fti_search(Archive, query), fti_search(Person, query))
else:
search_clause = And(
Person.name == owner_name, Archive.name == archive_name)
clause = And(
self._filter,
get_enabled_archive_filter(
getUtility(ILaunchBag).user, purpose=ArchivePurpose.PPA,
include_public=True),
search_clause)
return self._table.select(
clause, orderBy=self._orderBy, clauseTables=self._clauseTables)
def get_specification_filters(filter, goalstatus=True):
"""Return a list of Storm expressions for filtering Specifications.
:param filters: A collection of SpecificationFilter and/or strings.
Strings are used for text searches.
"""
clauses = []
# ALL is the trump card.
if SpecificationFilter.ALL in filter:
return clauses
# Look for informational specs.
if SpecificationFilter.INFORMATIONAL in filter:
clauses.append(Specification.implementation_status ==
SpecificationImplementationStatus.INFORMATIONAL)
# Filter based on completion. See the implementation of
# Specification.is_complete() for more details.
if SpecificationFilter.COMPLETE in filter:
clauses.append(get_specification_completeness_clause())
if SpecificationFilter.INCOMPLETE in filter:
clauses.append(Not(get_specification_completeness_clause()))
# Filter for goal status.
if goalstatus:
goalstatus = None
if SpecificationFilter.ACCEPTED in filter:
goalstatus = SpecificationGoalStatus.ACCEPTED
elif SpecificationFilter.PROPOSED in filter:
goalstatus = SpecificationGoalStatus.PROPOSED
elif SpecificationFilter.DECLINED in filter:
goalstatus = SpecificationGoalStatus.DECLINED
if goalstatus:
clauses.append(Specification.goalstatus == goalstatus)
if SpecificationFilter.STARTED in filter:
clauses.append(get_specification_started_clause())
# Filter for validity. If we want valid specs only, then we should exclude
# all OBSOLETE or SUPERSEDED specs.
if SpecificationFilter.VALID in filter:
clauses.append(
Not(
Specification.definition_status.is_in([
SpecificationDefinitionStatus.OBSOLETE,
SpecificationDefinitionStatus.SUPERSEDED
])))
# Filter for specification text.
for constraint in filter:
if isinstance(constraint, basestring):
# A string in the filter is a text search filter.
clauses.append(fti_search(Specification, constraint))
return clauses
def search(self, query, vocab_filter=None):
"""Return a resultset of archives.
This is a helper required by `SQLObjectVocabularyBase.searchForTerms`.
"""
if not query:
return self.emptySelectResults()
query = query.lower()
try:
owner_name, archive_name = query.split('/')
except ValueError:
clause = And(
self._filter,
Or(fti_search(Archive, query), fti_search(Person, query)))
else:
clause = And(
self._filter, Person.name == owner_name,
Archive.name == archive_name)
return self._table.select(
clause, orderBy=self._orderBy, clauseTables=self._clauseTables)
def get_specification_filters(filter, goalstatus=True):
"""Return a list of Storm expressions for filtering Specifications.
:param filters: A collection of SpecificationFilter and/or strings.
Strings are used for text searches.
"""
clauses = []
# ALL is the trump card.
if SpecificationFilter.ALL in filter:
return clauses
# Look for informational specs.
if SpecificationFilter.INFORMATIONAL in filter:
clauses.append(
Specification.implementation_status ==
SpecificationImplementationStatus.INFORMATIONAL)
# Filter based on completion. See the implementation of
# Specification.is_complete() for more details.
if SpecificationFilter.COMPLETE in filter:
clauses.append(get_specification_completeness_clause())
if SpecificationFilter.INCOMPLETE in filter:
clauses.append(Not(get_specification_completeness_clause()))
# Filter for goal status.
if goalstatus:
goalstatus = None
if SpecificationFilter.ACCEPTED in filter:
goalstatus = SpecificationGoalStatus.ACCEPTED
elif SpecificationFilter.PROPOSED in filter:
goalstatus = SpecificationGoalStatus.PROPOSED
elif SpecificationFilter.DECLINED in filter:
goalstatus = SpecificationGoalStatus.DECLINED
if goalstatus:
clauses.append(Specification.goalstatus == goalstatus)
if SpecificationFilter.STARTED in filter:
clauses.append(get_specification_started_clause())
# Filter for validity. If we want valid specs only, then we should exclude
# all OBSOLETE or SUPERSEDED specs.
if SpecificationFilter.VALID in filter:
clauses.append(Not(Specification.definition_status.is_in([
SpecificationDefinitionStatus.OBSOLETE,
SpecificationDefinitionStatus.SUPERSEDED])))
# Filter for specification text.
for constraint in filter:
if isinstance(constraint, basestring):
# A string in the filter is a text search filter.
clauses.append(fti_search(Specification, constraint))
return clauses
def searchBinaryPackages(self, text):
"""See `IDistroArchSeries`."""
from lp.soyuz.model.publishing import BinaryPackagePublishingHistory
origin = [
BinaryPackageRelease,
Join(
BinaryPackagePublishingHistory,
BinaryPackagePublishingHistory.binarypackagerelease ==
BinaryPackageRelease.id),
Join(
BinaryPackageName,
BinaryPackageRelease.binarypackagename ==
BinaryPackageName.id)]
find_spec = [BinaryPackageRelease, BinaryPackageName]
archives = self.distroseries.distribution.getArchiveIDList()
clauses = [
BinaryPackagePublishingHistory.distroarchseries == self,
BinaryPackagePublishingHistory.archiveID.is_in(archives),
BinaryPackagePublishingHistory.status.is_in(
active_publishing_status)]
order_by = [BinaryPackageName.name]
if text:
ranking = rank_by_fti(BinaryPackageRelease, text)
find_spec.append(ranking)
clauses.append(
Or(
fti_search(BinaryPackageRelease, text),
BinaryPackageName.name.contains_string(text.lower())))
order_by.insert(0, ranking)
result = IStore(BinaryPackageName).using(*origin).find(
tuple(find_spec), *clauses).config(distinct=True).order_by(
*order_by)
# import here to avoid circular import problems
from lp.soyuz.model.distroarchseriesbinarypackagerelease import (
DistroArchSeriesBinaryPackageRelease)
# Create a function that will decorate the results, converting
# them from the find_spec above into DASBPRs.
def result_to_dasbpr(row):
return DistroArchSeriesBinaryPackageRelease(
distroarchseries=self, binarypackagerelease=row[0])
# Return the decorated result set so the consumer of these
# results will only see DSPs.
return DecoratedResultSet(result, result_to_dasbpr)
def searchBinaryPackages(self, text):
"""See `IDistroArchSeries`."""
from lp.soyuz.model.publishing import BinaryPackagePublishingHistory
origin = [
BinaryPackageRelease,
Join(
BinaryPackagePublishingHistory,
BinaryPackagePublishingHistory.binarypackagerelease ==
BinaryPackageRelease.id),
Join(
BinaryPackageName,
BinaryPackageRelease.binarypackagename ==
BinaryPackageName.id)]
find_spec = [BinaryPackageRelease, BinaryPackageName]
archives = self.distroseries.distribution.getArchiveIDList()
clauses = [
BinaryPackagePublishingHistory.distroarchseries == self,
BinaryPackagePublishingHistory.archiveID.is_in(archives),
BinaryPackagePublishingHistory.dateremoved == None]
order_by = [BinaryPackageName.name]
if text:
ranking = rank_by_fti(BinaryPackageRelease, text)
find_spec.append(ranking)
clauses.append(
Or(
fti_search(BinaryPackageRelease, text),
BinaryPackageName.name.contains_string(text.lower())))
order_by.insert(0, ranking)
result = IStore(BinaryPackageName).using(*origin).find(
tuple(find_spec), *clauses).config(distinct=True).order_by(
*order_by)
# import here to avoid circular import problems
from lp.soyuz.model.distroarchseriesbinarypackagerelease import (
DistroArchSeriesBinaryPackageRelease)
# Create a function that will decorate the results, converting
# them from the find_spec above into DASBPRs.
def result_to_dasbpr(row):
return DistroArchSeriesBinaryPackageRelease(
distroarchseries=self, binarypackagerelease=row[0])
# Return the decorated result set so the consumer of these
# results will only see DSPs.
return DecoratedResultSet(result, result_to_dasbpr)
def search(self, query, vocab_filter=None):
"""See `SQLObjectVocabularyBase.search`.
We find specs where query is in the text of name or title, or matches
the full text index and then filter out ineligible specs using
`_filter_specs`.
"""
if not query:
return CountableIterator(0, [])
spec = self._spec_from_url(query)
if self._is_valid_candidate(spec):
return CountableIterator(1, [spec])
return Store.of(self.context).find(
Specification,
fti_search(Specification, query),
self._exclude_blocked_query(),
).order_by(self._order_by())
def search(self, query, vocab_filter=None):
"""See `SQLObjectVocabularyBase.search`.
We find specs where query is in the text of name or title, or matches
the full text index and then filter out ineligible specs using
`_filter_specs`.
"""
if not query:
return CountableIterator(0, [])
spec = self._spec_from_url(query)
if self._is_valid_candidate(spec):
return CountableIterator(1, [spec])
return Store.of(self.context).find(
Specification,
fti_search(Specification, query),
self._exclude_blocked_query(),
).order_by(self._order_by())
def findSimilar(summary, product=None, distribution=None):
"""Return the FAQs similar to summary.
See `IFAQTarget.findSimilarFAQs` for details.
"""
assert not (product and distribution), (
'only one of product or distribution should be provided')
if product:
target_constraint = 'product = %s' % sqlvalues(product)
elif distribution:
target_constraint = 'distribution = %s' % sqlvalues(distribution)
else:
raise AssertionError('must provide product or distribution')
phrases = nl_phrase_search(summary, FAQ, target_constraint)
if not phrases:
# No useful words to search on in that summary.
return FAQ.select('1 = 2')
return FAQ.select(
And(target_constraint, fti_search(FAQ, phrases, ftq=False)),
orderBy=[
rank_by_fti(FAQ, phrases, ftq=False), "-FAQ.date_created"])
def findSimilar(summary, product=None, distribution=None):
"""Return the FAQs similar to summary.
See `IFAQTarget.findSimilarFAQs` for details.
"""
assert not (product and distribution), (
'only one of product or distribution should be provided')
if product:
target_constraint = 'product = %s' % sqlvalues(product)
elif distribution:
target_constraint = 'distribution = %s' % sqlvalues(distribution)
else:
raise AssertionError('must provide product or distribution')
phrases = nl_phrase_search(summary, FAQ, target_constraint)
if not phrases:
# No useful words to search on in that summary.
return FAQ.select('1 = 2')
return FAQ.select(
And(target_constraint, fti_search(FAQ, phrases, ftq=False)),
orderBy=[
rank_by_fti(FAQ, phrases, ftq=False), "-FAQ.date_created"])
def search(self, text):
"""See ICveSet."""
return Cve.select(
fti_search(Cve, text), distinct=True, orderBy='-datemodified')