33
33
'DistributionSourcePackageVocabulary',
34
34
'DistributionVocabulary',
35
35
'DistroSeriesDerivationVocabulary',
36
'DistroSeriesDifferencesVocabulary',
37
36
'DistroSeriesVocabulary',
38
37
'FeaturedProjectVocabulary',
39
38
'FilteredDistroSeriesVocabulary',
171
167
from lp.registry.interfaces.sourcepackage import ISourcePackage
172
168
from lp.registry.model.distribution import Distribution
173
169
from lp.registry.model.distroseries import DistroSeries
174
from lp.registry.model.distroseriesdifference import DistroSeriesDifference
175
170
from lp.registry.model.distroseriesparent import DistroSeriesParent
176
171
from lp.registry.model.featuredproject import FeaturedProject
177
172
from lp.registry.model.karma import KarmaCategory
199
194
from lp.soyuz.model.binarypackagename import BinaryPackageName
200
195
from lp.soyuz.model.binarypackagerelease import BinaryPackageRelease
201
196
from lp.soyuz.model.distroarchseries import DistroArchSeries
202
from lp.soyuz.model.publishing import SourcePackagePublishingHistory
197
from lp.soyuz.model.publishing import (
198
SourcePackagePublishingHistory,
203
200
from lp.soyuz.model.sourcepackagerelease import SourcePackageRelease
1869
1866
return self.find_terms(where)
1872
class DistroSeriesDifferencesVocabulary:
1873
"""A vocabulary source for differences relating to a series.
1875
Specifically, all `DistroSeriesDifference`s relating to a derived series.
1878
implements(IHugeVocabulary)
1880
displayname = "Choose a difference"
1881
step_title = 'Search'
1883
def __init__(self, context):
1884
"""Create a new vocabulary for the context.
1886
:type context: `IDistroSeries`.
1888
assert IDistroSeries.providedBy(context)
1889
self.distroseries = context
1892
"""See `IIterableVocabulary`."""
1893
return self.searchForDifferences().count()
1896
"""See `IIterableVocabulary`."""
1897
for difference in self.searchForDifferences():
1898
yield self.toTerm(difference)
1900
def __contains__(self, value):
1901
"""See `IVocabulary`."""
1903
IDistroSeriesDifference.providedBy(value) and
1904
value.derived_series == self.distroseries)
1906
def getTerm(self, value):
1907
"""See `IVocabulary`."""
1908
if value not in self:
1909
raise LookupError(value)
1910
return self.toTerm(value)
1912
def getTermByToken(self, token):
1913
"""See `IVocabularyTokenized`."""
1914
if not token.isdigit():
1915
raise LookupError(token)
1916
difference = IStore(DistroSeriesDifference).get(
1917
DistroSeriesDifference, int(token))
1918
if difference is None:
1919
raise LookupError(token)
1920
elif difference.derived_series != self.distroseries:
1921
raise LookupError(token)
1923
return self.toTerm(difference)
1927
"""Return the term for a `DistroSeriesDifference`."""
1928
return SimpleTerm(dsd, dsd.id)
1930
def searchForTerms(self, query=None):
1931
"""See `IHugeVocabulary`."""
1932
results = self.searchForDifferences()
1933
return CountableIterator(results.count(), results, self.toTerm)
1935
def searchForDifferences(self):
1936
"""The set of `DistroSeriesDifference`s related to the context.
1938
:return: `IResultSet` yielding `IDistroSeriesDifference`.
1940
return DistroSeriesDifference.getForDistroSeries(self.distroseries)
1943
1869
class PillarVocabularyBase(NamedSQLObjectHugeVocabulary):
1944
1870
"""Active `IPillar` objects vocabulary."""
1945
1871
displayname = 'Needs to be overridden'
1946
1872
_table = PillarName
1949
1875
def toTerm(self, obj):
1950
1876
"""See `IVocabulary`."""
1951
if type(obj) == int:
1952
return self.toTerm(PillarName.get(obj))
1953
1877
if IPillarName.providedBy(obj):
1954
1878
assert obj.active, 'Inactive object %s %d' % (
1955
1879
obj.__class__.__name__, obj.id)
1970
1894
def __contains__(self, obj):
1971
1895
raise NotImplementedError
1973
def searchForTerms(self, query=None):
1975
return self.emptySelectResults()
1976
query = ensure_unicode(query).lower()
1977
store = IStore(PillarName)
1978
equal_clauses = [PillarName.name == query]
1980
PillarName.name != query, PillarName.name.contains_string(query)]
1982
equal_clauses.extend(self._filter)
1983
like_clauses.extend(self._filter)
1984
ranked_results = store.execute(
1987
(PillarName.id, PillarName.name, SQL('100 AS rank')),
1988
tables=[PillarName],
1989
where=And(*equal_clauses)),
1991
(PillarName.id, PillarName.name, SQL('50 AS rank')),
1992
tables=[PillarName],
1993
where=And(*like_clauses)),
1994
limit=self._limit, order_by=(
1995
Desc(SQL('rank')), PillarName.name), all=True))
1996
results = [row[0] for row in list(ranked_results)]
1997
return self.iterator(len(results), results, self.toTerm)
2000
1898
class DistributionOrProductVocabulary(PillarVocabularyBase):
2001
1899
"""Active `IDistribution` or `IProduct` objects vocabulary."""
2002
1900
displayname = 'Select a project'
2003
_filter = [PillarName.project == None, PillarName.active == True]
1902
-- An active product/distro.
1904
AND (product IS NOT NULL OR distribution IS NOT NULL)
1907
-- Or an alias for an active product/distro.
1909
SELECT id FROM PillarName
1910
WHERE active IS TRUE AND
1911
(product IS NOT NULL OR distribution IS NOT NULL))
2005
1915
def __contains__(self, obj):
2006
1916
if IProduct.providedBy(obj):
2013
1923
class DistributionOrProductOrProjectGroupVocabulary(PillarVocabularyBase):
2014
1924
"""Active `IProduct`, `IProjectGroup` or `IDistribution` vocabulary."""
2015
1925
displayname = 'Select a project'
2016
_filter = [PillarName.active == True]
1926
_filter = PillarName.q.active == True
2018
1928
def __contains__(self, obj):
2019
1929
if IProduct.providedBy(obj) or IProjectGroup.providedBy(obj):
added
removed
lib/lp/registry/vocabularies.py
