Initial example of using notification system for view-specific errors

I found myself rebuilding these messages in template code and figured it
would be a good excuse to further consolidate the patterns we're using.

In short, these messages are emitted at view time and are not saved to
the database. The view time logic is similar as notifications however.

A few questions stand for me:

- I like centering all of our notifications/errors around exceptions, as
  it retains an opportunity to emit exceptions from wherever we might
  want to move some of this logic. Arguably, this logic should not exist
  on a single view and could be moved on to modeling/queryset classes.
- I don't have a strong opinion on whether it's important for these
  messages to exist in the registry. I see arguments for both, but I
  chose to use the registry so that we can consolidate logic there --
  format values and message lookup, etc.

I'm looking for input on these patterns.

On the template side, the display is now just a simple `if` and template
logic similar to the current notification display, using the header/body
render methods.

Author: agjohnson

readthedocs/projects/exceptions.py

@@ -2,6 +2,7 @@
 
 
 from readthedocs.doc_builder.exceptions import BuildAppError, BuildUserError
+from readthedocs.notifications.exceptions import NotificationBaseException
 
 
 class ProjectConfigurationError(BuildUserError):
@@ -32,3 +33,20 @@ class SyncRepositoryLocked(BuildAppError):
     """Error risen when there is another sync_repository_task already running."""
 
     REPOSITORY_LOCKED = "project:repository:locked"
+
+
+class ProjectAutomaticCreationDisallowed(NotificationBaseException):
+
+    """Used for raising messages in the project automatic create form view"""
+
+    NO_CONNECTED_ACCOUNT = "project:create:automatic:no-connected-account"
+    SSO_ENABLED = "project:create:automatic:sso-enabled"
+    INADEQUATE_PERMISSIONS = "project:create:automatic:inadequate-permissions"
+
+
+class ProjectManualCreationDisallowed(NotificationBaseException):
+
+    """Used for raising messages in the project manual create form view"""
+
+    SSO_ENABLED = "project:create:manual:sso-enabled"
+    INADEQUATE_PERMISSIONS = "project:create:manual:inadequate-permissions"

readthedocs/projects/notifications.py

@@ -6,7 +6,9 @@
 from readthedocs.notifications.constants import ERROR, INFO, WARNING
 from readthedocs.notifications.messages import Message, registry
 from readthedocs.projects.exceptions import (
+    ProjectAutomaticCreationDisallowed,
     ProjectConfigurationError,
+    ProjectManualCreationDisallowed,
     RepositoryError,
     SyncRepositoryLocked,
     UserFileNotFound,
@@ -145,5 +147,48 @@
         ),
         type=WARNING,
     ),
+    # The following messages are added to the registry but are only used
+    # directly by the project creation view template. These could be split out
+    # directly for use by import, instead of reusing message id lookup.
+    Message(
+        id=ProjectAutomaticCreationDisallowed.NO_CONNECTED_ACCOUNT,
+        header=_("No connected services found"),
+        body=_(
+            textwrap.dedent(
+                # Translators: "connected service" refers to the user setting page for "Connected Services"
+                """
+                You must first <a href="{{ url }}">add a connected service to your account</a>
+                to enable automatic configuration of repositories.
+                """
+            ).strip(),
+        ),
+        type=WARNING,
+    ),
+    Message(
+        id=ProjectAutomaticCreationDisallowed.SSO_ENABLED,
+        header=_("Organization single sign-on enabled"),
+        body=_(
+            textwrap.dedent(
+                """
+                Only organization owners may create new projects when single
+                sign-on is enabled.
+                """
+            ).strip(),
+        ),
+        type=WARNING,
+    ),
+    Message(
+        id=ProjectManualCreationDisallowed.SSO_ENABLED,
+        header=_("Organization single sign-on enabled"),
+        body=_(
+            textwrap.dedent(
+                """
+                Projects cannot be manually configured when single sign-on is
+                enabled.
+                """
+            ).strip(),
+        ),
+        type=WARNING,
+    ),
 ]
 registry.add(messages)

readthedocs/projects/views/private.py

@@ -42,10 +42,15 @@
 from readthedocs.core.notifications import MESSAGE_EMAIL_VALIDATION_PENDING
 from readthedocs.integrations.models import HttpExchange, Integration
 from readthedocs.invitations.models import Invitation
+from readthedocs.notifications.messages import registry as messages_registry
 from readthedocs.notifications.models import Notification
 from readthedocs.oauth.services import registry
 from readthedocs.oauth.tasks import attach_webhook
 from readthedocs.oauth.utils import update_webhook
+from readthedocs.projects.exceptions import (
+    ProjectAutomaticCreationDisallowed,
+    ProjectManualCreationDisallowed,
+)
 from readthedocs.projects.filters import ProjectListFilterSet
 from readthedocs.projects.forms import (
     AddonsConfigForm,
@@ -397,9 +402,55 @@ def post(self, request, *args, **kwargs):
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
         context['view_csrf_token'] = get_token(self.request)
-        context['has_connected_accounts'] = SocialAccount.objects.filter(
-            user=self.request.user,
-        ).exists()
+
+        if settings.RTD_EXT_THEME_ENABLED:
+            error_import_manually = None
+            error_import_automatically = None
+
+            has_connected_account = SocialAccount.objects.filter(
+                user=self.request.user,
+            ).exists()
+
+            # First check ability for automatic project creation
+            # NOTE that try catch is used here, but isn't super useful yet. But
+            # if it makes more sense to house this logic outside this view,
+            # somewhere central to organization/user modeling, then we don't
+            # have to change any code here.
+            try:
+                if has_connected_account:
+                    raise ProjectAutomaticCreationDisallowed(
+                        message_id=ProjectAutomaticCreationDisallowed.NO_CONNECTED_ACCOUNT,
+                        format_values={
+                            "url": reverse("socialaccount_connections"),
+                        },
+                    )
+                # TODO if organization sso enabled and user is not an owner
+                if True:
+                    raise ProjectAutomaticCreationDisallowed(
+                        message_id=ProjectAutomaticCreationDisallowed.SSO_ENABLED,
+                    )
+            except ProjectAutomaticCreationDisallowed as exc:
+                error_import_automatically = messages_registry.get(
+                    exc.message_id,
+                    format_values=exc.format_values,
+                )
+
+            # Next check ability for manual project creation
+            try:
+                # TODO if organization sso enabled
+                if True:
+                    raise ProjectManualCreationDisallowed(
+                        ProjectManualCreationDisallowed.SSO_ENABLED
+                    )
+            except ProjectManualCreationDisallowed as exc:
+                error_import_manually = messages_registry.get(
+                    exc.message_id,
+                    format_values=exc.format_values,
+                )
+
+            context["error_import_automatically"] = error_import_automatically
+            context["error_import_manually"] = error_import_manually
+
         return context