def apply_filters(self, request, applicable_filters):
types = applicable_filters.pop('type', None)
extent = applicable_filters.pop('extent', None)
keywords = applicable_filters.pop('keywords__slug__in', None)
metadata_only = applicable_filters.pop('metadata_only', False)
filtering_method = applicable_filters.pop('f_method', 'and')
if filtering_method == 'or':
filters = Q()
for f in applicable_filters.items():
filters |= Q(f)
semi_filtered = self.get_object_list(request).filter(filters)
else:
semi_filtered = super().apply_filters(
request,
applicable_filters)
filtered = None
if types:
for the_type in types:
if the_type in LAYER_TYPES:
super_type = the_type
if 'vector_time' == the_type:
super_type = 'vector'
if filtered:
if 'time' in the_type:
filtered = filtered | semi_filtered.filter(
Layer___subtype=super_type).exclude(Layer___has_time=False)
else:
filtered = filtered | semi_filtered.filter(
Layer___subtype=super_type)
else:
if 'time' in the_type:
filtered = semi_filtered.filter(
Layer___subtype=super_type).exclude(Layer___has_time=False)
else:
filtered = semi_filtered.filter(
Layer___subtype=super_type)
else:
_type_filter = FILTER_TYPES[the_type].__name__.lower()
if filtered:
filtered = filtered | semi_filtered.filter(polymorphic_ctype__model=_type_filter)
else:
filtered = semi_filtered.filter(polymorphic_ctype__model=_type_filter)
else:
filtered = semi_filtered
if extent:
filtered = filter_bbox(filtered, extent)
if keywords:
filtered = self.filter_h_keywords(filtered, keywords)
# return filtered
return get_visible_resources(
filtered,
request.user if request else None,
metadata_only=metadata_only,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
def facets(context):
request = context['request']
title_filter = request.GET.get('title__icontains', '')
extent_filter = request.GET.get('extent', None)
keywords_filter = request.GET.getlist('keywords__slug__in', None)
category_filter = request.GET.getlist('category__identifier__in', None)
regions_filter = request.GET.getlist('regions__name__in', None)
owner_filter = request.GET.getlist('owner__username__in', None)
date_gte_filter = request.GET.get('date__gte', None)
date_lte_filter = request.GET.get('date__lte', None)
date_range_filter = request.GET.get('date__range', None)
facet_type = context.get('facet_type', 'all')
if not settings.SKIP_PERMS_FILTER:
authorized = []
try:
authorized = get_objects_for_user(
request.user, 'base.view_resourcebase').values('id')
except Exception:
pass
if facet_type == 'geoapps':
facets = {}
from django.apps import apps
for label, app in apps.app_configs.items():
if hasattr(app, 'type') and app.type == 'GEONODE_APP':
if hasattr(app, 'default_model'):
geoapps = get_visible_resources(
apps.get_model(label, app.default_model).objects.all(),
request.user if request else None,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
if category_filter:
geoapps = geoapps.filter(category__identifier__in=category_filter)
if regions_filter:
geoapps = geoapps.filter(regions__name__in=regions_filter)
if owner_filter:
geoapps = geoapps.filter(owner__username__in=owner_filter)
if date_gte_filter:
geoapps = geoapps.filter(date__gte=date_gte_filter)
if date_lte_filter:
geoapps = geoapps.filter(date__lte=date_lte_filter)
if date_range_filter:
geoapps = geoapps.filter(date__range=date_range_filter.split(','))
if extent_filter:
geoapps = filter_bbox(geoapps, extent_filter)
if keywords_filter:
treeqs = HierarchicalKeyword.objects.none()
for keyword in keywords_filter:
try:
kws = HierarchicalKeyword.objects.filter(name__iexact=keyword)
for kw in kws:
treeqs = treeqs | HierarchicalKeyword.get_tree(kw)
except Exception:
# Ignore keywords not actually used?
pass
geoapps = geoapps.filter(Q(keywords__in=treeqs))
if not settings.SKIP_PERMS_FILTER:
geoapps = geoapps.filter(id__in=authorized)
facets[app.default_model] = geoapps.count()
return facets
elif facet_type == 'documents':
documents = Document.objects.filter(title__icontains=title_filter)
if category_filter:
documents = documents.filter(category__identifier__in=category_filter)
if regions_filter:
documents = documents.filter(regions__name__in=regions_filter)
if owner_filter:
documents = documents.filter(owner__username__in=owner_filter)
if date_gte_filter:
documents = documents.filter(date__gte=date_gte_filter)
if date_lte_filter:
documents = documents.filter(date__lte=date_lte_filter)
if date_range_filter:
documents = documents.filter(date__range=date_range_filter.split(','))
documents = get_visible_resources(
documents,
request.user if request else None,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
if keywords_filter:
treeqs = HierarchicalKeyword.objects.none()
for keyword in keywords_filter:
try:
kws = HierarchicalKeyword.objects.filter(name__iexact=keyword)
for kw in kws:
treeqs = treeqs | HierarchicalKeyword.get_tree(kw)
except Exception:
# Ignore keywords not actually used?
pass
documents = documents.filter(Q(keywords__in=treeqs))
if not settings.SKIP_PERMS_FILTER:
documents = documents.filter(id__in=authorized)
counts = documents.values('doc_type').annotate(count=Count('doc_type'))
facets = {count['doc_type']: count['count'] for count in counts}
return facets
else:
layers = Layer.objects.filter(title__icontains=title_filter)
if category_filter:
layers = layers.filter(category__identifier__in=category_filter)
if regions_filter:
layers = layers.filter(regions__name__in=regions_filter)
if owner_filter:
layers = layers.filter(owner__username__in=owner_filter)
if date_gte_filter:
layers = layers.filter(date__gte=date_gte_filter)
if date_lte_filter:
layers = layers.filter(date__lte=date_lte_filter)
if date_range_filter:
layers = layers.filter(date__range=date_range_filter.split(','))
layers = get_visible_resources(
layers,
request.user if request else None,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
if extent_filter:
layers = filter_bbox(layers, extent_filter)
if keywords_filter:
treeqs = HierarchicalKeyword.objects.none()
for keyword in keywords_filter:
try:
kws = HierarchicalKeyword.objects.filter(name__iexact=keyword)
for kw in kws:
treeqs = treeqs | HierarchicalKeyword.get_tree(kw)
except Exception:
# Ignore keywords not actually used?
pass
layers = layers.filter(Q(keywords__in=treeqs))
if not settings.SKIP_PERMS_FILTER:
layers = layers.filter(id__in=authorized)
counts = layers.values('storeType').annotate(count=Count('storeType'))
counts_array = []
try:
for count in counts:
counts_array.append((count['storeType'], count['count']))
except Exception:
pass
count_dict = dict(counts_array)
vector_time_series = layers.exclude(has_time=False).filter(storeType='dataStore'). \
values('storeType').annotate(count=Count('storeType'))
if vector_time_series:
count_dict['vectorTimeSeries'] = vector_time_series[0]['count']
facets = {
'raster': count_dict.get('coverageStore', 0),
'vector': count_dict.get('dataStore', 0),
'vector_time': count_dict.get('vectorTimeSeries', 0),
'remote': count_dict.get('remoteStore', 0),
'wms': count_dict.get('wmsStore', 0),
}
# Break early if only_layers is set.
if facet_type == 'layers':
return facets
maps = Map.objects.filter(title__icontains=title_filter)
documents = Document.objects.filter(title__icontains=title_filter)
if category_filter:
maps = maps.filter(category__identifier__in=category_filter)
documents = documents.filter(category__identifier__in=category_filter)
if regions_filter:
maps = maps.filter(regions__name__in=regions_filter)
documents = documents.filter(regions__name__in=regions_filter)
if owner_filter:
maps = maps.filter(owner__username__in=owner_filter)
documents = documents.filter(owner__username__in=owner_filter)
if date_gte_filter:
maps = maps.filter(date__gte=date_gte_filter)
documents = documents.filter(date__gte=date_gte_filter)
if date_lte_filter:
maps = maps.filter(date__lte=date_lte_filter)
documents = documents.filter(date__lte=date_lte_filter)
if date_range_filter:
maps = maps.filter(date__range=date_range_filter.split(','))
documents = documents.filter(date__range=date_range_filter.split(','))
maps = get_visible_resources(
maps,
request.user if request else None,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
documents = get_visible_resources(
documents,
request.user if request else None,
admin_approval_required=settings.ADMIN_MODERATE_UPLOADS,
unpublished_not_visible=settings.RESOURCE_PUBLISHING,
private_groups_not_visibile=settings.GROUP_PRIVATE_RESOURCES)
if extent_filter:
documents = filter_bbox(documents, extent_filter)
if keywords_filter:
treeqs = HierarchicalKeyword.objects.none()
for keyword in keywords_filter:
try:
kws = HierarchicalKeyword.objects.filter(name__iexact=keyword)
for kw in kws:
treeqs = treeqs | HierarchicalKeyword.get_tree(kw)
except Exception:
# Ignore keywords not actually used?
pass
maps = maps.filter(Q(keywords__in=treeqs))
documents = documents.filter(Q(keywords__in=treeqs))
if not settings.SKIP_PERMS_FILTER:
maps = maps.filter(id__in=authorized)
documents = documents.filter(id__in=authorized)
facets['map'] = maps.count()
facets['document'] = documents.count()
if facet_type == 'home':
facets['user'] = get_user_model().objects.exclude(
username='******').count()
facets['group'] = GroupProfile.objects.exclude(
access="private").count()
facets['layer'] = facets['raster'] + facets['vector'] + facets['remote'] + facets['wms']
return facets
def apply_filters(self, request, applicable_filters):
types = applicable_filters.pop('type', None)
extent = applicable_filters.pop('extent', None)
keywords = applicable_filters.pop('keywords__slug__in', None)
filtering_method = applicable_filters.pop('f_method', 'and')
if filtering_method == 'or':
filters = Q()
for f in applicable_filters.items():
filters |= Q(f)
semi_filtered = self.get_object_list(request).filter(filters)
else:
semi_filtered = super(CommonModelApi,
self).apply_filters(request,
applicable_filters)
filtered = None
if types:
for the_type in types:
if the_type in LAYER_SUBTYPES.keys():
super_type = the_type
if 'vector_time' == the_type:
super_type = 'vector'
if filtered:
if 'time' in the_type:
filtered = filtered | semi_filtered.filter(
Layer___storeType=LAYER_SUBTYPES[super_type]
).exclude(Layer___has_time=False)
else:
filtered = filtered | semi_filtered.filter(
Layer___storeType=LAYER_SUBTYPES[super_type])
else:
if 'time' in the_type:
filtered = semi_filtered.filter(
Layer___storeType=LAYER_SUBTYPES[super_type]
).exclude(Layer___has_time=False)
else:
filtered = semi_filtered.filter(
Layer___storeType=LAYER_SUBTYPES[super_type])
else:
_type_filter = FILTER_TYPES[the_type].__name__.lower()
if filtered:
filtered = filtered | semi_filtered.filter(
polymorphic_ctype__model=_type_filter)
else:
filtered = semi_filtered.filter(
polymorphic_ctype__model=_type_filter)
else:
filtered = semi_filtered
if settings.RESOURCE_PUBLISHING or settings.ADMIN_MODERATE_UPLOADS:
filtered = self.filter_published(filtered, request)
if settings.GROUP_PRIVATE_RESOURCES:
filtered = self.filter_group(filtered, request)
if extent:
filtered = filter_bbox(filtered, extent)
if keywords:
filtered = self.filter_h_keywords(filtered, keywords)
# Hide Dirty State Resources
user = request.user if request else None
if not user or not user.is_superuser:
if user:
filtered = filtered.exclude(
Q(dirty_state=True)
& ~(Q(owner__username__iexact=str(user))))
else:
filtered = filtered.exclude(Q(dirty_state=True))
return filtered
def filter_queryset(self, request, queryset, view):
if request.query_params.get('extent'):
return filter_bbox(queryset, request.query_params.get('extent'))
return queryset
