Teams redesign

engine/apps/alerts/models/alert_receive_channel.py

@@ -8,7 +8,7 @@
 from django.conf import settings
 from django.core.validators import MinLengthValidator
 from django.db import models, transaction
-from django.db.models import Count, Q
+from django.db.models import Q
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils import timezone
@@ -236,55 +236,16 @@ def hard_delete(self):
         super(AlertReceiveChannel, self).delete()
 
     def change_team(self, team_id, user):
-        EscalationPolicy = apps.get_model("alerts", "EscalationPolicy")
 
         if team_id == self.team_id:
             raise TeamCanNotBeChangedError("Integration is already in this team")
 
         if team_id is not None:
-            new_team = user.teams.filter(public_primary_key=team_id).first()
+            new_team = user.available_teams.filter(public_primary_key=team_id).first()
             if not new_team:
                 raise TeamCanNotBeChangedError("User is not a member of the selected team")
         else:
             new_team = None  # means General team
-
-        escalation_chains_pks = self.channel_filters.all().values_list("escalation_chain", flat=True)
-        escalation_chains = self.organization.escalation_chains.filter(pk__in=escalation_chains_pks).annotate(
-            num_integrations=Count(
-                "channel_filters__alert_receive_channel",
-                distinct=True,
-                filter=Q(channel_filters__alert_receive_channel__deleted_at__isnull=True),
-            ),
-        )
-        if escalation_chains:
-            # check if escalation chains are connected to routes of other integrations
-            shared_escalation_chains = []
-            for escalation_chain in escalation_chains:
-                if escalation_chain.num_integrations > 1:
-                    shared_escalation_chains.append(escalation_chain)
-            if shared_escalation_chains:
-                shared_escalation_chains_verbal = ", ".join([ec.name for ec in shared_escalation_chains])
-                raise TeamCanNotBeChangedError(
-                    f"Team cannot be changed because one or more escalation chain of integration routes "
-                    f"is connected to other integration: {shared_escalation_chains_verbal}"
-                )
-
-            escalation_policies = EscalationPolicy.objects.filter(escalation_chain__in=escalation_chains)
-
-            users_in_escalation = self.organization.users.filter(escalationpolicy__in=escalation_policies)
-            if new_team:
-                team_members = new_team.users.filter(pk__in=[user.pk for user in users_in_escalation])
-            else:
-                team_members = self.organization.users.filter(pk__in=[user.pk for user in users_in_escalation])
-            not_team_members = set(users_in_escalation) - set(team_members)
-            if not_team_members:
-                not_team_members_verbal = ", ".join([user.username for user in not_team_members])
-                raise TeamCanNotBeChangedError(
-                    f"Team cannot be changed because one or more user from escalation chain(s) is not a member "
-                    f"of the selected team: {not_team_members_verbal}"
-                )
-
-            escalation_chains.update(team=new_team)
         self.team = new_team
         self.save(update_fields=["team"])
 

engine/apps/api/serializers/alert_group.py

@@ -8,6 +8,7 @@
 from apps.alerts.incident_appearance.renderers.web_renderer import AlertGroupWebRenderer
 from apps.alerts.models import AlertGroup, AlertGroupLogRecord
 from apps.user_management.models import User
+from common.api_helpers.custom_fields import TeamPrimaryKeyRelatedField
 from common.api_helpers.mixins import EagerLoadingMixin
 
 from .alert import AlertSerializer
@@ -82,6 +83,7 @@ class AlertGroupListSerializer(EagerLoadingMixin, AlertGroupFieldsCacheSerialize
     related_users = serializers.SerializerMethodField()
     dependent_alert_groups = ShortAlertGroupSerializer(many=True)
     root_alert_group = ShortAlertGroupSerializer()
+    team = TeamPrimaryKeyRelatedField(source="channel.team", allow_null=True)
 
     alerts_count = serializers.IntegerField(read_only=True)
     render_for_web = serializers.SerializerMethodField()
@@ -129,6 +131,7 @@ class Meta:
             "root_alert_group",
             "status",
             "declare_incident_link",
+            "team",
         ]
 
     def get_render_for_web(self, obj):

engine/apps/api/serializers/paging.py

@@ -2,6 +2,8 @@
 from rest_framework import serializers
 
 from apps.alerts.models import AlertGroup
+from common.api_helpers.custom_fields import TeamPrimaryKeyRelatedField
+from common.api_helpers.utils import CurrentTeamDefault
 
 
 class UserReferenceSerializer(serializers.Serializer):
@@ -49,6 +51,8 @@ class DirectPagingSerializer(serializers.Serializer):
     title = serializers.CharField(required=False, default=None)
     message = serializers.CharField(required=False, default=None)
 
+    team = TeamPrimaryKeyRelatedField(allow_null=True, default=CurrentTeamDefault())
+
     def validate(self, attrs):
         organization = self.context["organization"]
 

engine/apps/api/serializers/team.py

@@ -13,4 +13,12 @@ class Meta:
             "name",
             "email",
             "avatar_url",
+            "is_sharing_resources_to_all",
+        )
+
+        read_only_fields = (
+            "id",
+            "name",
+            "email",
+            "avatar_url",
         )

engine/apps/api/views/alert_group.py

@@ -22,7 +22,12 @@
 from apps.mobile_app.auth import MobileAppAuthTokenAuthentication
 from apps.user_management.models import Team, User
 from common.api_helpers.exceptions import BadRequest
-from common.api_helpers.filters import DateRangeFilterMixin, ModelFieldFilterMixin
+from common.api_helpers.filters import (
+    ByTeamModelFieldFilterMixin,
+    DateRangeFilterMixin,
+    ModelFieldFilterMixin,
+    TeamModelMultipleChoiceFilter,
+)
 from common.api_helpers.mixins import PreviewTemplateMixin, PublicPrimaryKeyMixin, TeamFilteringMixin
 from common.api_helpers.paginators import TwentyFiveCursorPaginator
 
@@ -48,7 +53,7 @@ def get_user_queryset(request):
     return User.objects.filter(organization=request.user.organization).distinct()
 
 
-class AlertGroupFilter(DateRangeFilterMixin, ModelFieldFilterMixin, filters.FilterSet):
+class AlertGroupFilter(DateRangeFilterMixin, ByTeamModelFieldFilterMixin, ModelFieldFilterMixin, filters.FilterSet):
     """
     Examples of possible date formats here https://docs.djangoproject.com/en/1.9/ref/settings/#datetime-input-formats
     """
@@ -103,6 +108,7 @@ class AlertGroupFilter(DateRangeFilterMixin, ModelFieldFilterMixin, filters.Filt
     )
     with_resolution_note = filters.BooleanFilter(method="filter_with_resolution_note")
     mine = filters.BooleanFilter(method="filter_mine")
+    team = TeamModelMultipleChoiceFilter(field_name="channel__team")
 
     class Meta:
         model = AlertGroup
@@ -280,11 +286,12 @@ def get_queryset(self):
         alert_receive_channels_ids = list(
             AlertReceiveChannel.objects.filter(
                 organization_id=self.request.auth.organization.id,
-                team_id=self.request.user.current_team,
             ).values_list("id", flat=True)
         )
+
         queryset = AlertGroup.unarchived_objects.filter(
             channel__in=alert_receive_channels_ids,
+            *self.available_teams_lookup_args,
         ).only("id")
 
         return queryset
@@ -538,6 +545,12 @@ def filters(self, request):
         )
 
         filter_options = [
+            {
+                "name": "team",
+                "type": "team_select",
+                "href": api_root + "teams/",
+                "global": True,
+            },
             {"name": "search", "type": "search"},
             {"name": "integration", "type": "options", "href": api_root + "alert_receive_channels/?filters=true"},
             {"name": "escalation_chain", "type": "options", "href": api_root + "escalation_chains/?filters=true"},
@@ -572,7 +585,7 @@ def filters(self, request):
                 "name": "status",
                 "type": "options",
                 "options": [
-                    {"display_name": "new", "value": AlertGroup.NEW},
+                    {"display_name": "firing", "value": AlertGroup.NEW},
                     {"display_name": "acknowledged", "value": AlertGroup.ACKNOWLEDGED},
                     {"display_name": "resolved", "value": AlertGroup.RESOLVED},
                     {"display_name": "silenced", "value": AlertGroup.SILENCED},

engine/apps/api/views/alert_receive_channel.py

@@ -18,6 +18,7 @@
 from apps.api.throttlers import DemoAlertThrottler
 from apps.auth_token.auth import PluginAuthentication
 from common.api_helpers.exceptions import BadRequest
+from common.api_helpers.filters import ByTeamModelFieldFilterMixin, TeamModelMultipleChoiceFilter
 from common.api_helpers.mixins import (
     FilterSerializerMixin,
     PreviewTemplateMixin,
@@ -29,11 +30,12 @@
 from common.insight_log import EntityEvent, write_resource_insight_log
 
 
-class AlertReceiveChannelFilter(filters.FilterSet):
+class AlertReceiveChannelFilter(ByTeamModelFieldFilterMixin, filters.FilterSet):
     maintenance_mode = filters.MultipleChoiceFilter(
         choices=AlertReceiveChannel.MAINTENANCE_MODE_CHOICES, method="filter_maintenance_mode"
     )
     integration = filters.ChoiceFilter(choices=AlertReceiveChannel.INTEGRATION_CHOICES)
+    team = TeamModelMultipleChoiceFilter()
 
     class Meta:
         model = AlertReceiveChannel
@@ -92,6 +94,7 @@ class AlertReceiveChannelView(
         "partial_update": [RBACPermission.Permissions.INTEGRATIONS_WRITE],
         "destroy": [RBACPermission.Permissions.INTEGRATIONS_WRITE],
         "change_team": [RBACPermission.Permissions.INTEGRATIONS_WRITE],
+        "filters": [RBACPermission.Permissions.INTEGRATIONS_READ],
     }
 
     def create(self, request, *args, **kwargs):
@@ -127,12 +130,12 @@ def get_queryset(self, eager=True):
         if is_filters_request:
             queryset = AlertReceiveChannel.objects_with_maintenance.filter(
                 organization=organization,
-                team=self.request.user.current_team,
+                *self.available_teams_lookup_args,
             )
         else:
             queryset = AlertReceiveChannel.objects.filter(
                 organization=organization,
-                team=self.request.user.current_team,
+                *self.available_teams_lookup_args,
             )
             if eager:
                 queryset = self.serializer_class.setup_eager_loading(queryset)
@@ -216,3 +219,22 @@ def get_alert_to_template(self):
             return self.get_object().alert_groups.last().alerts.first()
         except AttributeError:
             return None
+
+    @action(methods=["get"], detail=False)
+    def filters(self, request):
+        filter_name = request.query_params.get("search", None)
+        api_root = "/api/internal/v1/"
+
+        filter_options = [
+            {
+                "name": "team",
+                "type": "team_select",
+                "href": api_root + "teams/",
+                "global": True,
+            },
+        ]
+
+        if filter_name is not None:
+            filter_options = list(filter(lambda f: filter_name in f["name"], filter_options))
+
+        return Response(filter_options)

engine/apps/api/views/alert_receive_channel_template.py

@@ -6,12 +6,13 @@
 from apps.api.permissions import RBACPermission
 from apps.api.serializers.alert_receive_channel import AlertReceiveChannelTemplatesSerializer
 from apps.auth_token.auth import PluginAuthentication
-from common.api_helpers.mixins import PublicPrimaryKeyMixin
+from common.api_helpers.mixins import PublicPrimaryKeyMixin, TeamFilteringMixin
 from common.insight_log import EntityEvent, write_resource_insight_log
 from common.jinja_templater.apply_jinja_template import JinjaTemplateError
 
 
 class AlertReceiveChannelTemplateView(
+    TeamFilteringMixin,
     PublicPrimaryKeyMixin,
     mixins.RetrieveModelMixin,
     mixins.UpdateModelMixin,
@@ -34,7 +35,7 @@ class AlertReceiveChannelTemplateView(
     def get_queryset(self):
         queryset = AlertReceiveChannel.objects.filter(
             organization=self.request.auth.organization,
-            team=self.request.user.current_team,
+            *self.available_teams_lookup_args,
         )
         return queryset
 

engine/apps/api/views/channel_filter.py

@@ -16,12 +16,19 @@
 from apps.auth_token.auth import PluginAuthentication
 from apps.slack.models import SlackChannel
 from common.api_helpers.exceptions import BadRequest
-from common.api_helpers.mixins import CreateSerializerMixin, PublicPrimaryKeyMixin, UpdateSerializerMixin
+from common.api_helpers.mixins import (
+    CreateSerializerMixin,
+    PublicPrimaryKeyMixin,
+    TeamFilteringMixin,
+    UpdateSerializerMixin,
+)
 from common.exceptions import UnableToSendDemoAlert
 from common.insight_log import EntityEvent, write_resource_insight_log
 
 
-class ChannelFilterView(PublicPrimaryKeyMixin, CreateSerializerMixin, UpdateSerializerMixin, ModelViewSet):
+class ChannelFilterView(
+    TeamFilteringMixin, PublicPrimaryKeyMixin, CreateSerializerMixin, UpdateSerializerMixin, ModelViewSet
+):
     authentication_classes = (PluginAuthentication,)
     permission_classes = (IsAuthenticated, RBACPermission)
     rbac_permissions = {
@@ -41,6 +48,8 @@ class ChannelFilterView(PublicPrimaryKeyMixin, CreateSerializerMixin, UpdateSeri
     update_serializer_class = ChannelFilterUpdateSerializer
     create_serializer_class = ChannelFilterCreateSerializer
 
+    TEAM_LOOKUP = "alert_receive_channel__team"
+
     def get_queryset(self):
         alert_receive_channel_id = self.request.query_params.get("alert_receive_channel", None)
         lookup_kwargs = {}
@@ -53,10 +62,10 @@ def get_queryset(self):
         ).order_by("pk")
 
         queryset = ChannelFilter.objects.filter(
-            **lookup_kwargs,
             alert_receive_channel__organization=self.request.auth.organization,
-            alert_receive_channel__team=self.request.user.current_team,
             alert_receive_channel__deleted_at=None,
+            *self.available_teams_lookup_args,  # TODO: double check this
+            **lookup_kwargs,
         ).annotate(
             slack_channel_name=Subquery(slack_channels_subq.values("name")[:1]),
             slack_channel_pk=Subquery(slack_channels_subq.values("public_primary_key")[:1]),