class OrderItemFilter(OfferingFilterMixin, django_filters.FilterSet):
project_uuid = django_filters.UUIDFilter(field_name='order__project__uuid')
category_uuid = django_filters.UUIDFilter(
field_name='offering__category__uuid')
provider_uuid = django_filters.UUIDFilter(
field_name='offering__customer__uuid')
customer_uuid = django_filters.UUIDFilter(
field_name='order__project__customer__uuid')
service_manager_uuid = django_filters.UUIDFilter(
method='filter_service_manager')
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.OrderItem.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.OrderItem.States.CHOICES
},
)
type = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.OrderItem.Types.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.OrderItem.Types.CHOICES
},
)
order = core_filters.URLFilter(view_name='marketplace-order-detail',
field_name='order__uuid')
order_uuid = django_filters.UUIDFilter(field_name='order__uuid')
resource = core_filters.URLFilter(view_name='marketplace-resource-detail',
field_name='resource__uuid')
resource_uuid = django_filters.UUIDFilter(field_name='resource__uuid')
o = django_filters.OrderingFilter(fields=('created', ))
class Meta:
model = models.OrderItem
fields = []
def filter_service_manager(self, queryset, name, value):
return queryset.filter(
offering__shared=True,
offering__permissions__user__uuid=value,
offering__permissions__is_active=True,
)
class FeedbackFilter(django_filters.FilterSet):
issue = core_filters.URLFilter(view_name='support-issue-detail',
field_name='issue__uuid')
issue_uuid = django_filters.UUIDFilter(field_name='issue__uuid')
user = core_filters.URLFilter(view_name='user-detail',
field_name='issue__caller__uuid')
user_uuid = django_filters.UUIDFilter(field_name='issue__caller__uuid')
created_before = django_filters.DateTimeFilter(field_name="created",
lookup_expr="lte")
created_after = django_filters.DateTimeFilter(field_name="created",
lookup_expr="gte")
evaluation = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.Feedback.Evaluation.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Feedback.Evaluation.CHOICES
},
)
issue_key = django_filters.CharFilter(field_name='issue__key')
user_full_name = django_filters.CharFilter(method='filter_by_full_name',
label='User full name contains')
def filter_by_full_name(self, queryset, name, value):
return core_filters.filter_by_full_name(queryset, value,
'issue__caller')
class OrderFilter(django_filters.FilterSet):
customer = core_filters.URLFilter(
view_name='customer-detail', field_name='project__customer__uuid'
)
customer_uuid = django_filters.UUIDFilter(field_name='project__customer__uuid')
project = core_filters.URLFilter(
view_name='project-detail', field_name='project__uuid'
)
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.Order.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Order.States.CHOICES
},
)
o = django_filters.OrderingFilter(
fields=('created', 'approved_at', 'total_cost', 'state')
)
class Meta:
model = models.Order
fields = []
class OrderItemFilter(django_filters.FilterSet):
offering = core_filters.URLFilter(view_name='marketplace-offering-detail',
name='offering__uuid')
offering_uuid = django_filters.UUIDFilter(name='offering__uuid')
project_uuid = django_filters.UUIDFilter(name='order__project__uuid')
category_uuid = django_filters.UUIDFilter(name='offering__category__uuid')
provider_uuid = django_filters.UUIDFilter(name='offering__customer__uuid')
customer_uuid = django_filters.UUIDFilter(
name='order__project__customer__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.OrderItem.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.OrderItem.States.CHOICES
},
)
order = core_filters.URLFilter(view_name='marketplace-order-detail',
name='order__uuid')
order_uuid = django_filters.UUIDFilter(name='order__uuid')
class Meta(object):
model = models.OrderItem
fields = []
class OfferingFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
description = django_filters.CharFilter(lookup_expr='icontains')
type = django_filters.ChoiceFilter(
choices=[(item, item)
for item in settings.WALDUR_SUPPORT['OFFERINGS'].keys()])
issue = core_filters.URLFilter(view_name='support-issue-detail',
name='issue__uuid')
issue_uuid = django_filters.UUIDFilter(name='issue__uuid')
project = core_filters.URLFilter(view_name='project-detail',
name='project__uuid')
project_uuid = django_filters.UUIDFilter(name='project__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Offering.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Offering.States.CHOICES
},
)
o = django_filters.OrderingFilter(fields=('created', 'modified', 'state'))
class Meta(object):
model = models.Offering
fields = ('name', 'description', 'type', 'issue', 'issue_uuid',
'project', 'project_uuid', 'state')
class ResourceFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
name_exact = django_filters.CharFilter(field_name='name')
query = django_filters.CharFilter(method='filter_query')
offering = core_filters.URLFilter(view_name='marketplace-offering-detail',
field_name='offering__uuid')
offering_uuid = django_filters.UUIDFilter(field_name='offering__uuid')
offering_type = django_filters.CharFilter(field_name='offering__type')
offering_billable = django_filters.UUIDFilter(
field_name='offering__billable')
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
project_name = django_filters.CharFilter(field_name='project__name')
customer_uuid = django_filters.UUIDFilter(
field_name='project__customer__uuid')
category_uuid = django_filters.UUIDFilter(
field_name='offering__category__uuid')
provider_uuid = django_filters.UUIDFilter(
field_name='offering__customer__uuid')
backend_id = django_filters.CharFilter(method='filter_backend_id')
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Resource.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Resource.States.CHOICES
},
)
o = django_filters.OrderingFilter(fields=(
'name',
'created',
))
class Meta:
model = models.Resource
fields = []
def filter_query(self, queryset, name, value):
if is_uuid_like(value):
return queryset.filter(uuid=value)
else:
return queryset.filter(name__icontains=value)
def filter_backend_id(self, queryset, name, value):
resource_models = [
b['resource_model'] for b in manager.backends.values()
if 'resource_model' in b.keys()
]
for resource_model in resource_models:
resources_ids = resource_model.objects.filter(
backend_id=value).values_list('id', flat=True)
if not resources_ids:
continue
ct = ContentType.objects.get_for_model(resource_model)
return queryset.filter(content_type=ct,
object_id__in=resources_ids)
return queryset.none()
class BaseOfferingFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
name_exact = django_filters.CharFilter(field_name='name')
customer = core_filters.URLFilter(
view_name='customer-detail', field_name='customer__uuid'
)
customer_uuid = django_filters.UUIDFilter(field_name='customer__uuid')
project_uuid = django_filters.UUIDFilter(method='filter_project')
allowed_customer_uuid = django_filters.UUIDFilter(
field_name='customer__uuid', method='filter_allowed_customer'
)
attributes = django_filters.CharFilter(
field_name='attributes', method='filter_attributes'
)
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.Offering.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Offering.States.CHOICES
},
)
category_uuid = django_filters.UUIDFilter(field_name='category__uuid')
billable = django_filters.BooleanFilter(widget=BooleanWidget)
o = django_filters.OrderingFilter(fields=('name', 'created'))
def filter_allowed_customer(self, queryset, name, value):
return queryset.filter_for_customer(value)
def filter_project(self, queryset, name, value):
return queryset.filter_for_project(value)
def filter_attributes(self, queryset, name, value):
try:
value = json.loads(value)
except ValueError:
raise rf_exceptions.ValidationError(
_('Filter attribute is not valid json.')
)
if not isinstance(value, dict):
raise rf_exceptions.ValidationError(
_('Filter attribute should be an dict.')
)
for k, v in value.items():
if isinstance(v, list):
# If a filter value is a list, use multiple choice.
queryset = queryset.filter(
**{'attributes__{key}__has_any_keys'.format(key=k): v}
)
else:
queryset = queryset.filter(attributes__contains={k: v})
return queryset
class OfferingFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
description = django_filters.CharFilter(lookup_expr='icontains')
type = django_filters.ModelMultipleChoiceFilter(
queryset=models.OfferingTemplate.objects.all(),
to_field_name='name',
method='offering_template_filter',
)
template = django_filters.ModelMultipleChoiceFilter(
queryset=models.OfferingTemplate.objects.all(),
)
issue = core_filters.URLFilter(
view_name='support-issue-detail', field_name='issue__uuid'
)
issue_uuid = django_filters.UUIDFilter(field_name='issue__uuid')
issue_key = django_filters.CharFilter(field_name='issue__key')
project = core_filters.URLFilter(
view_name='project-detail', field_name='project__uuid'
)
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.Offering.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Offering.States.CHOICES
},
)
o = django_filters.OrderingFilter(fields=('created', 'modified', 'state'))
def offering_template_filter(self, queryset, name, value):
if value:
return queryset.filter(template__in=value)
return queryset
class Meta:
model = models.Offering
fields = (
'name',
'description',
'template',
'issue',
'issue_uuid',
'project',
'project_uuid',
'state',
)
class ResourceFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
name_exact = django_filters.CharFilter(field_name='name')
query = django_filters.CharFilter(method='filter_query')
offering = core_filters.URLFilter(view_name='marketplace-offering-detail',
field_name='offering__uuid')
offering_uuid = django_filters.UUIDFilter(field_name='offering__uuid')
offering_type = django_filters.CharFilter(field_name='offering__type')
offering_billable = django_filters.UUIDFilter(
field_name='offering__billable')
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
project_name = django_filters.CharFilter(field_name='project__name')
customer_uuid = django_filters.UUIDFilter(
field_name='project__customer__uuid')
category_uuid = django_filters.UUIDFilter(
field_name='offering__category__uuid')
provider_uuid = django_filters.UUIDFilter(
field_name='offering__customer__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Resource.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Resource.States.CHOICES
},
)
o = django_filters.OrderingFilter(fields=(
'name',
'created',
))
class Meta:
model = models.Resource
fields = []
def filter_query(self, queryset, name, value):
if is_uuid_like(value):
return queryset.filter(uuid=value)
else:
return queryset.filter(name__icontains=value)
class OfferingFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
customer = core_filters.URLFilter(view_name='customer-detail',
name='customer__uuid')
customer_uuid = django_filters.UUIDFilter(name='customer__uuid')
attributes = django_filters.CharFilter(name='attributes',
method='filter_attributes')
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Offering.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Offering.States.CHOICES
},
)
category_uuid = django_filters.UUIDFilter(name='category__uuid')
def filter_attributes(self, queryset, name, value):
try:
value = json.loads(value)
except ValueError:
raise rf_exceptions.ValidationError(
_('Filter attribute is not valid json.'))
if not isinstance(value, dict):
raise rf_exceptions.ValidationError(
_('Filter attribute should be an dict.'))
for k, v in value.items():
if isinstance(v, list):
# If a filter value is a list, use multiple choice.
queryset = queryset.filter(
**{'attributes__{key}__has_any_keys'.format(key=k): v})
else:
queryset = queryset.filter(attributes__contains={k: v})
return queryset
class Meta(object):
model = models.Offering
fields = ['shared', 'type']
class OrderFilter(django_filters.FilterSet):
customer = core_filters.URLFilter(view_name='customer-detail',
field_name='project__customer__uuid')
customer_uuid = django_filters.UUIDFilter(
field_name='project__customer__uuid')
project = core_filters.URLFilter(view_name='project-detail',
field_name='project__uuid')
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Order.States.CHOICES],
choice_mappings={
representation: db_value
for db_value, representation in models.Order.States.CHOICES
},
)
type = django_filters.MultipleChoiceFilter(
choices=[(representation, representation) for db_value, representation
in models.RequestTypeMixin.Types.CHOICES],
method='filter_items_type',
label='Items type',
)
o = django_filters.OrderingFilter(fields=('created', 'approved_at',
'total_cost', 'state'))
class Meta:
model = models.Order
fields = []
def filter_items_type(self, queryset, name, value):
type_ids = []
for v in value:
for type_id, type_name in models.RequestTypeMixin.Types.CHOICES:
if type_name == v:
type_ids.append(type_id)
order_ids = models.OrderItem.objects.filter(
type__in=type_ids).values_list('order_id', flat=True)
return queryset.filter(id__in=order_ids)
class BaseResourceFilter(NameFilterSet, metaclass=ResourceFilterMetaclass):
def __init__(self, *args, **kwargs):
super(BaseResourceFilter, self).__init__(*args, **kwargs)
self.filters['o'] = django_filters.OrderingFilter(fields=self.ORDERING_FIELDS)
# customer
customer = django_filters.UUIDFilter(
field_name='service_project_link__service__customer__uuid'
)
customer_uuid = django_filters.UUIDFilter(
field_name='service_project_link__service__customer__uuid'
)
customer_name = django_filters.CharFilter(
field_name='service_project_link__service__customer__name',
lookup_expr='icontains',
)
customer_native_name = django_filters.CharFilter(
field_name='service_project_link__project__customer__native_name',
lookup_expr='icontains',
)
customer_abbreviation = django_filters.CharFilter(
field_name='service_project_link__project__customer__abbreviation',
lookup_expr='icontains',
)
# project
project = django_filters.UUIDFilter(
field_name='service_project_link__project__uuid'
)
project_uuid = django_filters.UUIDFilter(
field_name='service_project_link__project__uuid'
)
project_name = django_filters.CharFilter(
field_name='service_project_link__project__name', lookup_expr='icontains'
)
# service
service_uuid = django_filters.UUIDFilter(
field_name='service_project_link__service__uuid'
)
service_name = django_filters.CharFilter(
field_name='service_project_link__service__settings__name',
lookup_expr='icontains',
)
# service settings
service_settings_uuid = django_filters.UUIDFilter(
field_name='service_project_link__service__settings__uuid'
)
service_settings_name = django_filters.CharFilter(
field_name='service_project_link__service__settings__name',
lookup_expr='icontains',
)
# resource
description = django_filters.CharFilter(lookup_expr='icontains')
state = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in core_models.StateMixin.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in core_models.StateMixin.States.CHOICES
},
)
uuid = django_filters.UUIDFilter(lookup_expr='exact')
backend_id = django_filters.CharFilter(field_name='backend_id', lookup_expr='exact')
tag = django_filters.ModelMultipleChoiceFilter(
field_name='tags__name',
label='tag',
to_field_name='name',
queryset=taggit.models.Tag.objects.all(),
)
rtag = django_filters.ModelMultipleChoiceFilter(
field_name='tags__name',
label='rtag',
to_field_name='name',
queryset=taggit.models.Tag.objects.all(),
conjoined=True,
)
external_ip = core_filters.EmptyFilter()
ORDERING_FIELDS = (
('name', 'name'),
('state', 'state'),
('service_project_link__project__customer__name', 'customer_name'),
(
'service_project_link__project__customer__native_name',
'customer_native_name',
),
(
'service_project_link__project__customer__abbreviation',
'customer_abbreviation',
),
('service_project_link__project__name', 'project_name'),
('service_project_link__service__settings__name', 'service_name'),
('service_project_link__service__uuid', 'service_uuid'),
('created', 'created'),
)
class Meta:
model = models.ResourceMixin
fields = (
# customer
'customer',
'customer_uuid',
'customer_name',
'customer_native_name',
'customer_abbreviation',
# project
'project',
'project_uuid',
'project_name',
# service
'service_uuid',
'service_name',
# service settings
'service_settings_name',
'service_settings_uuid',
# resource
'name',
'name_exact',
'description',
'state',
'uuid',
'backend_id',
'tag',
'rtag',
)
class ResourceFilter(OfferingFilterMixin, structure_filters.NameFilterSet,
django_filters.FilterSet):
query = django_filters.CharFilter(method='filter_query')
offering_type = django_filters.CharFilter(field_name='offering__type')
offering_billable = django_filters.UUIDFilter(
field_name='offering__billable')
project_uuid = django_filters.UUIDFilter(field_name='project__uuid')
project_name = django_filters.CharFilter(field_name='project__name')
customer_uuid = django_filters.UUIDFilter(
field_name='project__customer__uuid')
customer = core_filters.URLFilter(view_name='customer-detail',
field_name='project__customer__uuid')
service_manager_uuid = django_filters.UUIDFilter(
method='filter_service_manager')
category_uuid = django_filters.UUIDFilter(
field_name='offering__category__uuid')
provider_uuid = django_filters.UUIDFilter(
field_name='offering__customer__uuid')
backend_id = django_filters.CharFilter()
state = core_filters.MappedMultipleChoiceFilter(
choices=[(representation, representation)
for db_value, representation in models.Resource.States.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Resource.States.CHOICES
},
)
o = django_filters.OrderingFilter(fields=(
'name',
'created',
))
class Meta:
model = models.Resource
fields = []
def filter_query(self, queryset, name, value):
if is_uuid_like(value):
if queryset.filter(uuid=value).exists():
return queryset.filter(uuid=value)
else:
return self.filter_scope_uuid(queryset, name, value)
else:
return queryset.filter(
Q(name__icontains=value)
| Q(backend_metadata__external_ips__icontains=value)
| Q(backend_metadata__internal_ips__icontains=value))
def filter_service_manager(self, queryset, name, value):
return queryset.filter(
offering__shared=True,
offering__permissions__user__uuid=value,
offering__permissions__is_active=True,
)
def filter_scope_uuid(self, queryset, name, value):
for offering_type in plugins.manager.get_offering_types():
resource_model = plugins.manager.get_resource_model(offering_type)
if not resource_model:
continue
try:
obj = resource_model.objects.get(uuid=value)
ct = ContentType.objects.get_for_model(resource_model)
if queryset.filter(content_type=ct, object_id=obj.id).exists():
return queryset.filter(content_type=ct, object_id=obj.id)
except resource_model.DoesNotExist:
continue
return queryset.none()
