[ENG-7873] CLONE - SPAM - When Hamming a Spammed user, preprints and registrations remain private (#11125)

## Purpose
fix was_public state when flag spam

## Changes
- correct check if node was public when flag_spam
- use earliest confirm/flag spam log to check if node was public instead of the latest one
---
- fix TypeError when check archiving status for stuck registrations (not related to ticket ENG-7873, but it's just one line `permissible_addons = set(permissible_addons)`, so no additional testing is required)

## QA Notes
I couldn't reproduce this issue via UI, but combination `confirm_spam()` -> `flag_spam()` -> `...` breaks this feature. I'm not sure if it's exactly what's happening in our case, but since `flag_spam()` is used with automatic spam checks during node/preprint updates, it's quite possible.

## Ticket
https://openscience.atlassian.net/browse/ENG-7873

Author: antkryt

osf/models/mixins.py

@@ -2081,6 +2081,22 @@ def log_class(self):
     def log_params(self):
         return NotImplementedError()
 
+    @property
+    def was_public_at_spam(self):
+        was_public = self.is_public
+        try:
+            latest_privacy_edit = self.logs.filter(
+                action__in=[self.log_class.MADE_PRIVATE, self.log_class.MADE_PUBLIC]
+            ).latest('created')
+            first_spam_log = self.logs.filter(
+                action__in=[self.log_class.FLAG_SPAM, self.log_class.CONFIRM_SPAM],
+                created__gt=latest_privacy_edit.created
+            ).earliest('created')
+
+            return first_spam_log.params.get('was_public', was_public)
+        except ObjectDoesNotExist:
+            return was_public
+
     def get_spam_fields(self, saved_fields=None):
         return NotImplementedError()
 
@@ -2110,15 +2126,8 @@ def confirm_spam(self, domains=None, save=True, train_spam_services=True):
         """
         super().confirm_spam(save=save, domains=domains or [], train_spam_services=train_spam_services)
         self.deleted = timezone.now()
-        was_public = self.is_public
-        # the approach below helps to update to public true on ham just the objects that were public before were spammed
-        is_public_changings = self.logs.filter(action__in=['made_public', 'made_private'])
-        if is_public_changings:
-            latest_privacy_edit_time = is_public_changings.latest('created').created
-            last_spam_log = self.logs.filter(action__in=['confirm_spam', 'flag_spam'],
-                                                 created__gt=latest_privacy_edit_time)
-            if last_spam_log:
-                was_public = last_spam_log.latest().params.get('was_public', was_public)
+        was_public = self.was_public_at_spam
+
         self.set_privacy('private', auth=None, log=False, save=False, force=True, should_hide=True)
 
         log = self.add_log(
@@ -2221,7 +2230,6 @@ def suspend_spam_user(self, user):
         if user.is_hammy:
             return False
         self.confirm_spam(save=True, train_spam_services=False)
-        self.set_privacy('private', log=False, save=True)
 
         # Suspend the flagged user for spam.
         user.flag_spam()
@@ -2240,20 +2248,18 @@ def suspend_spam_user(self, user):
         for node in user.all_nodes:
             if self._id != node._id and len(node.contributors) == 1 and node.is_public and not node.is_quickfiles:
                 node.confirm_spam(save=True, train_spam_services=False)
-                node.set_privacy('private', log=False, save=True, force=True)
 
         # Make preprints private from this contributor
         for preprint in user.preprints.all():
             if self._id != preprint._id and len(preprint.contributors) == 1 and preprint.is_public:
                 preprint.confirm_spam(save=True, train_spam_services=False)
-                preprint.set_privacy('private', log=False, save=True)
 
     def flag_spam(self):
         """ Overrides SpamMixin#flag_spam.
         """
         super().flag_spam()
         if settings.SPAM_FLAGGED_MAKE_NODE_PRIVATE:
-            was_public = self.is_public
+            was_public = self.was_public_at_spam
             self.set_privacy('private', auth=None, log=False, save=False, check_addons=False, force=True, should_hide=True)
             log = self.add_log(
                 action=self.log_class.FLAG_SPAM,

osf/models/user.py

@@ -995,10 +995,8 @@ def deactivate_account(self):
             )
         except mailchimp_utils.OSFError as error:
             sentry.log_exception(error)
-            sentry.log_message(error)
         except Exception as error:
             sentry.log_exception(error)
-            sentry.log_message(error)
         # Call to `unsubscribe` above saves, and can lead to stale data
         self.reload()
         self.is_disabled = True
@@ -1022,10 +1020,8 @@ def reactivate_account(self):
             subscribe_on_confirm(self)
         except OSFError as error:
             sentry.log_exception(error)
-            sentry.log_message(error)
         except Exception as error:
             sentry.log_exception(error)
-            sentry.log_message(error)
         signals.user_account_reactivated.send(self)
 
     def update_is_active(self):

osf_tests/test_node.py

@@ -2428,6 +2428,42 @@ def test_confirm_spam_makes_node_private(self, project):
         assert project.is_spammy
         assert project.is_public is False
 
+    @mock.patch.object(settings, 'SPAM_FLAGGED_MAKE_NODE_PRIVATE', True)
+    def test_project_remains_recoverable_after_multiple_spam_flags(self, project):
+        project.set_privacy('public')
+        assert project.is_public
+
+        project.confirm_spam()
+        assert project.is_public is False
+        assert project.was_public_at_spam is True
+
+        project.flag_spam()
+        assert project.is_public is False
+        assert project.was_public_at_spam is True
+
+        project.confirm_spam()
+        assert project.is_public is False
+        assert project.was_public_at_spam is True
+
+    def test_multiple_privacy_changing(self, project):
+        project.set_privacy('public')
+        assert project.is_public
+
+        project.confirm_spam()
+        assert not project.is_public
+
+        project.confirm_ham()
+        assert project.is_public
+
+        project.set_privacy('private')
+        assert not project.is_public
+
+        project.confirm_spam()
+        assert not project.is_public
+
+        project.confirm_ham()
+        assert not project.is_public
+
 
 # copied from tests/test_models.py
 class TestPrivateLinks: