regscale-cli 6.21.2.0__py3-none-any.whl → 6.28.2.1__py3-none-any.whl

regscale/models/regscale_models/regscale_model.py

@@ -60,6 +60,8 @@ class RegScaleModel(BaseModel, ABC):
 
     _pending_updates: ClassVar[Dict[str, Set[int]]] = {}
     _pending_creations: ClassVar[Dict[str, Set[str]]] = {}
+    _session_created_ids: ClassVar[Set[int]] = set()  # Track IDs created in current session for dedupe detection
+    _ignore_has_changed: bool = False
 
     id: int = 0
     extra_data: Dict[str, Any] = Field(default={}, exclude=True)
@@ -181,6 +183,7 @@ class RegScaleModel(BaseModel, ABC):
     def _get_cache_key(cls, obj: T, defaults: Optional[Dict[str, Any]] = None) -> str:
         """
         Generate a cache key based on the object's unique fields using SHA256 hash.
+        Includes parentId to scope cache keys to individual security plans/parents.
 
         :param T obj: The object to generate a key for
         :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply to the object, defaults to None
@@ -188,6 +191,14 @@ class RegScaleModel(BaseModel, ABC):
         :rtype: str
         """
         defaults = defaults or {}
+
+        # Get parent ID to scope cache keys to individual parents (e.g., security plans)
+        # This prevents assets/issues/etc. from being matched across different security plans
+        parent_id = getattr(obj, cls._parent_id_field, None)
+        # Check if parent_id is None and try defaults if available
+        if parent_id is None and defaults:
+            parent_id = defaults.get(cls._parent_id_field)
+
         # Iterate over each set of unique fields
         for fields in cls.get_unique_fields():
             unique_fields = []
@@ -206,11 +217,12 @@ class RegScaleModel(BaseModel, ABC):
             # If all fields in the current set have values, use them to generate the cache key
             if len(unique_fields) == len(fields):
                 unique_string = ":".join(unique_fields)
-                cache_key = f"{cls.__name__}:{unique_string}"
+                # Include parent_id in cache key to scope to individual security plans/parents
+                cache_key = f"{cls.__name__}:{parent_id}:{unique_string}"
                 return cache_key
 
         # Fallback if no complete set of unique fields is found, use object ID
-        return f"{cls.__name__}:{obj.get_object_id()}"
+        return f"{cls.__name__}:{parent_id}:{obj.get_object_id()}"
 
     @classmethod
     def get_cached_object(cls, cache_key: str) -> Optional[T]:
@@ -502,31 +514,93 @@ class RegScaleModel(BaseModel, ABC):
         :return: A list of unique fields
         :rtype: List[List[str]]
         """
-        sample_format = {"uniqueOverride": {"asset": ["ipAddress"]}}
         config = Application().config
 
+        # First, ensure _unique_fields is in new format (List[List[str]])
+        cls._ensure_unique_fields_format()
+
         try:
             primary = config.get("uniqueOverride", {}).get(cls.__name__.lower())
             if primary:
-                if not isinstance(primary, list):
-                    raise ValueError(
-                        f"Invalid config format in uniqueOverride.{cls.__name__.lower()}, the configuration must be in a format like so:\n{dump(sample_format, default_flow_style=False)}"
-                    )
-                if primary != cls._unique_fields:
-                    if all(attr in cls.model_fields for attr in primary):
-                        if primary not in cls._unique_fields:
-                            cls._unique_fields.insert(1, primary)
-                        else:
-                            # Move primary to index 1 if it exists
-                            cls._unique_fields.insert(1, cls._unique_fields.pop(cls._unique_fields.index(primary)))
-                    else:
-                        raise ValueError(
-                            f"One or more invalid attribute(s) detected: {primary}, falling back on default unique fields for type: {cls.__name__.lower()}"
-                        )
+                cls._process_primary_override(primary)
         except ValueError as e:
             logger.warning(e)
         return cls._unique_fields
 
+    @classmethod
+    def _ensure_unique_fields_format(cls) -> None:
+        """
+        Ensure _unique_fields is in the new format (List[List[str]]).
+
+        :rtype: None
+        """
+        # Check if it's still in old format (List[str])
+        if cls._unique_fields and isinstance(cls._unique_fields[0], str):
+            # Convert old format to new format
+            cls._unique_fields = [cls._unique_fields]  # type: ignore
+
+    @classmethod
+    def _process_primary_override(cls, primary: List[str]) -> None:
+        """
+        Process the primary override configuration.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If the primary fields are invalid
+        :rtype: None
+        """
+        cls._validate_primary_format(primary)
+
+        # Now cls._unique_fields is guaranteed to be List[List[str]]
+        # Check if primary is different from any existing unique field set
+        if primary not in cls._unique_fields:
+            cls._handle_new_primary_fields(primary)
+
+    @classmethod
+    def _validate_primary_format(cls, primary: List[str]) -> None:
+        """
+        Validate the format of the primary override configuration.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If the primary format is invalid
+        :rtype: None
+        """
+        if not isinstance(primary, list):
+            sample_format = {"uniqueOverride": {"asset": ["ipAddress"]}}
+            raise ValueError(
+                f"Invalid config format in uniqueOverride.{cls.__name__.lower()}, the configuration must be in a format like so:\n{dump(sample_format, default_flow_style=False)}"
+            )
+
+    @classmethod
+    def _handle_new_primary_fields(cls, primary: List[str]) -> None:
+        """
+        Handle new primary fields that are not in existing unique fields.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If any attributes are invalid
+        :rtype: None
+        """
+        if all(attr in cls.model_fields for attr in primary):
+            cls._insert_primary_fields(primary)
+        else:
+            raise ValueError(
+                f"One or more invalid attribute(s) detected: {primary}, falling back on default unique fields for type: {cls.__name__.lower()}"
+            )
+
+    @classmethod
+    def _insert_primary_fields(cls, primary: List[str]) -> None:
+        """
+        Insert primary fields into the unique fields list.
+
+        :param List[str] primary: The primary override fields
+        :rtype: None
+        """
+        # Check if primary already exists in the list
+        if primary not in cls._unique_fields:
+            cls._unique_fields.insert(1, primary)
+        else:
+            # Move primary to index 1 if it exists
+            cls._unique_fields.insert(1, cls._unique_fields.pop(cls._unique_fields.index(primary)))
+
     @classmethod
     def _get_endpoints(cls) -> ConfigDict:
         """
@@ -612,19 +686,37 @@ class RegScaleModel(BaseModel, ABC):
             raise NotImplementedError(f"_unique_fields not defined for {self.__class__.__name__}")
 
         parent_id = getattr(self, parent_id_field or self._parent_id_field, None)
+        logger.debug(
+            f"find_by_unique for {self.__class__.__name__}: parent_id={parent_id} (type: {type(parent_id).__name__}), "
+            f"parent_id_field={parent_id_field or self._parent_id_field}"
+        )
         if parent_id is None:
             raise ValueError(f"Parent ID not found for {self.__class__.__name__}")
 
         parent_module = getattr(self, "parentModule", getattr(self, "parent_module", ""))
+        logger.debug(f"find_by_unique for {self.__class__.__name__}: parent_module={parent_module}")
         cache_key = self._get_cache_key(self)
 
         with self._get_lock(cache_key):
             # Check cache first
             if cached_object := self.get_cached_object(cache_key):
+                logger.debug(f"find_by_unique for {self.__class__.__name__}: Found in cache")
                 return cached_object
 
             # Get all instances from parent
+            logger.debug(
+                f"find_by_unique for {self.__class__.__name__}: Calling get_all_by_parent with "
+                f"parent_id={parent_id}, parent_module={parent_module}"
+            )
             instances: List[T] = self.get_all_by_parent(parent_id=parent_id, parent_module=parent_module)
+            logger.debug(
+                f"find_by_unique for {self.__class__.__name__}: Retrieved {len(instances)} instances from parent_id={parent_id}"
+            )
+            if instances:
+                parent_ids = set(getattr(inst, self._parent_id_field, None) for inst in instances[:10])
+                logger.debug(
+                    f"find_by_unique for {self.__class__.__name__}: Sample parent_ids in results: {parent_ids}"
+                )
 
             # Try to find matching instance using unique fields
             for keys in self._unique_fields:
@@ -642,8 +734,14 @@ class RegScaleModel(BaseModel, ABC):
                     None,
                 )
                 if matching_instance:
+                    matched_parent_id = getattr(matching_instance, self._parent_id_field, None)
+                    logger.debug(
+                        f"find_by_unique for {self.__class__.__name__}: Found match using fields {keys}, "
+                        f"matched instance parent_id={matched_parent_id}, current parent_id={parent_id}"
+                    )
                     return matching_instance
 
+        logger.debug(f"find_by_unique for {self.__class__.__name__}: No matching instance found")
         return None
 
     def get_or_create_with_status(self: T, bulk: bool = False) -> Tuple[bool, T]:
@@ -665,17 +763,45 @@ class RegScaleModel(BaseModel, ABC):
                 self.cache_object(instance)
                 return False, instance
             else:
-                created_instance = self.create(bulk=bulk)
-                self.cache_object(created_instance)
-                return True, created_instance
+                try:
+                    created_instance = self.create(bulk=bulk)
+                    self.cache_object(created_instance)
+                    return True, created_instance
+                except APIInsertionError as e:
+                    # Check if this is a duplicate error (race condition in threading)
+                    error_str = str(e).lower()
+                    if "already exists" in error_str or "mapping already exists" in error_str:
+                        logger.debug(
+                            f"Race condition detected for {self.__class__.__name__}, retrying find_by_unique: {e}"
+                        )
+                        # Clear the cache to force a fresh lookup
+                        self.clear_cache()
+                        # Try to find the instance again - another thread may have created it
+                        instance = self.find_by_unique()
+                        if instance:
+                            self.cache_object(instance)
+                            logger.debug(
+                                f"Successfully found existing {self.__class__.__name__} after duplicate creation error, ID: {instance.id}"
+                            )
+                            return False, instance
+                        else:
+                            # If we still can't find it, log error but don't stop the process
+                            logger.error(
+                                f"Failed to find {self.__class__.__name__} after duplicate creation error: {e}"
+                            )
+                            # Return None to indicate creation failed but don't raise
+                            return False, None
+                    else:
+                        # Not a duplicate error, re-raise
+                        logger.error(f"Failed to create object: {self.__class__.__name__} creation error: {e}")
 
-    def get_or_create(self: T, bulk: bool = False) -> T:
+    def get_or_create(self: T, bulk: bool = False) -> Optional[T]:
         """
         Get or create an instance.
 
         :param bool bulk: Whether to perform a bulk create operation, defaults to False
-        :return: The instance
-        :rtype: T
+        :return: The instance or None if creation failed due to race condition
+        :rtype: Optional[T]
         """
         _, instance = self.get_or_create_with_status(bulk=bulk)
         return instance
@@ -705,15 +831,15 @@ class RegScaleModel(BaseModel, ABC):
         bulk_create: bool = False,
         bulk_update: bool = False,
         defaults: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[bool, T]:
+    ) -> Tuple[str, T]:
         """
         Create or update an instance. Use cache methods to retrieve and store instances based on unique fields.
 
         :param bool bulk_create: Whether to perform a bulk create, defaults to False
         :param bool bulk_update: Whether to perform a bulk update, defaults to False
         :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply to the instance if it is created, defaults to {}
-        :return: The instance of the class
-        :rtype: Tuple[bool, T]
+        :return: Tuple of (status, instance) where status is "created", "updated", or "deduped"
+        :rtype: Tuple[str, T]
         """
         logger.debug(f"Starting create_or_update for {self.__class__.__name__}: #{getattr(self, 'id', '')}")
 
@@ -727,44 +853,106 @@ class RegScaleModel(BaseModel, ABC):
             instance = cached_object or self.find_by_unique()
 
             if instance:
-                # An existing instance was found (either in cache or database)
-                logger.debug(f"Found {'cached' if cached_object else 'existing'} instance of {self.__class__.__name__}")
-                # Update the current object's ID with the found instance's ID
-                self.id = instance.id
-                # If the object has a 'dateCreated' attribute, update it
-                if hasattr(self, "dateCreated"):
-                    self.dateCreated = instance.dateCreated  # noqa
-
-                # Update the _original_data attribute with the instance data
-                self._original_data = instance.dict(exclude_unset=True)
-
-                # Check if the current object has any changes compared to the found instance
-                if self.has_changed():
-                    logger.debug(f"Instance of {self.__class__.__name__} has changed, updating")
-                    # Save the changes, potentially in bulk
-                    updated_instance = self.save(bulk=bulk_update)
-                    # Update the cache with the new instance
-                    self.cache_object(updated_instance)
-                    # Return the updated instance, optionally with a flag indicating it wasn't newly created
-                    return False, updated_instance
-
-                # If no changes, return the existing instance
-                return False, instance
+                return self._handle_existing_instance(instance, cached_object, bulk_update)
 
             # No existing instance was found, so create a new one
-            # apply defaults if they are provided
-            if defaults:
-                for key, value in defaults.items():
-                    # Handle callable values by executing them
-                    if callable(value):
-                        value = value()
-                    setattr(self, key, value)
-            logger.debug(f"No existing instance found for {self.__class__.__name__}, creating new")
-            created_instance = self.create(bulk=bulk_create)
-            # Cache the newly created instance
-            self.cache_object(created_instance)
-            # Return the created instance, optionally with a flag indicating it was newly created
-            return True, created_instance
+            return self._handle_new_instance(defaults, bulk_create)
+
+    def _handle_existing_instance(self: T, instance: T, cached_object: Optional[T], bulk_update: bool) -> Tuple[str, T]:
+        """
+        Handle processing of an existing instance found in cache or database.
+
+        :param T instance: The found instance
+        :param Optional[T] cached_object: The cached object if found in cache
+        :param bool bulk_update: Whether to perform a bulk update
+        :return: Tuple of (status, instance) where status is "updated" or "deduped"
+        :rtype: Tuple[str, T]
+        """
+        # An existing instance was found (either in cache or database)
+        logger.debug(f"Found {'cached' if cached_object else 'existing'} instance of {self.__class__.__name__}")
+
+        # Update current object with instance data
+        self._sync_with_existing_instance(instance)
+
+        # Check if the current object has any changes compared to the found instance
+        if self.has_changed():
+            return self._update_existing_instance(bulk_update, is_cached=cached_object is not None)
+
+        # If no changes, determine if this is a dedupe or update
+        # Dedupe = found in cache OR was created during this session
+        is_dedupe = cached_object is not None or instance.id in self.__class__._session_created_ids
+        status = "deduped" if is_dedupe else "updated"
+        return status, instance
+
+    def _sync_with_existing_instance(self: T, instance: T) -> None:
+        """
+        Synchronize current object with existing instance data.
+
+        :param T instance: The existing instance to sync with
+        :rtype: None
+        """
+        # Update the current object's ID with the found instance's ID
+        self.id = instance.id
+        # If the object has a 'dateCreated' attribute, update it
+        if hasattr(self, "dateCreated"):
+            self.dateCreated = instance.dateCreated  # noqa
+
+        # Update the _original_data attribute with the instance data
+        self._original_data = instance.dict(exclude_unset=True)
+
+    def _update_existing_instance(self: T, bulk_update: bool, is_cached: bool = False) -> Tuple[str, T]:
+        """
+        Update an existing instance that has changes.
+
+        :param bool bulk_update: Whether to perform a bulk update
+        :param bool is_cached: Whether the instance was found in cache (dedupe) or from API (update)
+        :return: Tuple of (status, updated_instance) where status is "updated" or "deduped"
+        :rtype: Tuple[str, T]
+        """
+        logger.debug(f"Instance of {self.__class__.__name__} has changed, updating")
+        # Save the changes, potentially in bulk
+        updated_instance = self.save(bulk=bulk_update)
+        # Update the cache with the new instance
+        self.cache_object(updated_instance)
+        # Determine if this is a dedupe: found in cache OR was created during this session
+        is_dedupe = is_cached or self.id in self.__class__._session_created_ids
+        status = "deduped" if is_dedupe else "updated"
+        return status, updated_instance
+
+    def _handle_new_instance(self: T, defaults: Optional[Dict[str, Any]], bulk_create: bool) -> Tuple[str, T]:
+        """
+        Handle creation of a new instance when none exists.
+
+        :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply
+        :param bool bulk_create: Whether to perform a bulk create
+        :return: Tuple of (status, created_instance) where status is "created"
+        :rtype: Tuple[str, T]
+        """
+        # apply defaults if they are provided
+        self._apply_defaults(defaults)
+
+        logger.debug(f"No existing instance found for {self.__class__.__name__}, creating new")
+        created_instance = self.create(bulk=bulk_create)
+        # Track this ID as created in this session for dedupe detection
+        self.__class__._session_created_ids.add(created_instance.id)
+        # Cache the newly created instance
+        self.cache_object(created_instance)
+        # Return the created instance with "created" status
+        return "created", created_instance
+
+    def _apply_defaults(self: T, defaults: Optional[Dict[str, Any]]) -> None:
+        """
+        Apply default values to the instance.
+
+        :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply
+        :rtype: None
+        """
+        if defaults:
+            for key, value in defaults.items():
+                # Handle callable values by executing them
+                if callable(value):
+                    value = value()
+                setattr(self, key, value)
 
     @classmethod
     def _handle_list_response(
@@ -1037,24 +1225,33 @@ class RegScaleModel(BaseModel, ABC):
         :return: A list of objects
         :rtype: List[T]
         """
+        logger.debug(
+            f"get_all_by_parent for {cls.__name__}: parent_id={parent_id}, parent_module={parent_module}, "
+            f"search={'provided' if search else 'None'}"
+        )
         cache_key = f"{parent_id}:{cls.__name__}"
 
         with cls._get_lock(cache_key):
             cached_objects = cls._parent_cache.get(cache_key)
             # Check for None and empty list
             if cached_objects is not None and len(cached_objects) > 0:
+                logger.debug(f"get_all_by_parent for {cls.__name__}: Returning {len(cached_objects)} cached objects")
                 return cached_objects
 
-            if "get_all_by_search" in cls._get_endpoints() and parent_id and parent_module and not search:
-                logger.debug("Using get_all_by_search")
+            if "get_all_by_search" in cls._get_endpoints() and parent_id is not None and parent_module and not search:
+                logger.debug(
+                    f"get_all_by_search for {cls.__name__}: Creating Search with parentID={parent_id}, module={parent_module}"
+                )
                 search = Search(parentID=parent_id, module=parent_module)
             if search:
+                logger.debug(f"get_all_by_parent for {cls.__name__}: Using search endpoint")
                 objects: List[T] = cls._handle_looping_response(search)
             else:
                 try:
                     endpoint = cls.get_endpoint("get_all_by_parent").format(
                         intParentID=parent_id, strModule=parent_module
                     )
+                    logger.debug(f"get_all_by_parent for {cls.__name__}: Using endpoint: {endpoint}")
                     objects: List[T] = cls._handle_list_response(
                         cls._get_api_handler().get(endpoint=endpoint), parent_id=parent_id, parent_module=parent_module
                     )
@@ -1062,6 +1259,11 @@ class RegScaleModel(BaseModel, ABC):
                     logger.error(f"Failed to get endpoint: {e}", exc_info=True)
                     objects = []
 
+            logger.debug(f"get_all_by_parent for {cls.__name__}: Retrieved {len(objects)} objects from API")
+            if objects:
+                sample_parent_ids = set(getattr(obj, cls._parent_id_field, None) for obj in objects[:10])
+                logger.debug(f"get_all_by_parent for {cls.__name__}: Sample parent_ids in results: {sample_parent_ids}")
+
             cls.cache_list_objects(cache_key=cache_key, objects=objects)
 
             return objects
@@ -1111,17 +1313,18 @@ class RegScaleModel(BaseModel, ABC):
         return ConfigDict()
 
     @classmethod
-    def get_endpoint(cls, endpoint_type: str) -> str:
+    def get_endpoint(cls, endpoint_type: str, suppress_error: bool = False) -> str:
         """
         Get the endpoint for a specific type.
 
         :param str endpoint_type: The type of endpoint
+        :param bool suppress_error: Whether to suppress the error if the endpoint is not found, defaults to False
         :raises ValueError: If the endpoint type is not found
         :return: The endpoint
         :rtype: str
         """
         endpoint = cls._get_endpoints().get(endpoint_type, "na")  # noqa
-        if not endpoint or endpoint == "na":
+        if not endpoint or endpoint == "na" and not suppress_error:
             logger.error(f"{cls.__name__} does not have endpoint {endpoint_type}")
             raise ValueError(f"Endpoint {endpoint_type} not found")
         endpoint = str(endpoint).replace("{model_slug}", cls.get_module_slug())
@@ -1163,7 +1366,11 @@ class RegScaleModel(BaseModel, ABC):
         """
         # Check if the model has change tracking and if there are changes
         has_change_tracking = hasattr(self, "has_changed") and callable(getattr(self, "has_changed", None))
-        should_save = not has_change_tracking or self.has_changed()
+
+        if hasattr(self, "_ignore_has_changed") and self._ignore_has_changed:
+            should_save = True
+        else:
+            should_save = not has_change_tracking or self.has_changed()
 
         if should_save:
             if bulk:
@@ -1269,7 +1476,15 @@ class RegScaleModel(BaseModel, ABC):
         endpoint = self.get_endpoint("insert")
         response = self._get_api_handler().post(endpoint=endpoint, data=self.dict(), headers=self._get_headers())
         if response and response.ok:
-            obj = self.__class__(**response.json())
+            response_data = response.json()
+
+            # Handle special case for ComponentMapping which may have nested response structure
+            if self.__class__.__name__ == "ComponentMapping" and "componentMapping" in response_data:
+                component_mapping_data = response_data["componentMapping"]
+                obj = self.__class__(**component_mapping_data)
+            else:
+                obj = self.__class__(**response_data)
+
             self.cache_object(obj)
             return obj
         else:
@@ -1407,11 +1622,22 @@ class RegScaleModel(BaseModel, ABC):
                     f"[#f68d1f]Updating {total_items} RegScale {cls.__name__}s...",
                     total=total_items,
                 )
+            endpoint = cls.get_endpoint("batch_update", suppress_error=True)
+            if not endpoint or endpoint == "na":
+                logger.debug(f"No batch_update endpoint found for {cls.__name__}, using save method instead")
+                for item in items:
+                    updated_item = item.save()
+                    cls.cache_object(updated_item)
+                    results.append(updated_item)
+                    if progress and update_job is not None:
+                        progress.advance(update_job, advance=1)
+                cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
+                return results
             for i in range(0, total_items, batch_size):
                 batch = items[i : i + batch_size]
                 batch_results = cls._handle_list_response(
                     cls._get_api_handler().put(
-                        endpoint=cls.get_endpoint("batch_update"),
+                        endpoint=endpoint,
                         data=[item.model_dump() for item in batch if item],
                     )
                 )
@@ -1424,10 +1650,10 @@ class RegScaleModel(BaseModel, ABC):
             cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
 
         if progress_context:
-            process_batch(progress_context)
+            process_batch(progress=progress_context, remove_progress_bar=remove_progress)
         else:
             with create_progress_object() as create_progress:
-                process_batch(create_progress)
+                process_batch(progress=create_progress, remove_progress_bar=remove_progress)
 
         return results
 
@@ -1468,6 +1694,17 @@ class RegScaleModel(BaseModel, ABC):
             logger.warning(f"{cls.__name__}: No matching record found for ID: {cls.__name__} {object_id}")
             return None
 
+    @classmethod
+    def get(cls, id: Union[str, int]) -> Optional[T]:
+        """
+        Get a RegScale object by ID. shortcut for get_object.
+
+        :param Union[str, int] id: The ID of the object
+        :return: The object or None if not found
+        :rtype: Optional[T]
+        """
+        return cls.get_object(object_id=id)
+
     @classmethod
     def get_objects_and_attachments_by_parent(
         cls, parent_id: int, parent_module: str
@@ -1480,7 +1717,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: A tuple of a list of objects and a list of attachments
         :rtype: Tuple[List[T], dict[int, List["File"]]]
         """
-        from regscale.models import File
+        from regscale.models.regscale_models import File
 
         # get the existing issues for the parent record that are already in RegScale
         logger.info("Fetching full %s list from RegScale %s #%i.", cls.__name__, parent_module, parent_id)

regscale/models/regscale_models/security_plan.py

@@ -43,6 +43,7 @@ class SecurityPlan(RegScaleModel):
     environment: Optional[str] = ""
     lawsAndRegulations: Optional[str] = ""
     authorizationBoundary: Optional[str] = ""
+    authorizationTerminationDate: Optional[str] = ""
     networkArchitecture: Optional[str] = ""
     dataFlow: Optional[str] = ""
     overallCategorization: Optional[str] = ""
@@ -107,6 +108,7 @@ class SecurityPlan(RegScaleModel):
     fedrampDateSubmitted: Optional[str] = ""
     fedrampDateAuthorized: Optional[str] = ""
     fedrampId: Optional[str] = ""
+    complianceSettings: Optional[str] = None
     complianceSettingsId: Optional[int] = 1
     tenantsId: int = 1
 
@@ -119,11 +121,11 @@ class SecurityPlan(RegScaleModel):
         :return: The ComplianceSettings ID if the RegScale version is compatible, None otherwise
         :rtype: Optional[int]
         """
-        from packaging.version import Version
+        from regscale.utils.version import RegscaleVersion
 
         regscale_version = cls._get_api_handler().regscale_version
 
-        if len(regscale_version) >= 10 or Version(regscale_version) >= Version("6.13.0.0"):
+        if len(regscale_version) >= 10 or RegscaleVersion.compare_versions(regscale_version, "6.13.0.0"):
             return v
         else:
             return None

regscale/models/regscale_models/vulnerability.py

@@ -67,8 +67,8 @@ class Vulnerability(RegScaleModel):
     lastSeen: Optional[str] = None
     firstSeen: Optional[str] = None
     daysOpen: Optional[int] = None
-    dns: Optional[str] = None
-    ipAddress: Optional[str] = None
+    dns: Optional[str] = ""
+    ipAddress: Optional[str] = ""
     mitigated: Optional[bool] = None
     operatingSystem: Optional[str] = None
     port: Optional[Union[str, int]] = None
@@ -83,7 +83,7 @@ class Vulnerability(RegScaleModel):
     cvsSv3BaseScore: Optional[Union[float, int]] = None
     description: Optional[str] = None
     plugInText: Optional[str] = None
-    tenantsId: int = Field(default=0)
+    tenantsId: int = Field(default_factory=RegScaleModel.get_tenant_id)
     isPublic: bool = Field(default=False)
     dateClosed: Optional[str] = None
     status: Optional[Union[str, IssueStatus]] = Field(default_factory=lambda: IssueStatus.Open)