Content flagging systems console settings (#31411)

* Added enable/disable setting and feature flag

* added rest of notifgication settings

* Added backend for content flagging setting and populated notification values from server side defaults

* WIP user selector

* Added common reviewers UI

* Added additonal reviewers section

* WIP

* WIP

* Team table base

* Added search in teams

* Added search in teams

* Added additional settings section

* WIP

* Inbtegrated reviewers settings

* WIP

* WIP

* Added server side validation

* cleanup

* cleanup

* [skip ci]

* Some refactoring

* type fixes

* lint fix

* test: add content flagging settings test file

* test: add comprehensive unit tests for content flagging settings

* enhanced tests

* test: add test file for content flagging additional settings

* test: add comprehensive unit tests for ContentFlaggingAdditionalSettingsSection

* Added additoonal settings test

* test: add empty test file for team reviewers section

* test: add comprehensive unit tests for TeamReviewersSection component

* test: update tests to handle async data fetching in team reviewers section

* test: add empty test file for content reviewers component

* feat: add comprehensive unit tests for ContentFlaggingContentReviewers component

* Added ContentFlaggingContentReviewersContentFlaggingContentReviewers test

* test: add notification settings test file for content flagging

* test: add comprehensive unit tests for content flagging notification settings

* Added ContentFlaggingNotificationSettingsSection tests

* test: add user profile pill test file

* test: add comprehensive unit tests for UserProfilePill component

* refactor: Replace enzyme shallow with renderWithContext in user_profile_pill tests

* Added UserProfilePill tests

* test: add empty test file for content reviewers team option

* test: add comprehensive unit tests for TeamOptionComponent

* Added TeamOptionComponent tests

* test: add empty test file for reason_option component

* test: add comprehensive unit tests for ReasonOption component

* Added ReasonOption tests

* cleanup

* Fixed i18n error

* fixed e2e test lijnt issues

* Updated test cases

* Added snaoshot

* Updated snaoshot

* lint fix

* lint fix

* review fixes

* updated snapshot

* CI

* Review fixes

* Removed an test, updated comment

* CI

* Test update

server/i18n/en.json

@@ -9216,6 +9216,18 @@
     "id": "model.config.is_valid.collapsed_threads.autofollow.app_error",
     "translation": "ThreadAutoFollow must be true to enable CollapsedThreads"
   },
+  {
+    "id": "model.config.is_valid.content_flagging.common_reviewers_not_set.app_error",
+    "translation": "Common reviewers or additional reviewers must be set when \"Same reviewers for all teams\" is enabled."
+  },
+  {
+    "id": "model.config.is_valid.content_flagging.reasons_not_set.app_error",
+    "translation": "Reasons for flagging cannot be empty."
+  },
+  {
+    "id": "model.config.is_valid.content_flagging.team_reviewers_not_set.app_error",
+    "translation": "Team reviewers or additional reviewers must be set when setting \"Enabled\" for a team."
+  },
   {
     "id": "model.config.is_valid.data_retention.deletion_job_start_time.app_error",
     "translation": "Data retention job start time must be a 24-hour time stamp in the form HH:MM."
@@ -9552,6 +9564,18 @@
     "id": "model.config.is_valid.move_thread.domain_invalid.app_error",
     "translation": "Invalid domain for move thread settings"
   },
+  {
+    "id": "model.config.is_valid.notification_settings.invalid_event",
+    "translation": "Invalid flagging event specified."
+  },
+  {
+    "id": "model.config.is_valid.notification_settings.invalid_target",
+    "translation": "Invalid flaggig event target specified."
+  },
+  {
+    "id": "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled",
+    "translation": "Notifications for new flagged post cannot be disabled for reviewers."
+  },
   {
     "id": "model.config.is_valid.outgoing_integrations_request_timeout.app_error",
     "translation": "Invalid Outgoing Integrations Request Timeout for service settings. Must be a positive number."

server/public/model/config.go

@@ -3884,6 +3884,7 @@ type Config struct {
 	WranglerSettings            WranglerSettings
 	ConnectedWorkspacesSettings ConnectedWorkspacesSettings
 	AccessControlSettings       AccessControlSettings
+	ContentFlaggingSettings     ContentFlaggingSettings
 }
 
 func (o *Config) Auditable() map[string]any {
@@ -4002,6 +4003,7 @@ func (o *Config) SetDefaults() {
 	o.WranglerSettings.SetDefaults()
 	o.ConnectedWorkspacesSettings.SetDefaults(isUpdate, o.ExperimentalSettings)
 	o.AccessControlSettings.SetDefaults()
+	o.ContentFlaggingSettings.SetDefaults()
 }
 
 func (o *Config) IsValid() *AppError {
@@ -4129,6 +4131,10 @@ func (o *Config) IsValid() *AppError {
 		}
 	}
 
+	if appErr := o.ContentFlaggingSettings.IsValid(); appErr != nil {
+		return appErr
+	}
+
 	return nil
 }
 

server/public/model/content_flagging_settings.go

@@ -0,0 +1,229 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+import "net/http"
+
+type ContentFlaggingEvent string
+
+const (
+	EventFlagged          ContentFlaggingEvent = "flagged"
+	EventAssigned         ContentFlaggingEvent = "assigned"
+	EventContentRemoved   ContentFlaggingEvent = "removed"
+	EventContentDismissed ContentFlaggingEvent = "dismissed"
+)
+
+type NotificationTarget string
+
+const (
+	TargetReviewers NotificationTarget = "reviewers"
+	TargetAuthor    NotificationTarget = "author"
+	TargetReporter  NotificationTarget = "reporter"
+)
+
+type ContentFlaggingNotificationSettings struct {
+	EventTargetMapping map[ContentFlaggingEvent][]NotificationTarget
+}
+
+func (cfs *ContentFlaggingNotificationSettings) SetDefaults() {
+	if cfs.EventTargetMapping == nil {
+		cfs.EventTargetMapping = make(map[ContentFlaggingEvent][]NotificationTarget)
+	}
+
+	if _, exists := cfs.EventTargetMapping[EventFlagged]; !exists {
+		cfs.EventTargetMapping[EventFlagged] = []NotificationTarget{TargetReviewers}
+	}
+
+	if _, exists := cfs.EventTargetMapping[EventAssigned]; !exists {
+		cfs.EventTargetMapping[EventAssigned] = []NotificationTarget{TargetReviewers}
+	}
+
+	if _, exists := cfs.EventTargetMapping[EventContentRemoved]; !exists {
+		cfs.EventTargetMapping[EventContentRemoved] = []NotificationTarget{TargetReviewers, TargetAuthor, TargetReporter}
+	}
+
+	if _, exists := cfs.EventTargetMapping[EventContentDismissed]; !exists {
+		cfs.EventTargetMapping[EventContentDismissed] = []NotificationTarget{TargetReviewers, TargetReporter}
+	}
+}
+
+func (cfs *ContentFlaggingNotificationSettings) IsValid() *AppError {
+	// Reviewers must be notified when content is flagged
+	// Disabling this option is not allowed in the UI, so this check is for safety and consistency.
+
+	// Only valid events and targets are allowed
+	for event, targets := range cfs.EventTargetMapping {
+		if event != EventFlagged && event != EventAssigned && event != EventContentRemoved && event != EventContentDismissed {
+			return NewAppError("Config.IsValid", "model.config.is_valid.notification_settings.invalid_event", nil, "", http.StatusBadRequest)
+		}
+
+		for _, target := range targets {
+			if target != TargetReviewers && target != TargetAuthor && target != TargetReporter {
+				return NewAppError("Config.IsValid", "model.config.is_valid.notification_settings.invalid_target", nil, "", http.StatusBadRequest)
+			}
+		}
+	}
+
+	if cfs.EventTargetMapping[EventFlagged] == nil || len(cfs.EventTargetMapping[EventFlagged]) == 0 {
+		return NewAppError("Config.IsValid", "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled", nil, "", http.StatusBadRequest)
+	}
+
+	// Search for the TargetReviewers in the EventFlagged event
+	reviewerFound := false
+	for _, target := range cfs.EventTargetMapping[EventFlagged] {
+		if target == TargetReviewers {
+			reviewerFound = true
+			break
+		}
+	}
+
+	if !reviewerFound {
+		return NewAppError("Config.IsValid", "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled", nil, "", http.StatusBadRequest)
+	}
+
+	return nil
+}
+
+type TeamReviewerSetting struct {
+	Enabled     *bool
+	ReviewerIds *[]string
+}
+
+type ReviewerSettings struct {
+	CommonReviewers         *bool
+	CommonReviewerIds       *[]string
+	TeamReviewersSetting    *map[string]TeamReviewerSetting
+	SystemAdminsAsReviewers *bool
+	TeamAdminsAsReviewers   *bool
+}
+
+func (rs *ReviewerSettings) SetDefaults() {
+	if rs.CommonReviewers == nil {
+		rs.CommonReviewers = NewPointer(true)
+	}
+
+	if rs.CommonReviewerIds == nil {
+		rs.CommonReviewerIds = &[]string{}
+	}
+
+	if rs.TeamReviewersSetting == nil {
+		rs.TeamReviewersSetting = &map[string]TeamReviewerSetting{}
+	}
+
+	if rs.SystemAdminsAsReviewers == nil {
+		rs.SystemAdminsAsReviewers = NewPointer(false)
+	}
+
+	if rs.TeamAdminsAsReviewers == nil {
+		rs.TeamAdminsAsReviewers = NewPointer(true)
+	}
+}
+
+func (rs *ReviewerSettings) IsValid() *AppError {
+	additionalReviewersEnabled := *rs.SystemAdminsAsReviewers || *rs.TeamAdminsAsReviewers
+
+	// If common reviewers are enabled, there must be at least one specified reviewer, or additional viewers be specified
+	if *rs.CommonReviewers && (rs.CommonReviewerIds == nil || len(*rs.CommonReviewerIds) == 0) && !additionalReviewersEnabled {
+		return NewAppError("Config.IsValid", "model.config.is_valid.content_flagging.common_reviewers_not_set.app_error", nil, "", http.StatusBadRequest)
+	}
+
+	// if additional reviewers are specified, no extra validation is needed in team specific settings as
+	// settings team reviewers keeping team feature disabled is valid, as well as
+	// enabling team feature and not specified reviews is fine as well (since additional reviewers are set)
+	if !additionalReviewersEnabled {
+		for _, setting := range *rs.TeamReviewersSetting {
+			if *setting.Enabled && (setting.ReviewerIds == nil || len(*setting.ReviewerIds) == 0) {
+				return NewAppError("Config.IsValid", "model.config.is_valid.content_flagging.team_reviewers_not_set.app_error", nil, "", http.StatusBadRequest)
+			}
+		}
+	}
+
+	return nil
+}
+
+type AdditionalContentFlaggingSettings struct {
+	Reasons                 *[]string
+	ReporterCommentRequired *bool
+	ReviewerCommentRequired *bool
+	HideFlaggedContent      *bool
+}
+
+func (acfs *AdditionalContentFlaggingSettings) SetDefaults() {
+	if acfs.Reasons == nil {
+		acfs.Reasons = &[]string{
+			"Inappropriate content",
+			"Sensitive data",
+			"Security concern",
+			"Harassment or abuse",
+			"Spam or phishing",
+		}
+	}
+
+	if acfs.ReporterCommentRequired == nil {
+		acfs.ReporterCommentRequired = NewPointer(true)
+	}
+
+	if acfs.ReviewerCommentRequired == nil {
+		acfs.ReviewerCommentRequired = NewPointer(true)
+	}
+
+	if acfs.HideFlaggedContent == nil {
+		acfs.HideFlaggedContent = NewPointer(true)
+	}
+}
+
+func (acfs *AdditionalContentFlaggingSettings) IsValid() *AppError {
+	if acfs.Reasons == nil || len(*acfs.Reasons) == 0 {
+		return NewAppError("Config.IsValid", "model.config.is_valid.content_flagging.reasons_not_set.app_error", nil, "", http.StatusBadRequest)
+	}
+
+	return nil
+}
+
+type ContentFlaggingSettings struct {
+	EnableContentFlagging *bool
+	ReviewerSettings      *ReviewerSettings
+	NotificationSettings  *ContentFlaggingNotificationSettings
+	AdditionalSettings    *AdditionalContentFlaggingSettings
+}
+
+func (cfs *ContentFlaggingSettings) SetDefaults() {
+	if cfs.EnableContentFlagging == nil {
+		cfs.EnableContentFlagging = NewPointer(false)
+	}
+
+	if cfs.NotificationSettings == nil {
+		cfs.NotificationSettings = &ContentFlaggingNotificationSettings{
+			EventTargetMapping: make(map[ContentFlaggingEvent][]NotificationTarget),
+		}
+	}
+
+	if cfs.ReviewerSettings == nil {
+		cfs.ReviewerSettings = &ReviewerSettings{}
+	}
+
+	if cfs.AdditionalSettings == nil {
+		cfs.AdditionalSettings = &AdditionalContentFlaggingSettings{}
+	}
+
+	cfs.NotificationSettings.SetDefaults()
+	cfs.ReviewerSettings.SetDefaults()
+	cfs.AdditionalSettings.SetDefaults()
+}
+
+func (cfs *ContentFlaggingSettings) IsValid() *AppError {
+	if err := cfs.NotificationSettings.IsValid(); err != nil {
+		return err
+	}
+
+	if err := cfs.ReviewerSettings.IsValid(); err != nil {
+		return err
+	}
+
+	if err := cfs.AdditionalSettings.IsValid(); err != nil {
+		return err
+	}
+
+	return nil
+}

server/public/model/content_flagging_settings_test.go

@@ -0,0 +1,360 @@
+package model
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestContentFlaggingNotificationSettings_SetDefault(t *testing.T) {
+	t.Run("should set default event target mappings", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{}
+		settings.SetDefaults()
+
+		require.Nil(t, settings.IsValid())
+
+		require.NotNil(t, settings.EventTargetMapping)
+		require.Equal(t, []NotificationTarget{TargetReviewers}, settings.EventTargetMapping[EventFlagged])
+		require.Equal(t, []NotificationTarget{TargetReviewers}, settings.EventTargetMapping[EventAssigned])
+		require.Equal(t, []NotificationTarget{TargetReviewers, TargetAuthor, TargetReporter}, settings.EventTargetMapping[EventContentRemoved])
+		require.Equal(t, []NotificationTarget{TargetReviewers, TargetReporter}, settings.EventTargetMapping[EventContentDismissed])
+	})
+
+	t.Run("should not override existing mappings", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				EventFlagged: {TargetReviewers},
+			},
+		}
+		settings.SetDefaults()
+
+		require.Nil(t, settings.IsValid())
+		require.Equal(t, []NotificationTarget{TargetReviewers}, settings.EventTargetMapping[EventFlagged])
+		require.Equal(t, []NotificationTarget{TargetReviewers}, settings.EventTargetMapping[EventAssigned])
+	})
+}
+
+func TestContentFlaggingNotificationSettings_IsValid(t *testing.T) {
+	t.Run("should be valid when reviewers are notified for flagged events", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				EventFlagged: {TargetReviewers, TargetAuthor},
+			},
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be invalid when no targets for flagged events", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				EventFlagged: {},
+			},
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled", err.Id)
+	})
+
+	t.Run("should be invalid when flagged event mapping is nil", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{},
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled", err.Id)
+	})
+
+	t.Run("should be invalid when reviewers not included in flagged event targets", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				EventFlagged: {TargetAuthor, TargetReporter},
+			},
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.reviewer_flagged_notification_disabled", err.Id)
+	})
+
+	t.Run("should be invalid when invalid events and targets are specified", func(t *testing.T) {
+		settings := &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				"invalid_event": {TargetAuthor, TargetReporter},
+			},
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.invalid_event", err.Id)
+
+		settings = &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				EventFlagged: {"invalid_target_1", "invalid_target_2"},
+			},
+		}
+
+		err = settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.invalid_target", err.Id)
+
+		settings = &ContentFlaggingNotificationSettings{
+			EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+				"invalid_event": {"invalid_target_1", "invalid_target_2"},
+			},
+		}
+
+		err = settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.notification_settings.invalid_event", err.Id)
+	})
+}
+
+func TestReviewerSettings_SetDefault(t *testing.T) {
+	t.Run("should not override existing values", func(t *testing.T) {
+		commonReviewers := false
+		settings := &ReviewerSettings{
+			CommonReviewers: &commonReviewers,
+		}
+		settings.SetDefaults()
+
+		require.Nil(t, settings.IsValid())
+		require.False(t, *settings.CommonReviewers)
+	})
+}
+
+func TestReviewerSettings_IsValid(t *testing.T) {
+	t.Run("should be valid when common reviewers enabled with reviewer IDs", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:         NewPointer(true),
+			CommonReviewerIds:       &[]string{"user1", "user2"},
+			TeamReviewersSetting:    &map[string]TeamReviewerSetting{},
+			SystemAdminsAsReviewers: NewPointer(false),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be valid when common reviewers enabled with additional reviewers", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:         NewPointer(true),
+			CommonReviewerIds:       &[]string{},
+			TeamReviewersSetting:    &map[string]TeamReviewerSetting{},
+			SystemAdminsAsReviewers: NewPointer(true),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be invalid when common reviewers enabled but no reviewers specified", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:         NewPointer(true),
+			CommonReviewerIds:       &[]string{},
+			TeamReviewersSetting:    &map[string]TeamReviewerSetting{},
+			SystemAdminsAsReviewers: NewPointer(false),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.content_flagging.common_reviewers_not_set.app_error", err.Id)
+	})
+
+	t.Run("should be valid when team reviewers enabled with reviewer IDs", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:   NewPointer(false),
+			CommonReviewerIds: &[]string{},
+			TeamReviewersSetting: &map[string]TeamReviewerSetting{
+				"team1": {
+					Enabled:     NewPointer(true),
+					ReviewerIds: &[]string{"user1"},
+				},
+			},
+			SystemAdminsAsReviewers: NewPointer(false),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be invalid when team reviewers enabled but no reviewer IDs", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:   NewPointer(false),
+			CommonReviewerIds: &[]string{},
+			TeamReviewersSetting: &map[string]TeamReviewerSetting{
+				"team1": {
+					Enabled:     NewPointer(true),
+					ReviewerIds: &[]string{},
+				},
+			},
+			SystemAdminsAsReviewers: NewPointer(false),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.content_flagging.team_reviewers_not_set.app_error", err.Id)
+	})
+
+	t.Run("should be valid when team reviewers enabled but no reviewer IDs with additional reviewers", func(t *testing.T) {
+		settings := &ReviewerSettings{
+			CommonReviewers:   NewPointer(false),
+			CommonReviewerIds: &[]string{},
+			TeamReviewersSetting: &map[string]TeamReviewerSetting{
+				"team1": {
+					Enabled:     NewPointer(true),
+					ReviewerIds: &[]string{},
+				},
+			},
+			SystemAdminsAsReviewers: NewPointer(true),
+			TeamAdminsAsReviewers:   NewPointer(false),
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+}
+
+func TestAdditionalContentFlaggingSettings_SetDefault(t *testing.T) {
+	t.Run("should not override existing values", func(t *testing.T) {
+		customReasons := []string{"Custom reason"}
+		settings := &AdditionalContentFlaggingSettings{
+			Reasons: &customReasons,
+		}
+		settings.SetDefaults()
+
+		require.Nil(t, settings.IsValid())
+		require.Equal(t, customReasons, *settings.Reasons)
+	})
+}
+
+func TestAdditionalContentFlaggingSettings_IsValid(t *testing.T) {
+	t.Run("should be valid when reasons are provided", func(t *testing.T) {
+		settings := &AdditionalContentFlaggingSettings{
+			Reasons: &[]string{"Reason 1", "Reason 2"},
+		}
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be invalid when reasons are nil", func(t *testing.T) {
+		settings := &AdditionalContentFlaggingSettings{
+			Reasons: nil,
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.content_flagging.reasons_not_set.app_error", err.Id)
+	})
+
+	t.Run("should be invalid when reasons are empty", func(t *testing.T) {
+		settings := &AdditionalContentFlaggingSettings{
+			Reasons: &[]string{},
+		}
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Equal(t, "model.config.is_valid.content_flagging.reasons_not_set.app_error", err.Id)
+	})
+}
+
+func TestContentFlaggingSettings_SetDefault(t *testing.T) {
+	t.Run("should not override existing values", func(t *testing.T) {
+		enabled := true
+		settings := &ContentFlaggingSettings{
+			EnableContentFlagging: &enabled,
+		}
+		settings.SetDefaults()
+
+		require.Nil(t, settings.IsValid())
+		require.True(t, *settings.EnableContentFlagging)
+	})
+}
+
+func TestContentFlaggingSettings_IsValid(t *testing.T) {
+	t.Run("should be valid when all nested settings are valid", func(t *testing.T) {
+		settings := &ContentFlaggingSettings{}
+		settings.SetDefaults()
+
+		err := settings.IsValid()
+		require.Nil(t, err)
+	})
+
+	t.Run("should be invalid when notification settings are invalid", func(t *testing.T) {
+		settings := &ContentFlaggingSettings{
+			NotificationSettings: &ContentFlaggingNotificationSettings{
+				EventTargetMapping: map[ContentFlaggingEvent][]NotificationTarget{
+					EventFlagged: {},
+				},
+			},
+			ReviewerSettings:   &ReviewerSettings{},
+			AdditionalSettings: &AdditionalContentFlaggingSettings{},
+		}
+		settings.ReviewerSettings.SetDefaults()
+		settings.AdditionalSettings.SetDefaults()
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Contains(t, err.Id, "notification_settings")
+	})
+
+	t.Run("should be invalid when reviewer settings are invalid", func(t *testing.T) {
+		settings := &ContentFlaggingSettings{
+			NotificationSettings: &ContentFlaggingNotificationSettings{},
+			ReviewerSettings: &ReviewerSettings{
+				CommonReviewers:         NewPointer(true),
+				CommonReviewerIds:       &[]string{},
+				TeamReviewersSetting:    &map[string]TeamReviewerSetting{},
+				SystemAdminsAsReviewers: NewPointer(false),
+				TeamAdminsAsReviewers:   NewPointer(false),
+			},
+			AdditionalSettings: &AdditionalContentFlaggingSettings{},
+		}
+		settings.NotificationSettings.SetDefaults()
+		settings.AdditionalSettings.SetDefaults()
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Contains(t, err.Id, "common_reviewers_not_set")
+	})
+
+	t.Run("should be invalid when additional settings are invalid", func(t *testing.T) {
+		settings := &ContentFlaggingSettings{
+			NotificationSettings: &ContentFlaggingNotificationSettings{},
+			ReviewerSettings:     &ReviewerSettings{},
+			AdditionalSettings: &AdditionalContentFlaggingSettings{
+				Reasons: &[]string{},
+			},
+		}
+		settings.NotificationSettings.SetDefaults()
+		settings.ReviewerSettings.SetDefaults()
+
+		err := settings.IsValid()
+		require.NotNil(t, err)
+		require.Contains(t, err.Id, "reasons_not_set")
+	})
+}
+
+func TestContentFlaggingConstants(t *testing.T) {
+	t.Run("should have correct event constants", func(t *testing.T) {
+		require.Equal(t, ContentFlaggingEvent("flagged"), EventFlagged)
+		require.Equal(t, ContentFlaggingEvent("assigned"), EventAssigned)
+		require.Equal(t, ContentFlaggingEvent("removed"), EventContentRemoved)
+		require.Equal(t, ContentFlaggingEvent("dismissed"), EventContentDismissed)
+	})
+
+	t.Run("should have correct target constants", func(t *testing.T) {
+		require.Equal(t, NotificationTarget("reviewers"), TargetReviewers)
+		require.Equal(t, NotificationTarget("author"), TargetAuthor)
+		require.Equal(t, NotificationTarget("reporter"), TargetReporter)
+	})
+}

server/public/model/feature_flags.go

@@ -68,6 +68,8 @@ type FeatureFlags struct {
 	CustomProfileAttributes bool
 
 	AttributeBasedAccessControl bool
+
+	ContentFlagging bool
 }
 
 func (f *FeatureFlags) SetDefaults() {
@@ -96,6 +98,7 @@ func (f *FeatureFlags) SetDefaults() {
 	f.ExperimentalAuditSettingsSystemConsoleUI = true
 	f.CustomProfileAttributes = true
 	f.AttributeBasedAccessControl = true
+	f.ContentFlagging = false
 }
 
 // ToMap returns the feature flags as a map[string]string