def _order(self, request, queryset):
order_by = get_ordering(request)
item_name = self._get_item_name(order_by)
if item_name:
filter_kwargs = {self.db_field + '__name__startswith': item_name}
queryset = queryset.filter(**filter_kwargs).order_by(self.db_field + '__name')
return queryset
def filter(self, request, queryset, view):
order_by = get_ordering(request)
if order_by not in ('current_cost', '-current_cost'):
return queryset
year, month = invoice_utils.parse_period(request.query_params)
invoices = invoice_models.Invoice.objects.filter(
year=year, month=month, customer=OuterRef('pk'))
queryset = queryset.annotate(
current_cost=Subquery(invoices.values('current_cost')[:1]))
return order_with_nulls(queryset, order_by)
def filter(self, request, queryset, view):
order_by = get_ordering(request)
if order_by not in ('estimated_cost', '-estimated_cost'):
return queryset
ct = ContentType.objects.get_for_model(structure_models.Customer)
estimates = models.PriceEstimate.objects.filter(
content_type=ct, object_id=OuterRef('pk'))
queryset = queryset.annotate(
estimated_cost=Subquery(estimates.values('total')[:1]))
return order_with_nulls(queryset, order_by)
def filter_queryset(self, request, queryset, view):
period = get_period(request)
if 'actual_sla' in request.query_params:
value = request.query_params.get('actual_sla')
return queryset.filter(sla_items__value=value, sla_items__period=period)
elif get_ordering(request) == 'actual_sla':
return queryset.filter(sla_items__period=period).order_by('sla_items__value')
else:
return queryset
def filter_queryset(self, request, queryset, view):
for key in request.query_params.keys():
item_name = self._get_item_name(key)
if item_name:
value = request.query_params.get(key)
queryset = queryset.filter(monitoring_items__name=item_name,
monitoring_items__value=value)
order_by = get_ordering(request)
item_name = self._get_item_name(order_by)
if item_name:
queryset = queryset.filter(monitoring_items__name=item_name)\
.order_by('monitoring_items__value')
return queryset
def filter_queryset(self, request, queryset, view):
order_by = get_ordering(request)
if order_by not in ('start_time', '-start_time'):
return queryset
return order_with_nulls(queryset, order_by)
def filter_queryset(self, request, queryset, view):
search_text = request.query_params.get(
settings.api_settings.SEARCH_PARAM, '')
must_terms = {}
must_not_terms = {}
should_terms = {}
excluded_event_types = set()
if 'event_type' in request.query_params:
must_terms['event_type'] = request.query_params.getlist(
'event_type')
if 'feature' in request.query_params:
features = request.query_params.getlist('feature')
must_terms['event_type'] = expand_event_groups(features)
# Group events by features in order to prevent large HTTP GET request
if 'exclude_features' in request.query_params:
features = request.query_params.getlist('exclude_features')
excluded_event_types.update(expand_event_groups(features))
if 'exclude_extra' in request.query_params:
excluded_event_types.update(expand_event_groups(['update']))
if not django_settings.DEBUG:
excluded_event_types.update(expand_event_groups(['debug_only']))
if excluded_event_types:
must_not_terms['event_type'] = list(excluded_event_types)
if 'user_username' in request.query_params:
must_terms['user_username'] = [
request.query_params.get('user_username')
]
if 'scope' in request.query_params:
field = core_serializers.GenericRelatedField(
related_models=utils.get_loggable_models())
field._context = {'request': request}
obj = field.to_internal_value(request.query_params['scope'])
# XXX: Ilja - disabling this hack and re-opening a ticket. Additional analysis is required for
# a proper resolution
# # XXX: hack to prevent leaking customer events
# permitted_uuids = [uuid.hex for uuids in
# obj.get_permitted_objects_uuids(request.user).values() for uuid in uuids]
# if obj.uuid.hex not in permitted_uuids:
# raise ValidationError('You do not have permission to view events for scope %s'
# % request.query_params['scope'])
for key, val in obj.filter_by_logged_object().items():
must_terms[format_raw_field(key)] = [val]
elif 'scope_type' in request.query_params:
choices = utils.get_scope_types_mapping()
try:
scope_type = choices[request.query_params['scope_type']]
except KeyError:
raise ValidationError(
_('Scope type "%(value)s" is not valid. Has to be one from list: %(items)s.'
) % dict(value=request.query_params['scope_type'],
items=', '.join(choices.keys())))
else:
permitted_items = scope_type.get_permitted_objects_uuids(
request.user).items()
if not permitted_items:
return EmptyQueryset()
for field, uuids in permitted_items:
must_terms[field] = [uuid.hex for uuid in uuids]
elif 'resource_type' in request.query_params and 'resource_uuid' in request.query_params:
# Filter events by resource type and uuid.
# Please note, that permission checks are skipped,
# because we can't check permission for deleted resources.
# Also note, that resource type validation is skipped as well,
# because resource type name formatting is defined in structure application,
# but we don't want to create circular dependency between logging and structure apps.
# This issue could be fixed by switching resource type name formatting to str(model._meta)
# as it is done for scope_type parameter validation.
must_terms[format_raw_field('resource_type')] = [
request.query_params['resource_type']
]
must_terms[format_raw_field('resource_uuid')] = [
request.query_params['resource_uuid']
]
else:
should_terms.update(
event_logger.get_permitted_objects_uuids(request.user))
mapped = {
'start': request.query_params.get('from'),
'end': request.query_params.get('to'),
}
timestamp_interval_serializer = core_serializers.TimestampIntervalSerializer(
data={k: v
for k, v in mapped.items() if v})
timestamp_interval_serializer.is_valid(raise_exception=True)
filter_data = timestamp_interval_serializer.get_filter_data()
queryset = queryset.filter(search_text=search_text,
should_terms=should_terms,
must_terms=must_terms,
must_not_terms=must_not_terms,
start=filter_data.get('start'),
end=filter_data.get('end'))
order_by = get_ordering(request) or '-@timestamp'
if order_by:
queryset = queryset.order_by(order_by)
return queryset