def get_base_queryset(cls, params): # pylint: disable=too-many-branches
queryset = cls.objects.filter(is_active=True)
user = params.get('user', None)
org = params.get('org', None)
collection = params.get('collection', None)
source = params.get('source', None)
container_version = params.get('version', None)
concept = params.get('concept', None)
concept_version = params.get('concept_version', None)
is_latest = params.get('is_latest', None)
include_retired = params.get(INCLUDE_RETIRED_PARAM, False)
updated_since = parse_updated_since_param(params)
if collection:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__mnemonic',
collection))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__organization__mnemonic', org))
if container_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__version',
container_version))
if source:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__mnemonic', source))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria('parent__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'parent__organization__mnemonic', org))
if container_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__version',
container_version))
if concept:
queryset = queryset.filter(mnemonic__iexact=concept)
if concept_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('version', concept_version))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if not include_retired and not concept:
queryset = queryset.filter(retired=False)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
return queryset.distinct()
def get_base_queryset(cls, params): # pylint: disable=too-many-branches
queryset = cls.objects.filter(is_active=True)
user = params.get('user', None)
org = params.get('org', None)
collection = params.get('collection', None)
source = params.get('source', None)
container_version = params.get('version', None)
mapping = params.get('mapping', None)
mapping_version = params.get('mapping_version', None)
is_latest = params.get('is_latest', None)
include_retired = params.get(INCLUDE_RETIRED_PARAM, False)
updated_since = parse_updated_since_param(params)
if collection:
queryset = queryset.filter(
collection_set__mnemonic__in=collection.split(','))
if user:
queryset = queryset.filter(
collection_set__user__username__in=user.split(','))
if org:
queryset = queryset.filter(
collection_set__organization__mnemonic__in=org.split(','))
if container_version:
queryset = queryset.filter(
collection_set__version__in=container_version.split(','))
if source:
queryset = queryset.filter(sources__mnemonic__in=source.split(','))
if user:
queryset = queryset.filter(
parent__user__username__in=user.split(','))
if org:
queryset = queryset.filter(
parent__organization__mnemonic__in=org.split(','))
if container_version:
queryset = queryset.filter(
sources__version__in=container_version.split(','))
if mapping:
queryset = queryset.filter(mnemonic__iexact=mapping)
if mapping_version:
queryset = queryset.filter(version__in=mapping_version.split(','))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if not include_retired:
queryset = queryset.filter(retired=False)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
return queryset.distinct()
def get_queryset(self):
username = self.kwargs.get('user')
if not username and self.user_is_self:
username = get(self.request.user, 'username')
if username:
self.queryset = Organization.get_by_username(username)
elif self.request.user.is_anonymous:
self.queryset = Organization.get_public()
elif self.request.user.is_superuser or self.request.user.is_staff:
self.queryset = Organization.objects.filter(is_active=True)
else:
self.queryset = Organization.get_by_username(self.request.user.username) | Organization.get_public()
updated_since = parse_updated_since_param(self.request.query_params)
if updated_since:
self.queryset = self.queryset.filter(updated_at__gte=updated_since)
return self.queryset.distinct()
def get_base_queryset(cls, params):
username = params.get('user', None)
org = params.get('org', None)
version = params.get('version', None)
is_latest = params.get('is_latest', None) in [True, 'true']
updated_since = parse_updated_since_param(params)
queryset = cls.objects.filter(is_active=True)
if username:
queryset = queryset.filter(cls.get_iexact_or_criteria('user__username', username))
if org:
queryset = queryset.filter(cls.get_iexact_or_criteria('organization__mnemonic', org))
if version:
queryset = queryset.filter(cls.get_iexact_or_criteria('version', version))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
return queryset
def get_base_queryset(cls, params):
username = params.get('user', None)
org = params.get('org', None)
version = params.get('version', None)
is_latest = params.get('is_latest', None)
updated_since = parse_updated_since_param(params)
queryset = cls.objects.filter(is_active=True)
if username:
queryset = queryset.filter(user__username__in=username.split(','))
if org:
queryset = queryset.filter(organization__mnemonic__in=org.split(','))
if version:
queryset = queryset.filter(version__in=version.split(','))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
return queryset
def get_base_queryset(cls, params):
queryset = cls.objects.filter(is_active=True)
user = params.get('user', None)
org = params.get('org', None)
collection = params.get('collection', None)
source = params.get('source', None)
container_version = params.get('version', None)
concept = params.get('concept', None)
concept_version = params.get('concept_version', None)
is_latest = params.get('is_latest', None)
include_retired = params.get(INCLUDE_RETIRED_PARAM, False)
updated_since = parse_updated_since_param(params)
if user:
queryset = queryset.filter(parent__user__username=user)
if org:
queryset = queryset.filter(parent__organization__mnemonic=org)
if source:
queryset = queryset.filter(sources__mnemonic=source)
if collection:
queryset = queryset.filter(collection__mnemonic=collection)
if container_version and source:
queryset = queryset.filter(sources__version=container_version)
if container_version and collection:
queryset = queryset.filter(collection__version=container_version)
if concept:
queryset = queryset.filter(mnemonic=concept)
if concept_version:
queryset = queryset.filter(version=concept_version)
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if not include_retired:
queryset = queryset.filter(retired=False)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
return queryset.distinct()
def get_queryset(self):
updated_since = parse_updated_since_param(self.request.query_params)
if updated_since:
self.queryset = self.queryset.filter(updated_at__gte=updated_since)
return self.queryset
def __search_results(self): # pylint: disable=too-many-branches,too-many-locals
results = None
if self.should_perform_es_search():
results = self.document_model.search()
default_filters = self.default_filters.copy()
if self.is_source_child_document_model(
) and self.__should_query_latest_version():
default_filters['is_latest_version'] = True
for field, value in default_filters.items():
results = results.query("match", **{field: value})
faceted_criterion = self.get_faceted_criterion()
extras_fields = self.get_extras_searchable_fields_from_query_params(
)
extras_fields_exact = self.get_extras_exact_fields_from_query_params(
)
extras_fields_exists = self.get_extras_fields_exists_from_query_params(
)
if faceted_criterion:
results = results.query(faceted_criterion)
if self.is_exact_match_on():
results = results.query(self.get_exact_search_criterion())
else:
results = results.query(self.get_wildcard_search_criterion())
updated_since = parse_updated_since_param(
self.request.query_params)
if updated_since:
results = results.query('range',
last_update={"gte": updated_since})
if extras_fields:
for field, value in extras_fields.items():
results = results.filter("query_string",
query=value,
fields=[field])
if extras_fields_exists:
for field in extras_fields_exists:
results = results.query("exists",
field="extras.{}".format(field))
if extras_fields_exact:
for field, value in extras_fields_exact.items():
results = results.query("match",
**{field: value},
_expand__to_dot=False)
if self._should_exclude_retired_from_search_results():
results = results.query('match', retired=False)
user = self.request.user
is_authenticated = user.is_authenticated
username = user.username
include_private = self._should_include_private()
if not include_private:
results = results.query(self.get_public_criteria())
if self.is_owner_document_model():
kwargs_filters = self.kwargs.copy()
if self.user_is_self and is_authenticated:
kwargs_filters.pop('user_is_self', None)
kwargs_filters['user'] = username
else:
kwargs_filters = self.get_kwargs_filters()
if self.user_is_self and is_authenticated:
kwargs_filters['ownerType'] = 'User'
kwargs_filters['owner'] = username
for key, value in kwargs_filters.items():
results = results.query('match', **{to_snake_case(key): value})
sort_field = self.get_sort_attr()
if sort_field:
results = results.sort(sort_field)
return results
def get_base_queryset( # pylint: disable=too-many-branches,too-many-locals,too-many-statements
cls,
params,
distinct_by='updated_at'):
queryset = cls.objects.filter(is_active=True)
user = params.get('user', None)
org = params.get('org', None)
collection = params.get('collection', None)
source = params.get('source', None)
container_version = params.get('version', None)
concept = params.get('concept', None)
concept_version = params.get('concept_version', None)
is_latest = params.get('is_latest', None) in [True, 'true']
uri = params.get('uri', None)
include_retired = params.get(INCLUDE_RETIRED_PARAM,
None) in [True, 'true']
updated_since = parse_updated_since_param(params)
latest_released_version = None
is_latest_released = container_version == LATEST
if is_latest_released:
filters = dict(user__username=user, organization__mnemonic=org)
if source:
from core.sources.models import Source
latest_released_version = Source.find_latest_released_version_by(
{
**filters, 'mnemonic': source
})
elif collection:
from core.collections.models import Collection
latest_released_version = Collection.find_latest_released_version_by(
{
**filters, 'mnemonic': collection
})
if not latest_released_version:
return cls.objects.none()
if collection:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__mnemonic',
collection))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__organization__mnemonic', org))
if is_latest_released:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__version',
get(latest_released_version, 'version')))
if container_version and not is_latest_released:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__version',
container_version))
if source:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__mnemonic', source))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria('parent__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'parent__organization__mnemonic', org))
if is_latest_released:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'sources__version',
get(latest_released_version, 'version')))
if container_version and not is_latest_released:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__version',
container_version))
if concept:
queryset = queryset.filter(mnemonic__exact=concept)
if concept_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('version', concept_version))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if not include_retired and not concept:
queryset = queryset.filter(retired=False)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
if uri:
queryset = queryset.filter(uri__icontains=uri)
if distinct_by:
queryset = queryset.distinct(distinct_by)
return queryset
def get_base_queryset(cls, params, distinct_by='updated_at'): # pylint: disable=too-many-branches
queryset = cls.objects.filter(is_active=True)
user = params.get('user', None)
org = params.get('org', None)
collection = params.get('collection', None)
source = params.get('source', None)
container_version = params.get('version', None)
mapping = params.get('mapping', None)
mapping_version = params.get('mapping_version', None)
is_latest = params.get('is_latest', None) in [True, 'true']
include_retired = params.get(INCLUDE_RETIRED_PARAM,
None) in [True, 'true']
updated_since = parse_updated_since_param(params)
uri = params.get('uri', None)
if collection:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__mnemonic',
collection))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'collection_set__organization__mnemonic', org))
if container_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('collection_set__version',
container_version))
if source:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__mnemonic', source))
if user:
queryset = queryset.filter(
cls.get_iexact_or_criteria('parent__user__username', user))
if org:
queryset = queryset.filter(
cls.get_iexact_or_criteria(
'parent__organization__mnemonic', org))
if container_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('sources__version',
container_version))
if mapping:
queryset = queryset.filter(mnemonic__iexact=mapping)
if mapping_version:
queryset = queryset.filter(
cls.get_iexact_or_criteria('version', mapping_version))
if is_latest:
queryset = queryset.filter(is_latest_version=True)
if not include_retired and not mapping:
queryset = queryset.filter(retired=False)
if updated_since:
queryset = queryset.filter(updated_at__gte=updated_since)
if uri:
queryset = queryset.filter(uri__icontains=uri)
if distinct_by:
queryset = queryset.distinct(distinct_by)
return queryset