'memory_set', 'processor_set', 'disk_set', Prefetch('ethernet_set', queryset=Ethernet.objects.select_related('ipaddress')), Prefetch('securityscan', queryset=SecurityScan.objects.prefetch_related( 'vulnerabilities', 'tags')), # TODO: clusters ] filter_fields = [ 'service_env__service__uid', 'service_env__service__name', 'service_env__service__id', ] additional_filter_class = VirtualServerFilterSet extended_filter_fields = dict( list(BaseObjectViewSetMixin.extended_filter_fields.items()) + list( dict(hypervisor_service=['parent__service_env__service__uid'], ).items())) router.register(r'cloud-flavors', CloudFlavorViewSet) router.register(r'cloud-hosts', CloudHostViewSet) router.register(r'cloud-projects', CloudProjectViewSet) router.register(r'cloud-providers', CloudProviderViewSet) router.register(r'cloud-images', CloudImageViewSet) router.register(r'virtual-servers', VirtualServerViewSet) router.register(r'virtual-server-types', VirtualServerTypeViewSet) urlpatterns = []
queryset = Operation.objects.all().prefetch_related( Prefetch( lookup='base_objects', queryset=BaseObject.objects.select_related('parent') ) ) serializer_class = OperationSerializer save_serializer_class = OperationSerializer select_related = ['type', 'assignee', 'reporter', 'status'] filter_fields = [ 'id', 'title', 'description', 'status', 'status', 'ticket_id', 'created_date', 'update_date', 'resolved_date', 'type', 'assignee', 'reporter' ] class OperationTypeViewSet(RalphAPIViewSet): queryset = OperationType.objects.all() serializer_class = OperationTypeSerializer class OperationStatusViewSet(RalphAPIViewSet): queryset = OperationStatus.objects.all() serializer_class = OperationStatusSerializer router.register(r'operation', OperationViewSet) router.register(r'operationtype', OperationTypeViewSet) router.register(r'operationstatus', OperationStatusViewSet) urlpatterns = []
class DNSProviderSerializer(RalphAPISerializer): class Meta: model = DNSProvider class DNSProviderViewSet(RalphAPIViewSet): queryset = DNSProvider.objects.all() serializer_class = DNSProviderSerializer class DomainCategorySerializer(RalphAPISerializer): class Meta: model = DomainCategory class DomainCategoryViewSet(RalphAPIViewSet): queryset = DomainCategory.objects.all() serializer_class = DomainCategorySerializer router.register(r'domains', DomainViewSet) router.register( r'domain-provider-additional-services', DomainProviderAdditionalServicesViewSet ) router.register(r'dns-provider', DNSProviderViewSet) router.register(r'domain-category', DomainCategoryViewSet) urlpatterns = []
'service_env__environment' ] prefetch_related = [ 'tags', 'users', 'licenceuser_set__user', 'baseobjectlicence_set__base_object', ] class LicenceUserViewSet(RalphAPIViewSet): queryset = LicenceUser.objects.all() serializer_class = LicenceUserSerializer select_related = [ 'licence', 'licence__region', 'licence__manufacturer', 'licence__licence_type', 'licence__software', 'user' ] class SoftwareViewSet(RalphAPIViewSet): queryset = Software.objects.all() serializer_class = SoftwareSerializer router.register(r'base-objects-licences', BaseObjectLicenceViewSet) router.register(r'licences', LicenceViewSet) router.register(r'licence-types', LicenceTypeViewSet) router.register(r'licence-users', LicenceUserViewSet) router.register(r'software', SoftwareViewSet) urlpatterns = []
serializer_class = SupportSerializer select_related = [ 'region', 'budget_info', 'support_type', 'property_of', 'service_env', 'service_env__service', 'service_env__environment' ] prefetch_related = [ 'tags', Prefetch('base_objects', queryset=BaseObject.objects.all()) ] class BaseObjectsSupportSerializer(RalphAPISerializer): support = SupportSimpleSerializer() baseobject = serializers.HyperlinkedRelatedField( view_name='baseobject-detail', read_only=True) class Meta: model = BaseObjectsSupport class BaseObjectSupportViewSet(RalphAPIViewSet): queryset = BaseObjectsSupport.objects.all() serializer_class = BaseObjectsSupportSerializer select_related = ['baseobject', 'support'] router.register(r'base-objects-supports', BaseObjectSupportViewSet) router.register(r'supports', SupportViewSet) router.register(r'support-types', SupportTypeViewSet) urlpatterns = []
'status', 'card_number', 'phone_number', 'pin1', 'puk1', 'user', 'owner', 'warehouse', 'carrier', 'features', 'quarantine_until', 'modified' ] class CellularCarrierViewSet(RalphAPIViewSet): queryset = CellularCarrier.objects.all() serializer_class = CellularCarrierSerializer class SIMCardFeatureViewSet(RalphAPIViewSet): queryset = SIMCardFeatures.objects.all() serializer_class = SIMCardFeaturesSerializer class SIMCardViewSet(RalphAPIViewSet): queryset = SIMCard.objects.all() serializer_class = SIMCardSerializer select_related = ['carrier', 'user', 'owner'] prefetch_related = ['features'] filter_fields = [ 'user__username', 'features__name', 'owner__username', 'carrier__name' ] router.register(r'sim-card-feature', SIMCardFeatureViewSet) router.register(r'sim-card-cellular-carrier', CellularCarrierViewSet) router.register(r'sim-card', SIMCardViewSet) urlpatterns = []
result = super().to_internal_value(data) return result class IPFilter(django_filters.FilterSet): ip = django_filters.CharFilter( name='base_object__ethernet_set__ipaddress__address') class SecurityScanViewSet(RalphAPIViewSet): queryset = SecurityScan.objects.all() serializer_class = SecurityScanSerializer save_serializer_class = SaveSecurityScanSerializer additional_filter_class = IPFilter @transaction.atomic def create(self, request, *args, **kwargs): ip = IPAddress.objects.filter( address=self.request.data.get('host_ip', None)).first() if ip: # one scan can exist for ip (because there are linked by onetoone) # so this removes old scan to allow updates by post SecurityScan.objects.filter(base_object=ip.base_object.id).delete() return super().create(request, *args, **kwargs) router.register(r'vulnerabilities', VulnerabilityViewSet) router.register(r'security-scans', SecurityScanViewSet) urlpatterns = []
from ralph.ssl_certificates.models import SSLCertificate class SSLCertificateSerializer(BaseObjectSerializer): class Meta: model = SSLCertificate depth = 2 exclude = ('content_type', ) _skip_tags_field = True class SSLCertificateViewSet(RalphAPIViewSet): queryset = SSLCertificate.objects.all() serializer_class = SSLCertificateSerializer filter_fields = [ 'name', 'domain_ssl', 'date_from', 'date_to', 'san', 'price', 'service_env__service__uid', 'service_env__service__name', 'service_env__service__id', ] select_related = ['service_env__service', 'service_env__environment'] router.register(r'sslcertificates', SSLCertificateViewSet) urlpatterns = []
http_method_names = [ m for m in RalphAPIViewSet.http_method_names if m != 'post' ] class RegionSerializer(RalphAPISerializer): class Meta: model = Region class RegionViewSet(RalphAPIViewSet): queryset = Region.objects.all() serializer_class = RegionSerializer class TeamSerializer(RalphAPISerializer): class Meta: model = Team class TeamViewSet(RalphAPIViewSet): queryset = Team.objects.all() serializer_class = TeamSerializer router.register(r'groups', GroupViewSet) router.register(r'users', RalphUserViewSet) router.register(r'regions', RegionViewSet) router.register(r'teams', TeamViewSet) urlpatterns = []
# -*- coding: utf-8 -*- from ralph.api import RalphAPISerializer, RalphAPIViewSet, router from ralph.dhcp.models import DNSServer, DNSServerGroup class DNSServerGroupSerializer(RalphAPISerializer): class Meta: model = DNSServerGroup class DNSServerSerializer(RalphAPISerializer): class Meta: model = DNSServer depth = 1 class DNSServerViewSet(RalphAPIViewSet): queryset = DNSServer.objects.all() serializer_class = DNSServerSerializer class DNSServerGroupViewSet(RalphAPIViewSet): queryset = DNSServerGroup.objects.all() serializer_class = DNSServerGroupSerializer router.register(r'dns-servers', DNSServerViewSet) router.register(r'dns-server-group', DNSServerGroupViewSet) urlpatterns = []
owner = RalphUserSimpleSerializer() region = RegionSerializer() access_zones = AccessZoneSimpleSerializer(many=True) class Meta: model = AccessCard fields = ['id', 'status', 'user', 'owner', 'created', 'modified', 'visual_number', 'system_number', 'issue_date', 'notes', 'region', 'access_zones'] class AccessCardViewSet(RalphAPIViewSet): queryset = AccessCard.objects.order_by('id').all() select_related = ['user', 'owner', 'region'] serializer_class = AccessCardSerializer prefetch_related = ['access_zones'] extended_filter_fields = { 'access_zones__name': ['access_zones__name__icontains'], 'access_zones__id': ['access_zones__id'] } class AccessZoneViewSet(RalphAPIViewSet): queryset = AccessZone.objects.all() serializer_class = AccessZoneSerializer router.register(r'access-card', AccessCardViewSet) router.register(r'access-zone', AccessZoneViewSet) urlpatterns = []
from ralph.api import router from ralph.dashboards.api.views import GraphViewSet router.register(r'graph', GraphViewSet) urlpatterns = []
class SupportTypeSerializer(RalphAPISerializer): class Meta: model = SupportType class SupportTypeViewSet(RalphAPIViewSet): queryset = SupportType.objects.all() serializer_class = SupportTypeSerializer class SupportSerializer(BaseObjectSerializer): class Meta: model = Support depth = 1 # temporary - waiting for Polymorphic # (https://github.com/allegro/ralph/pull/1725) # we should create serializer for this field which will call # proper serializer for each type returned by Polymorphic or try to # use generic nested serializer for concrete type exclude = ('base_objects', 'content_type') class SupportViewSet(RalphAPIViewSet): queryset = Support.objects.all() serializer_class = SupportSerializer router.register(r'supports', SupportViewSet) router.register(r'support-types', SupportTypeViewSet) urlpatterns = []
ConfigurationModuleViewSet, DCHostViewSet, DiskViewSet, EnvironmentViewSet, EthernetViewSet, FibreChannelCardViewSet, ManufacturerKindViewSet, ManufacturerViewSet, MemoryViewSet, ProcessorViewSet, ProfitCenterViewSet, ServiceEnvironmentViewSet, ServiceViewSet ) router.register(r'assetholders', AssetHolderViewSet) router.register(r'assetmodels', AssetModelViewSet) router.register(r'budget-info', BudgetInfoViewSet) router.register(r'base-objects', BaseObjectViewSet) router.register(r'business-segments', BusinessSegmentViewSet) router.register(r'categories', CategoryViewSet) router.register(r'configuration-modules', ConfigurationModuleViewSet) router.register(r'configuration-classes', ConfigurationClassViewSet) router.register(r'disks', DiskViewSet) router.register(r'environments', EnvironmentViewSet) router.register(r'fibre-channel-cards', FibreChannelCardViewSet) router.register(r'ethernets', EthernetViewSet) router.register(r'memory', MemoryViewSet) router.register(r'manufacturers', ManufacturerViewSet) router.register(r'manufacturer-kind', ManufacturerKindViewSet) router.register(r'processors', ProcessorViewSet)
# -*- coding: utf-8 -*- from django.conf.urls import url from ralph.api import router from ralph.lib.transitions.api.views import (AvailableTransitionViewSet, TransitionActionViewSet, TransitionByIdView, TransitionJobViewSet, TransitionModelViewSet, TransitionView, TransitionViewSet) router.register(r'transitions', TransitionViewSet) router.register(r'transitions-action', TransitionActionViewSet) router.register(r'transitions-model', TransitionModelViewSet) router.register(r'transitions-job', TransitionJobViewSet) router.register( r'(?P<app_label>\w+)/(?P<model>\w+)/(?P<obj_pk>\w+)/transitions', AvailableTransitionViewSet, base_name='available-transiton') urlpatterns = [ # Deprecated url(r'^transition/(?P<transition_pk>[0-9]+)/(?P<obj_pk>\w+)$', TransitionByIdView.as_view(), name='transition-view'), url(r'^transitions/(?P<transition_pk>[0-9]+)/(?P<obj_pk>\w+)$', TransitionByIdView.as_view(), name='transitions-view'), url( r'^(?P<app_label>\w+)/(?P<model>\w+)/(?P<obj_pk>[0-9]+)/transitions/(?P<transition_pk>[0-9]+)/$', # noqa TransitionView.as_view(),
# -*- coding: utf-8 -*- from ralph.api import router from ralph.data_center.api.views import ( AccessoryViewSet, BaseObjectClusterViewSet, ClusterTypeViewSet, ClusterViewSet, DatabaseViewSet, DataCenterAssetViewSet, DataCenterViewSet, RackAccessoryViewSet, RackViewSet, ServerRoomViewSet, VIPViewSet) router.register(r'accessories', AccessoryViewSet) router.register(r'databases', DatabaseViewSet) router.register(r'data-centers', DataCenterViewSet) router.register(r'data-center-assets', DataCenterAssetViewSet) router.register(r'racks', RackViewSet) router.register(r'rack-accessories', RackAccessoryViewSet) router.register(r'server-rooms', ServerRoomViewSet) router.register(r'vips', VIPViewSet) router.register(r'clusters', ClusterViewSet) router.register(r'cluster-types', ClusterTypeViewSet) router.register(r'base-object-clusters', BaseObjectClusterViewSet) urlpatterns = []
'No hostname matching {} found.'.format(hostname), status.HTTP_404_NOT_FOUND ) serializer = self.save_serializer_class(data=request.data) serializer.is_valid(raise_exception=True) update_data = { 'last_checked': serializer.validated_data['last_checked'], 'check_result': serializer.validated_data['check_result'] } scan, created = SCMStatusCheck.objects.update_or_create( base_object_id=bo.id, defaults=update_data ) res_status = status.HTTP_201_CREATED if created else status.HTTP_200_OK return Response(self.serializer_class(scan).data, status=res_status) router.register('scm-info', SCMInfoViewSet) urlpatterns = [ url( r'^scm-info/(?P<hostname>[\w\.-]+)', SCMInfoViewSet.as_view({'post': 'create', 'delete': 'delete'}), name='scm-info-post' ) ]
class BackOfficeAssetSerializer(AssetSerializer): user = SimpleRalphUserSerializer() owner = SimpleRalphUserSerializer() class Meta(AssetSerializer.Meta): model = BackOfficeAsset depth = 2 class BackOfficeAssetViewSet(RalphAPIViewSet): select_related = BackOfficeAssetAdmin.list_select_related + [ 'service_env', 'service_env__service', 'service_env__environment', 'user', 'owner', 'property_of', 'office_infrastructure', 'budget_info' ] prefetch_related = base_object_descendant_prefetch_related + [ 'user__groups', 'user__user_permissions', 'service_env__service__environments', 'service_env__service__business_owners', 'service_env__service__technical_owners', 'tags', ] queryset = BackOfficeAsset.objects.all() serializer_class = BackOfficeAssetSerializer router.register(r'warehouses', WarehouseViewSet) router.register(r'office-infrastructures', OfficeInfrastructureViewSet) router.register(r'back-office-assets', BackOfficeAssetViewSet) urlpatterns = []
class CustomFieldChoicesField(serializers.Field): def to_representation(self, obj): return obj.split('|') def to_internal_value(self, data): if not isinstance(data, list): msg = 'Incorrect type. Expected a list, but got %s' raise serializers.ValidationError(msg % type(data).__name__) return '|'.join(data) class CustomFieldSerializer(RalphAPISerializer): choices = CustomFieldChoicesField() class Meta: model = CustomField fields = ('name', 'attribute_name', 'type', 'default_value', 'choices', 'use_as_configuration_variable', 'url') class CustomFieldViewSet(RalphAPIViewSet): serializer_class = CustomFieldSerializer save_serializer_class = CustomFieldSerializer queryset = CustomField.objects.all() router.register(r'custom-fields', CustomFieldViewSet) urlpatterns = []