nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/models/change_logging.py

@@ -108,22 +108,6 @@ class ObjectChange(BaseModel):
     object_data = models.JSONField(encoder=DjangoJSONEncoder, editable=False)
     object_data_v2 = models.JSONField(encoder=NautobotKombuJSONEncoder, editable=False, null=True, blank=True)
 
-    csv_headers = [
-        "time",
-        "user",
-        "user_name",
-        "request_id",
-        "action",
-        "changed_object_type",
-        "changed_object_id",
-        "related_object_type",
-        "related_object_id",
-        "object_repr",
-        "object_data",
-        "change_context",
-        "change_context_detail",
-    ]
-
     class Meta:
         ordering = ["-time"]
         get_latest_by = "time"
@@ -158,26 +142,6 @@ class ObjectChange(BaseModel):
 
         return super().save(*args, **kwargs)
 
-    def get_absolute_url(self):
-        return reverse("extras:objectchange", args=[self.pk])
-
-    def to_csv(self):
-        return (
-            self.time,
-            self.user,
-            self.user_name,
-            self.request_id,
-            self.get_action_display(),
-            self.changed_object_type,
-            self.changed_object_id,
-            self.related_object_type,
-            self.related_object_id,
-            self.object_repr,
-            self.object_data,
-            self.change_context,
-            self.change_context_detail,
-        )
-
     def get_action_class(self):
         return ObjectChangeActionChoices.CSS_CLASSES.get(self.action)
 

nautobot/extras/models/customfields.py

@@ -11,7 +11,6 @@ from django.core.serializers.json import DjangoJSONEncoder
 from django.core.validators import RegexValidator, ValidationError
 from django.db import models
 from django.forms.widgets import TextInput
-from django.urls import reverse
 from django.utils.safestring import mark_safe
 
 from nautobot.core.forms import (
@@ -29,6 +28,7 @@ from nautobot.core.models import BaseManager, BaseModel
 from nautobot.core.models.fields import AutoSlugField, slugify_dashes_to_underscores
 from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.core.models.validators import validate_regex
+from nautobot.core.settings_funcs import is_truthy
 from nautobot.core.templatetags.helpers import render_markdown
 from nautobot.core.utils.data import render_jinja2
 from nautobot.extras.choices import CustomFieldFilterLogicChoices, CustomFieldTypeChoices
@@ -63,9 +63,9 @@ class ComputedField(BaseModel, ChangeLoggedModel, NotesMixin):
         limit_choices_to=FeatureQuery("custom_fields"),
         related_name="computed_fields",
     )
-    slug = AutoSlugField(
+    key = AutoSlugField(
         populate_from="label",
-        help_text="Internal field name. Please use underscores rather than dashes in this slug.",
+        help_text="Internal field name. Please use underscores rather than dashes in this key.",
         slugify_function=slugify_dashes_to_underscores,
     )
     label = models.CharField(max_length=100, help_text="Name of the field as displayed to users")
@@ -89,15 +89,12 @@ class ComputedField(BaseModel, ChangeLoggedModel, NotesMixin):
     clone_fields = ["content_type", "description", "template", "fallback_value", "weight"]
 
     class Meta:
-        ordering = ["weight", "slug"]
+        ordering = ["weight", "key"]
         unique_together = ("content_type", "label")
 
     def __str__(self):
         return self.label
 
-    def get_absolute_url(self):
-        return reverse("extras:computedfield", args=[self.slug])
-
     def render(self, context):
         try:
             rendered = render_jinja2(self.template, context)
@@ -105,13 +102,18 @@ class ComputedField(BaseModel, ChangeLoggedModel, NotesMixin):
             # Doesn't raise an exception either most likely due to using Undefined rather
             # than StrictUndefined, but return fallback_value if None is returned
             if rendered is None:
-                logger.warning("Failed to render computed field %s", self.slug)
+                logger.warning("Failed to render computed field %s", self.key)
                 return self.fallback_value
             return rendered
         except Exception as exc:
-            logger.warning("Failed to render computed field %s: %s", self.slug, exc)
+            logger.warning("Failed to render computed field %s: %s", self.key, exc)
             return self.fallback_value
 
+    def clean(self):
+        super().clean()
+        if self.key != "":
+            check_if_key_is_graphql_safe(self.__class__.__name__, self.key)
+
 
 class CustomFieldModel(models.Model):
     """
@@ -225,7 +227,7 @@ class CustomFieldModel(models.Model):
                 logger.warning(f"Unknown field key '{field_key}' in custom field data for {self} ({self.pk}).")
                 continue
             try:
-                custom_fields[field_key].validate(value)
+                self._custom_field_data[field_key] = custom_fields[field_key].validate(value)
             except ValidationError as e:
                 raise ValidationError(f"Invalid value for custom field '{field_key}': {e.message}")
 
@@ -251,15 +253,15 @@ class CustomFieldModel(models.Model):
     def has_computed_fields_advanced(self):
         return self.has_computed_fields(advanced_ui=True)
 
-    def get_computed_field(self, slug, render=True):
+    def get_computed_field(self, key, render=True):
         """
-        Get a computed field for this model, lookup via slug.
+        Get a computed field for this model, lookup via key.
         Returns the template of this field if render is False, otherwise returns the rendered value.
         """
         try:
-            computed_field = ComputedField.objects.get_for_model(self).get(slug=slug)
+            computed_field = ComputedField.objects.get_for_model(self).get(key=key)
         except ComputedField.DoesNotExist:
-            logger.warning("Computed Field with slug %s does not exist for model %s", slug, self._meta.verbose_name)
+            logger.warning("Computed Field with key %s does not exist for model %s", key, self._meta.verbose_name)
             return None
         if render:
             return computed_field.render(context={"obj": self})
@@ -268,7 +270,7 @@ class CustomFieldModel(models.Model):
     def get_computed_fields(self, label_as_key=False, advanced_ui=None):
         """
         Return a dictionary of all computed fields and their rendered values for this model.
-        Keys are the `slug` value of each field. If label_as_key is True, `label` values of each field are used as keys.
+        Keys are the `key` value of each field. If label_as_key is True, `label` values of each field are used as keys.
         """
         computed_fields_dict = {}
         computed_fields = ComputedField.objects.get_for_model(self)
@@ -277,7 +279,7 @@ class CustomFieldModel(models.Model):
         if not computed_fields:
             return {}
         for cf in computed_fields:
-            computed_fields_dict[cf.label if label_as_key else cf.slug] = cf.render(context={"obj": self})
+            computed_fields_dict[cf.label if label_as_key else cf.key] = cf.render(context={"obj": self})
         return computed_fields_dict
 
 
@@ -417,7 +419,7 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
         # Validate the field's default value (if any)
         if self.default is not None:
             try:
-                self.validate(self.default)
+                self.default = self.validate(self.default)
             except ValidationError as err:
                 raise ValidationError({"default": f'Invalid default value "{self.default}": {err.message}'})
 
@@ -455,11 +457,14 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
     ):
         """
         Return a form field suitable for setting a CustomField's value for an object.
-        set_initial: Set initial date for the field. This should be False when generating a field for bulk editing.
-        enforce_required: Honor the value of CustomField.required. Set to False for filtering/bulk editing.
-        for_csv_import: Return a form field suitable for bulk import of objects in CSV format.
-        simple_json_filter: Return a TextInput widget for JSON filtering instead of the default TextArea widget.
-        label: Set the input label manually (if required) otherwise it will default to field's __str__() implementation.
+
+        Args:
+            set_initial: Set initial date for the field. This should be False when generating a field for bulk editing.
+            enforce_required: Honor the value of CustomField.required. Set to False for filtering/bulk editing.
+            for_csv_import: Return a form field suitable for bulk import of objects. Despite the parameter name,
+                this is *not* used for CSV imports since 2.0, but it *is* used for JSON/YAML import of DeviceTypes.
+            simple_json_filter: Return a TextInput widget for JSON filtering instead of the default TextArea widget.
+            label: Set the input label manually (if required); otherwise, defaults to field's __str__() implementation.
         """
         initial = self.default if set_initial else None
         required = self.required if enforce_required else False
@@ -555,6 +560,8 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
     def validate(self, value):
         """
         Validate a value according to the field's type validation rules.
+
+        Returns the value, possibly cleaned up
         """
         if value not in [None, "", []]:
             # Validate text field
@@ -568,7 +575,7 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
             # Validate integer
             if self.type == CustomFieldTypeChoices.TYPE_INTEGER:
                 try:
-                    int(value)
+                    value = int(value)
                 except ValueError:
                     raise ValidationError("Value must be an integer.")
                 if self.validation_minimum is not None and value < self.validation_minimum:
@@ -577,13 +584,11 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                     raise ValidationError(f"Value must not exceed {self.validation_maximum}")
 
             # Validate boolean
-            if self.type == CustomFieldTypeChoices.TYPE_BOOLEAN and value not in [
-                True,
-                False,
-                1,
-                0,
-            ]:
-                raise ValidationError("Value must be true or false.")
+            if self.type == CustomFieldTypeChoices.TYPE_BOOLEAN:
+                try:
+                    value = is_truthy(value)
+                except ValueError as exc:
+                    raise ValidationError("Value must be true or false.") from exc
 
             # Validate date
             if self.type == CustomFieldTypeChoices.TYPE_DATE:
@@ -601,6 +606,8 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
                     )
 
             if self.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
+                if isinstance(value, str):
+                    value = value.split(",")
                 if not set(value).issubset(self.custom_field_choices.values_list("value", flat=True)):
                     raise ValidationError(
                         f"Invalid choice(s) ({value}). Available choices are: {', '.join(self.custom_field_choices.values_list('value', flat=True))}"
@@ -609,6 +616,8 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
         elif self.required:
             raise ValidationError("Required field cannot be empty.")
 
+        return value
+
     def delete(self, *args, **kwargs):
         """
         Handle the cleanup of old custom field data when a CustomField is deleted.
@@ -619,9 +628,6 @@ class CustomField(BaseModel, ChangeLoggedModel, NotesMixin):
 
         delete_custom_field_data.delay(self.key, content_types)
 
-    def get_absolute_url(self):
-        return reverse("extras:customfield", args=[self.pk])
-
     def add_prefix_to_cf_key(self):
         return "cf_" + str(self.key)
 

nautobot/extras/models/datasources.py

@@ -2,14 +2,14 @@
 import os
 
 from django.conf import settings
+from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.core.validators import URLValidator
-from django.db import models, transaction
-from django.urls import reverse
+from django.db import models
 
-from nautobot.core.models.fields import AutoSlugField
+from nautobot.core.models.fields import AutoSlugField, slugify_dashes_to_underscores
 from nautobot.core.models.generics import PrimaryModel
-from nautobot.extras.utils import extras_features
+from nautobot.extras.utils import extras_features, check_if_key_is_graphql_safe
 
 
 @extras_features(
@@ -25,7 +25,11 @@ class GitRepository(PrimaryModel):
         max_length=100,
         unique=True,
     )
-    slug = AutoSlugField(populate_from="name")
+    slug = AutoSlugField(
+        populate_from="name",
+        help_text="Internal field name. Please use underscores rather than dashes in this key.",
+        slugify_function=slugify_dashes_to_underscores,
+    )
 
     remote_url = models.URLField(
         max_length=255,
@@ -58,7 +62,6 @@ class GitRepository(PrimaryModel):
     # the data types registered in registry['datasource_contents'].
     provided_contents = models.JSONField(encoder=DjangoJSONEncoder, default=list, blank=True)
 
-    csv_headers = ["name", "slug", "remote_url", "branch", "secrets_group", "provided_contents"]
     clone_fields = ["remote_url", "secrets_group", "provided_contents"]
 
     class Meta:
@@ -67,8 +70,6 @@ class GitRepository(PrimaryModel):
         verbose_name_plural = "Git repositories"
 
     def __init__(self, *args, **kwargs):
-        # If instantiated from the REST API, the originating Request will be passed as a kwarg:
-        self.request = kwargs.pop("request", None)
         super().__init__(*args, **kwargs)
 
         # Store the initial repo slug so we can check for changes on save().
@@ -77,8 +78,30 @@ class GitRepository(PrimaryModel):
     def __str__(self):
         return self.name
 
-    def get_absolute_url(self):
-        return reverse("extras:gitrepository", kwargs={"slug": self.slug})
+    def clean(self):
+        super().clean()
+
+        if self.slug != "":
+            check_if_key_is_graphql_safe(self.__class__.__name__, self.slug, "slug")
+
+            if self.present_in_database and self.slug != self.__initial_slug:
+                raise ValidationError(
+                    f"Slug cannot be changed once set. Current slug is {self.__initial_slug}, "
+                    f"requested slug is {self.slug}"
+                )
+
+    def get_latest_sync(self):
+        """
+        Return a `JobResult` for the latest sync operation.
+
+        Returns:
+            JobResult
+        """
+        from nautobot.extras.models import JobResult
+
+        # This will match all "GitRepository" jobs (pull/refresh, dry-run, etc.)
+        prefix = "nautobot.core.jobs.GitRepository"
+        return JobResult.objects.filter(task_name__startswith=prefix, task_kwargs__repository=self.pk).latest()
 
     def to_csv(self):
         return (
@@ -94,47 +117,22 @@ class GitRepository(PrimaryModel):
     def filesystem_path(self):
         return os.path.join(settings.GIT_ROOT, self.slug)
 
-    def set_dryrun(self):
+    def sync(self, user, dry_run=False):
         """
-        Add _dryrun flag.
+        Enqueue a Job to pull the Git repository from the remote and return the sync result.
 
-        The existence of this flag indicates that the next sync of this repo (on save()) should be a dry-run only.
-        """
-        self._dryrun = True
-
-    def save(self, *args, trigger_resync=True, **kwargs):
-        super().save(*args, **kwargs)
-
-        def on_commit_callback():
-            if self.__initial_slug and self.slug != self.__initial_slug:
-                # Rename any previously existing repo directory to the new slug.
-                # TODO: In a distributed Nautobot deployment, each Django instance and/or worker instance may
-                # have its own clone of this repository on its own local filesystem; we need some way to ensure
-                # that all such clones are renamed.
-                # For now we just rename the one that we have locally and rely on other methods
-                # (notably get_jobs()) to clean up other clones as they're encountered.
-                if os.path.exists(os.path.join(settings.GIT_ROOT, self.__initial_slug)):
-                    os.rename(
-                        os.path.join(settings.GIT_ROOT, self.__initial_slug),
-                        self.filesystem_path,
-                    )
-
-            dry_run = hasattr(self, "_dryrun")
-            if trigger_resync or dry_run:
-                assert self.request is not None, "No HTTP request associated with this update!"
-                from nautobot.extras.datasources import (
-                    enqueue_pull_git_repository_and_refresh_data,
-                    enqueue_git_repository_diff_origin_and_local,
-                )
+        Args:
+            user (User): The User that will perform the sync.
+            dry_run (bool): If set, dry-run the Git sync.
 
-                # NOTE: if dry_run is True, there would be no need to trigger a resync
-                # regardless of the trigger_resync value (True/False)
-                if dry_run:
-                    enqueue_git_repository_diff_origin_and_local(self, self.request)
-                else:
-                    enqueue_pull_git_repository_and_refresh_data(self, self.request)
-
-            # Update cached values
-            self.__initial_slug = self.slug
+        Returns:
+            JobResult
+        """
+        from nautobot.extras.datasources import (
+            enqueue_pull_git_repository_and_refresh_data,
+            enqueue_git_repository_diff_origin_and_local,
+        )
 
-        transaction.on_commit(on_commit_callback)
+        if dry_run:
+            return enqueue_git_repository_diff_origin_and_local(self, user)
+        return enqueue_pull_git_repository_and_refresh_data(self, user)

nautobot/extras/models/groups.py

@@ -8,7 +8,6 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db import models
-from django.urls import reverse
 from django.utils.functional import cached_property
 
 from nautobot.core.forms.constants import BOOLEAN_WITH_BLANK_CHOICES
@@ -322,9 +321,6 @@ class DynamicGroup(OrganizationalModel):
         """Return the number of member objects in this group."""
         return self.members.count()
 
-    def get_absolute_url(self):
-        return reverse("extras:dynamicgroup", kwargs={"pk": self.pk})
-
     def get_group_members_url(self):
         """Get URL to group members."""
         if self.model is None:
@@ -896,9 +892,12 @@ class DynamicGroupMembership(BaseModel):
         """Return the group count."""
         return self.group.count
 
-    def get_absolute_url(self):
+    def get_absolute_url(self, api=False):
         """Return the group's absolute URL."""
-        return self.group.get_absolute_url()
+        # TODO: we should be able to have an absolute UI URL for this model in the new UI
+        if not api:
+            return self.group.get_absolute_url(api=api)
+        return super().get_absolute_url(api=api)
 
     def get_group_members_url(self):
         """Return the group members URL."""