Skip to content

Golden Config API Package

nautobot_golden_config.api

REST API module for nautobot_golden_config plugin.

serializers

REST API serializer capabilities for graphql plugin.

ComplianceFeatureSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for ComplianceFeature object.

Source code in nautobot_golden_config/api/serializers.py 
26
27
28
29
30
31
32
33
34
35
36
37
class ComplianceFeatureSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for ComplianceFeature object."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_golden_config-api:compliancefeature-detail"
    )

    class Meta:
        """Set Meta Data for ComplianceFeature, will serialize all fields."""

        model = models.ComplianceFeature
        fields = "__all__"
Meta

Set Meta Data for ComplianceFeature, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
33
34
35
36
37
class Meta:
    """Set Meta Data for ComplianceFeature, will serialize all fields."""

    model = models.ComplianceFeature
    fields = "__all__"

ComplianceRuleSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for ComplianceRule object.

Source code in nautobot_golden_config/api/serializers.py 
40
41
42
43
44
45
46
47
48
49
class ComplianceRuleSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for ComplianceRule object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:compliancerule-detail")

    class Meta:
        """Set Meta Data for ComplianceRule, will serialize all fields."""

        model = models.ComplianceRule
        fields = "__all__"
Meta

Set Meta Data for ComplianceRule, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
45
46
47
48
49
class Meta:
    """Set Meta Data for ComplianceRule, will serialize all fields."""

    model = models.ComplianceRule
    fields = "__all__"

ConfigComplianceSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for ConfigCompliance object.

Source code in nautobot_golden_config/api/serializers.py 
52
53
54
55
56
57
58
59
class ConfigComplianceSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for ConfigCompliance object."""

    class Meta:
        """Set Meta Data for ConfigCompliance, will serialize fields."""

        model = models.ConfigCompliance
        fields = "__all__"
Meta

Set Meta Data for ConfigCompliance, will serialize fields.

Source code in nautobot_golden_config/api/serializers.py 
55
56
57
58
59
class Meta:
    """Set Meta Data for ConfigCompliance, will serialize fields."""

    model = models.ConfigCompliance
    fields = "__all__"

ConfigPlanSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer, StatusModelSerializerMixin

Serializer for ConfigPlan object.

Source code in nautobot_golden_config/api/serializers.py 
173
174
175
176
177
178
179
180
181
182
183
184
185
class ConfigPlanSerializer(NautobotModelSerializer, TaggedObjectSerializer, StatusModelSerializerMixin):
    """Serializer for ConfigPlan object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:configplan-detail")
    device = NestedDeviceSerializer(required=False)
    status = StatusSerializerField(required=False, queryset=Status.objects.all())

    class Meta:
        """Set Meta Data for ConfigPlan, will serialize all fields."""

        model = models.ConfigPlan
        fields = "__all__"
        read_only_fields = ["device", "plan_type", "feature", "config_set"]
Meta

Set Meta Data for ConfigPlan, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
180
181
182
183
184
185
class Meta:
    """Set Meta Data for ConfigPlan, will serialize all fields."""

    model = models.ConfigPlan
    fields = "__all__"
    read_only_fields = ["device", "plan_type", "feature", "config_set"]

ConfigRemoveSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for ConfigRemove object.

Source code in nautobot_golden_config/api/serializers.py 
115
116
117
118
119
120
121
122
123
124
class ConfigRemoveSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for ConfigRemove object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:configremove-detail")

    class Meta:
        """Set Meta Data for ConfigRemove, will serialize all fields."""

        model = models.ConfigRemove
        fields = "__all__"
Meta

Set Meta Data for ConfigRemove, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
120
121
122
123
124
class Meta:
    """Set Meta Data for ConfigRemove, will serialize all fields."""

    model = models.ConfigRemove
    fields = "__all__"

ConfigReplaceSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for ConfigReplace object.

Source code in nautobot_golden_config/api/serializers.py 
127
128
129
130
131
132
133
134
135
136
class ConfigReplaceSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for ConfigReplace object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:configreplace-detail")

    class Meta:
        """Set Meta Data for ConfigReplace, will serialize all fields."""

        model = models.ConfigReplace
        fields = "__all__"
Meta

Set Meta Data for ConfigReplace, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
132
133
134
135
136
class Meta:
    """Set Meta Data for ConfigReplace, will serialize all fields."""

    model = models.ConfigReplace
    fields = "__all__"

ConfigToPushSerializer

Bases: DeviceSerializer

Serializer for ConfigToPush view.

Source code in nautobot_golden_config/api/serializers.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
class ConfigToPushSerializer(DeviceSerializer):
    """Serializer for ConfigToPush view."""

    config = serializers.SerializerMethodField()

    class Meta(DeviceSerializer):
        """Extend the Device serializer with the configuration after postprocessing."""

        fields = DeviceSerializer.Meta.fields + ["config"]
        model = Device

    def get_config(self, obj):
        """Provide the intended configuration ready after postprocessing to the config field."""
        request = self.context.get("request")

        config_details = models.GoldenConfig.objects.get(device=obj)
        return get_config_postprocessing(config_details, request)
Meta

Bases: DeviceSerializer

Extend the Device serializer with the configuration after postprocessing.

Source code in nautobot_golden_config/api/serializers.py 
144
145
146
147
148
class Meta(DeviceSerializer):
    """Extend the Device serializer with the configuration after postprocessing."""

    fields = DeviceSerializer.Meta.fields + ["config"]
    model = Device
get_config(obj)

Provide the intended configuration ready after postprocessing to the config field.

Source code in nautobot_golden_config/api/serializers.py 
150
151
152
153
154
155
def get_config(self, obj):
    """Provide the intended configuration ready after postprocessing to the config field."""
    request = self.context.get("request")

    config_details = models.GoldenConfig.objects.get(device=obj)
    return get_config_postprocessing(config_details, request)

GoldenConfigSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for GoldenConfig object.

Source code in nautobot_golden_config/api/serializers.py 
62
63
64
65
66
67
68
69
70
71
class GoldenConfigSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for GoldenConfig object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:goldenconfig-detail")

    class Meta:
        """Set Meta Data for GoldenConfig, will serialize all fields."""

        model = models.GoldenConfig
        fields = "__all__"
Meta

Set Meta Data for GoldenConfig, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
67
68
69
70
71
class Meta:
    """Set Meta Data for GoldenConfig, will serialize all fields."""

    model = models.GoldenConfig
    fields = "__all__"

GoldenConfigSettingSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for GoldenConfigSetting object.

Source code in nautobot_golden_config/api/serializers.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
class GoldenConfigSettingSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for GoldenConfigSetting object."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_golden_config-api:goldenconfigsetting-detail"
    )
    scope = serializers.JSONField(required=False)
    dynamic_group = NestedDynamicGroupSerializer(required=False)

    class Meta:
        """Set Meta Data for GoldenConfigSetting, will serialize all fields."""

        model = models.GoldenConfigSetting
        fields = "__all__"

    def validate(self, data):
        """Validate scope & dynamic_group are not both submitted."""
        if data.get("scope") and data.get("dynamic_group"):
            raise serializers.ValidationError(
                "Payload can only contain `scope` or `dynamic_group`, but both were provided."
            )
        return data

    def create(self, validated_data):
        """Overload to handle ability to post scope instead of dynamic_group."""
        if not validated_data.get("scope"):
            return models.GoldenConfigSetting.objects.create(**validated_data)

        # The scope setter is not called on use of Model.objects.create method.
        # The model must first be created in memory without the scope, then
        # assign the scope which will call the scope setter. Finally .save()
        # and return.
        scope = validated_data.pop("scope")
        setting = models.GoldenConfigSetting(**validated_data)
        setting.scope = scope

        # Using .save() over .validated_save() as validation is done prior to .create() being called
        setting.save()
        return setting
Meta

Set Meta Data for GoldenConfigSetting, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
83
84
85
86
87
class Meta:
    """Set Meta Data for GoldenConfigSetting, will serialize all fields."""

    model = models.GoldenConfigSetting
    fields = "__all__"
create(validated_data)

Overload to handle ability to post scope instead of dynamic_group.

Source code in nautobot_golden_config/api/serializers.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
def create(self, validated_data):
    """Overload to handle ability to post scope instead of dynamic_group."""
    if not validated_data.get("scope"):
        return models.GoldenConfigSetting.objects.create(**validated_data)

    # The scope setter is not called on use of Model.objects.create method.
    # The model must first be created in memory without the scope, then
    # assign the scope which will call the scope setter. Finally .save()
    # and return.
    scope = validated_data.pop("scope")
    setting = models.GoldenConfigSetting(**validated_data)
    setting.scope = scope

    # Using .save() over .validated_save() as validation is done prior to .create() being called
    setting.save()
    return setting
validate(data)

Validate scope & dynamic_group are not both submitted.

Source code in nautobot_golden_config/api/serializers.py 
89
90
91
92
93
94
95
def validate(self, data):
    """Validate scope & dynamic_group are not both submitted."""
    if data.get("scope") and data.get("dynamic_group"):
        raise serializers.ValidationError(
            "Payload can only contain `scope` or `dynamic_group`, but both were provided."
        )
    return data

GraphQLSerializer

Bases: Serializer

Serializer for a GraphQL object.

Source code in nautobot_golden_config/api/serializers.py 
20
21
22
23
class GraphQLSerializer(serializers.Serializer):  # pylint: disable=abstract-method
    """Serializer for a GraphQL object."""

    data = serializers.JSONField()

NestedConfigPlanSerializer

Bases: WritableNestedSerializer

Nested serializer for ConfigPlan object.

Source code in nautobot_golden_config/api/serializers.py 
188
189
190
191
192
193
194
195
196
197
class NestedConfigPlanSerializer(WritableNestedSerializer):
    """Nested serializer for ConfigPlan object."""

    url = serializers.HyperlinkedIdentityField(view_name="plugins-api:nautobot_golden_config-api:configplan-detail")

    class Meta:
        """Set Meta Data for ConfigPlan, will serialize brief fields."""

        model = models.ConfigPlan
        fields = ["id", "url", "device", "plan_type"]
Meta

Set Meta Data for ConfigPlan, will serialize brief fields.

Source code in nautobot_golden_config/api/serializers.py 
193
194
195
196
197
class Meta:
    """Set Meta Data for ConfigPlan, will serialize brief fields."""

    model = models.ConfigPlan
    fields = ["id", "url", "device", "plan_type"]

RemediationSettingSerializer

Bases: NautobotModelSerializer, TaggedObjectSerializer

Serializer for RemediationSetting object.

Source code in nautobot_golden_config/api/serializers.py 
158
159
160
161
162
163
164
165
166
167
168
169
170
class RemediationSettingSerializer(NautobotModelSerializer, TaggedObjectSerializer):
    """Serializer for RemediationSetting object."""

    url = serializers.HyperlinkedIdentityField(
        view_name="plugins-api:nautobot_golden_config-api:remediationsetting-detail"
    )

    class Meta:
        """Set Meta Data for RemediationSetting, will serialize all fields."""

        model = models.RemediationSetting
        choices_fields = ["remediation_type"]
        fields = "__all__"
Meta

Set Meta Data for RemediationSetting, will serialize all fields.

Source code in nautobot_golden_config/api/serializers.py 
165
166
167
168
169
170
class Meta:
    """Set Meta Data for RemediationSetting, will serialize all fields."""

    model = models.RemediationSetting
    choices_fields = ["remediation_type"]
    fields = "__all__"

urls

API for Custom Jobs .

views

View for Golden Config APIs.

ComplianceFeatureViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ComplianceFeature objects.

Source code in nautobot_golden_config/api/views.py 
51
52
53
54
55
56
class ComplianceFeatureViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ComplianceFeature objects."""

    queryset = models.ComplianceFeature.objects.all()
    serializer_class = serializers.ComplianceFeatureSerializer
    filterset_class = filters.ComplianceFeatureFilterSet

ComplianceRuleViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ComplianceRule objects.

Source code in nautobot_golden_config/api/views.py 
43
44
45
46
47
48
class ComplianceRuleViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ComplianceRule objects."""

    queryset = models.ComplianceRule.objects.all()
    serializer_class = serializers.ComplianceRuleSerializer
    filterset_class = filters.ComplianceRuleFilterSet

ConfigComplianceViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ConfigCompliance objects.

Source code in nautobot_golden_config/api/views.py 
59
60
61
62
63
64
class ConfigComplianceViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ConfigCompliance objects."""

    queryset = models.ConfigCompliance.objects.all()
    serializer_class = serializers.ConfigComplianceSerializer
    filterset_class = filters.ConfigComplianceFilterSet

ConfigPlanViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ConfigPlan objects.

Source code in nautobot_golden_config/api/views.py 
127
128
129
130
131
132
133
134
135
class ConfigPlanViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ConfigPlan objects."""

    queryset = models.ConfigPlan.objects.all()
    serializer_class = serializers.ConfigPlanSerializer
    filterset_class = filters.ConfigPlanFilterSet

    # Disabling POST as these should only be created via Job.
    http_method_names = ["get", "put", "patch", "delete", "head", "options"]

ConfigPushPermissions

Bases: BasePermission

Permissions class to validate access to Devices and GoldenConfig view.

Source code in nautobot_golden_config/api/views.py 
 99
100
101
102
103
104
105
106
107
108
class ConfigPushPermissions(BasePermission):
    """Permissions class to validate access to Devices and GoldenConfig view."""

    def has_permission(self, request, view):
        """Method to validated permissions to API view."""
        return request.user.has_perm("nautobot_golden_config.view_goldenconfig")

    def has_object_permission(self, request, view, obj):
        """Validate user access to the object, taking into account constraints."""
        return request.user.has_perm("dcim.view_device", obj=obj)
has_object_permission(request, view, obj)

Validate user access to the object, taking into account constraints.

Source code in nautobot_golden_config/api/views.py 
106
107
108
def has_object_permission(self, request, view, obj):
    """Validate user access to the object, taking into account constraints."""
    return request.user.has_perm("dcim.view_device", obj=obj)
has_permission(request, view)

Method to validated permissions to API view.

Source code in nautobot_golden_config/api/views.py 
102
103
104
def has_permission(self, request, view):
    """Method to validated permissions to API view."""
    return request.user.has_perm("nautobot_golden_config.view_goldenconfig")

ConfigRemoveViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ConfigRemove objects.

Source code in nautobot_golden_config/api/views.py 
83
84
85
86
87
88
class ConfigRemoveViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ConfigRemove objects."""

    queryset = models.ConfigRemove.objects.all()
    serializer_class = serializers.ConfigRemoveSerializer
    filterset_class = filters.ConfigRemoveFilterSet

ConfigReplaceViewSet

Bases: NautobotModelViewSet

API viewset for interacting with ConfigReplace objects.

Source code in nautobot_golden_config/api/views.py 
91
92
93
94
95
96
class ConfigReplaceViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with ConfigReplace objects."""

    queryset = models.ConfigReplace.objects.all()
    serializer_class = serializers.ConfigReplaceSerializer
    filterset_class = filters.ConfigReplaceFilterSet

ConfigToPushViewSet

Bases: RetrieveModelMixin, GenericViewSet

Detail REST API view showing configuration after postprocessing.

Source code in nautobot_golden_config/api/views.py 
111
112
113
114
115
116
class ConfigToPushViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
    """Detail REST API view showing configuration after postprocessing."""

    permission_classes = [IsAuthenticated & ConfigPushPermissions]
    queryset = Device.objects.all()
    serializer_class = serializers.ConfigToPushSerializer

GoldenConfigRootView

Bases: APIRootView

Golden Config API root view.

Source code in nautobot_golden_config/api/views.py 
21
22
23
24
25
26
class GoldenConfigRootView(APIRootView):
    """Golden Config API root view."""

    def get_view_name(self):
        """Golden Config API root view boilerplate."""
        return "Golden Config"
get_view_name()

Golden Config API root view boilerplate.

Source code in nautobot_golden_config/api/views.py 
24
25
26
def get_view_name(self):
    """Golden Config API root view boilerplate."""
    return "Golden Config"

GoldenConfigSettingViewSet

Bases: NautobotModelViewSet

API viewset for interacting with GoldenConfigSetting objects.

Source code in nautobot_golden_config/api/views.py 
75
76
77
78
79
80
class GoldenConfigSettingViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with GoldenConfigSetting objects."""

    queryset = models.GoldenConfigSetting.objects.all()
    serializer_class = serializers.GoldenConfigSettingSerializer
    filterset_class = filters.GoldenConfigSettingFilterSet

GoldenConfigViewSet

Bases: NautobotModelViewSet

API viewset for interacting with GoldenConfig objects.

Source code in nautobot_golden_config/api/views.py 
67
68
69
70
71
72
class GoldenConfigViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with GoldenConfig objects."""

    queryset = models.GoldenConfig.objects.all()
    serializer_class = serializers.GoldenConfigSerializer
    filterset_class = filters.GoldenConfigFilterSet

RemediationSettingViewSet

Bases: NautobotModelViewSet

API viewset for interacting with RemediationSetting objects.

Source code in nautobot_golden_config/api/views.py 
119
120
121
122
123
124
class RemediationSettingViewSet(NautobotModelViewSet):  # pylint:disable=too-many-ancestors
    """API viewset for interacting with RemediationSetting objects."""

    queryset = models.RemediationSetting.objects.all()
    serializer_class = serializers.RemediationSettingSerializer
    filterset_class = filters.RemediationSettingFilterSet

SOTAggDeviceDetailView

Bases: APIView

Detail REST API view showing graphql, with a potential "transformer" of data on a specific device.

Source code in nautobot_golden_config/api/views.py 
29
30
31
32
33
34
35
36
37
38
39
40
class SOTAggDeviceDetailView(APIView):
    """Detail REST API view showing graphql, with a potential "transformer" of data on a specific device."""

    permission_classes = [AllowAny]

    def get(self, request, *args, **kwargs):
        """Get method serialize for a dictionary to json response."""
        device = Device.objects.get(pk=kwargs["pk"])
        settings = get_device_to_settings_map(queryset=Device.objects.filter(pk=device.pk))[device.id]
        status_code, data = graph_ql_query(request, device, settings.sot_agg_query.query)
        data = json.loads(json.dumps(data))
        return Response(serializers.GraphQLSerializer(data=data).initial_data, status=status_code)
get(request, *args, **kwargs)

Get method serialize for a dictionary to json response.

Source code in nautobot_golden_config/api/views.py 
34
35
36
37
38
39
40
def get(self, request, *args, **kwargs):
    """Get method serialize for a dictionary to json response."""
    device = Device.objects.get(pk=kwargs["pk"])
    settings = get_device_to_settings_map(queryset=Device.objects.filter(pk=device.pk))[device.id]
    status_code, data = graph_ql_query(request, device, settings.sot_agg_query.query)
    data = json.loads(json.dumps(data))
    return Response(serializers.GraphQLSerializer(data=data).initial_data, status=status_code)