'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 = []
