[MM-58290] Add UI to select notification preference. (#657)

* add connection status to the store

* change event name

* Add tests for connection status

* add tests for disconnect command

* move user settings to it's own file

* typo

* readd connect button

server/api.go

@@ -53,6 +53,7 @@ const (
 	QueryParamPrimaryPlatform                 = "primary_platform"
 	QueryParamChannelID                       = "channel_id"
 	QueryParamPostID                          = "post_id"
+	QueryParamFromPreferences                 = "from_preferences"
 
 	APIChoosePrimaryPlatform = "/choose-primary-platform"
 )
@@ -78,6 +79,7 @@ func NewAPI(p *Plugin, store store.Store) *API {
 	router.HandleFunc("/lifecycle", api.processLifecycle).Methods("POST")
 	router.HandleFunc("/autocomplete/teams", api.autocompleteTeams).Methods("GET")
 	router.HandleFunc("/autocomplete/channels", api.autocompleteChannels).Methods("GET")
+	router.HandleFunc("/connection-status", api.connectionStatus).Methods("GET")
 	router.HandleFunc("/connect", api.connect).Methods("GET", "OPTIONS")
 	router.HandleFunc("/oauth-redirect", api.oauthRedirectHandler).Methods("GET", "OPTIONS")
 	router.HandleFunc("/connected-users", api.getConnectedUsers).Methods(http.MethodGet)
@@ -348,10 +350,16 @@ func (a *API) connect(w http.ResponseWriter, r *http.Request) {
 		userID = a.p.GetBotUserID()
 	}
 
+	stateSuffix := ""
+	fromPreferences := query.Get(QueryParamFromPreferences)
 	channelID := query.Get(QueryParamChannelID)
 	postID := query.Get(QueryParamPostID)
-	if channelID == "" || postID == "" {
-		a.p.API.LogWarn("Missing channelID or postID from query parameters", "channel_id", channelID, "post_id", postID)
+	if fromPreferences == "true" {
+		stateSuffix = "fromPreferences:true"
+	} else if channelID != "" && postID != "" {
+		stateSuffix = fmt.Sprintf("fromBotMessage:%s|%s", channelID, postID)
+	} else {
+		a.p.API.LogWarn("could not determine origin of the connect request", "channel_id", channelID, "post_id", postID, "from_preferences", fromPreferences)
 		http.Error(w, "Missing required query parameters.", http.StatusBadRequest)
 		return
 	}
@@ -362,7 +370,7 @@ func (a *API) connect(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	state := fmt.Sprintf("%s_%s_%s_%s", model.NewId(), userID, postID, channelID)
+	state := fmt.Sprintf("%s_%s_%s", model.NewId(), userID, stateSuffix)
 	if err := a.store.StoreOAuth2State(state); err != nil {
 		a.p.API.LogWarn("Error in storing the OAuth state", "error", err.Error())
 		http.Error(w, "Error in trying to connect the account, please try again.", http.StatusInternalServerError)
@@ -381,6 +389,21 @@ func (a *API) connect(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, connectURL, http.StatusSeeOther)
 }
 
+func (a *API) connectionStatus(w http.ResponseWriter, r *http.Request) {
+	userID := r.Header.Get("Mattermost-User-ID")
+
+	response := map[string]bool{"connected": false}
+	if storedToken, _ := a.p.store.GetTokenForMattermostUser(userID); storedToken != nil {
+		response["connected"] = true
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		a.p.API.LogWarn("Error while writing response", "error", err.Error())
+		w.WriteHeader(http.StatusInternalServerError)
+	}
+}
+
 func (a *API) primaryPlatform(w http.ResponseWriter, r *http.Request) {
 	bundlePath, err := a.p.API.GetBundlePath()
 	if err != nil {
@@ -448,7 +471,36 @@ func (a *API) oauthRedirectHandler(w http.ResponseWriter, r *http.Request) {
 	state := r.URL.Query().Get("state")
 
 	stateArr := strings.Split(state, "_")
-	if len(stateArr) != 4 {
+	if len(stateArr) != 3 {
+		http.Error(w, "Invalid state", http.StatusBadRequest)
+		return
+	}
+
+	// determine origin of the connect request
+	// if the state is fromPreferences, the user is connecting from the preferences page
+	// if the state is fromBotMessage, the user is connecting from a bot message
+	originInfo := strings.Split(stateArr[2], ":")
+	if len(originInfo) != 2 {
+		a.p.API.LogWarn("unable to get origin info from state", "state", stateArr[2])
+		http.Error(w, "Invalid state", http.StatusBadRequest)
+		return
+	}
+
+	channelID := ""
+	postID := ""
+	switch originInfo[0] {
+	case "fromPreferences":
+		// do nothing
+	case "fromBotMessage":
+		fromBotMessageArgs := strings.Split(originInfo[1], "|")
+		if len(fromBotMessageArgs) != 2 {
+			a.p.API.LogWarn("unable to get args from bot message", "origin_info", originInfo[1])
+			http.Error(w, "Invalid state", http.StatusBadRequest)
+			return
+		}
+		channelID = fromBotMessageArgs[0]
+		postID = fromBotMessageArgs[1]
+	default:
 		http.Error(w, "Invalid state", http.StatusBadRequest)
 		return
 	}
@@ -555,6 +607,10 @@ func (a *API) oauthRedirectHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	a.p.API.PublishWebSocketEvent(WSEventUserConnected, map[string]any{}, &model.WebsocketBroadcast{
+		UserId: mmUserID,
+	})
+
 	if err = a.p.store.DeleteUserInvite(mmUserID); err != nil {
 		a.p.API.LogWarn("Unable to clear user invite", "user_id", mmUserID, "error", err.Error())
 	}
@@ -573,22 +629,30 @@ func (a *API) oauthRedirectHandler(w http.ResponseWriter, r *http.Request) {
 	_, _ = a.p.updateAutomutingOnUserConnect(mmUserID)
 
 	const userConnectedMessage = "Welcome to Mattermost for Microsoft Teams! Your conversations with MS Teams users are now synchronized."
-	post := &model.Post{
-		Id:        stateArr[2],
-		Message:   userConnectedMessage,
-		ChannelId: stateArr[3],
-		UserId:    a.p.GetBotUserID(),
-		CreateAt:  model.GetMillis(),
-	}
-
-	_, appErr = a.p.GetAPI().GetPost(stateArr[2])
-	if appErr == nil {
-		_, appErr = a.p.GetAPI().UpdatePost(post)
-		if appErr != nil {
-			a.p.API.LogWarn("Unable to update post", "post", post.Id, "error", err.Error())
+	switch originInfo[0] {
+	case "fromBotMessage":
+		post := &model.Post{
+			Id:        postID,
+			Message:   userConnectedMessage,
+			ChannelId: channelID,
+			UserId:    a.p.GetBotUserID(),
+			CreateAt:  model.GetMillis(),
+		}
+
+		_, appErr = a.p.GetAPI().GetPost(post.Id)
+		if appErr == nil {
+			_, appErr = a.p.GetAPI().UpdatePost(post)
+			if appErr != nil {
+				a.p.API.LogWarn("Unable to update post", "post", post.Id, "error", err.Error())
+			}
+		} else {
+			_ = a.p.GetAPI().UpdateEphemeralPost(mmUser.Id, post)
+		}
+	case "fromPreferences":
+		err = a.p.botSendDirectMessage(mmUserID, userConnectedMessage)
+		if err != nil {
+			a.p.API.LogWarn("Unable to send welcome direct message to user from preference", "error", err.Error())
 		}
-	} else {
-		_ = a.p.GetAPI().UpdateEphemeralPost(mmUser.Id, post)
 	}
 
 	connectURL := a.p.GetURL() + "/primary-platform"

server/api_test.go

@@ -1065,3 +1065,58 @@ func TestIFrameMattermostTab(t *testing.T) {
 func TestIFrameManifest(t *testing.T) {
 	t.Skip()
 }
+
+func TestConnectionStatus(t *testing.T) {
+	th := setupTestHelper(t)
+	apiURL := th.pluginURL(t, "/connection-status")
+	team := th.SetupTeam(t)
+
+	sendRequest := func(t *testing.T, user *model.User) (connected bool) {
+		t.Helper()
+		client := th.SetupClient(t, user.Id)
+
+		request, err := http.NewRequest(http.MethodGet, apiURL, nil)
+		require.NoError(t, err)
+
+		request.Header.Set(model.HeaderAuth, client.AuthType+" "+client.AuthToken)
+
+		response, err := http.DefaultClient.Do(request)
+		require.NoError(t, err)
+		t.Cleanup(func() {
+			require.NoError(t, response.Body.Close())
+		})
+
+		resMap := map[string]bool{}
+		err = json.NewDecoder(response.Body).Decode(&resMap)
+		require.NoError(t, err)
+
+		return resMap["connected"]
+	}
+
+	t.Run("connected users should get true", func(t *testing.T) {
+		th.Reset(t)
+		user := th.SetupUser(t, team)
+		th.ConnectUser(t, user.Id)
+
+		connected := sendRequest(t, user)
+		assert.True(t, connected)
+	})
+
+	t.Run("never connected users should get false", func(t *testing.T) {
+		th.Reset(t)
+		user := th.SetupUser(t, team)
+
+		connected := sendRequest(t, user)
+		assert.False(t, connected)
+	})
+
+	t.Run("disconnected users should get false", func(t *testing.T) {
+		th.Reset(t)
+		user := th.SetupUser(t, team)
+		th.ConnectUser(t, user.Id)
+		th.DisconnectUser(t, user.Id)
+
+		connected := sendRequest(t, user)
+		assert.False(t, connected)
+	})
+}

server/command.go

@@ -543,6 +543,10 @@ func (p *Plugin) executeDisconnectCommand(args *model.CommandArgs) (*model.Comma
 		return p.cmdSuccess(args, fmt.Sprintf("Error: unable to reset your primary platform, %s", err.Error()))
 	}
 
+	p.API.PublishWebSocketEvent(WSEventUserDisconnected, map[string]any{}, &model.WebsocketBroadcast{
+		UserId: args.UserId,
+	})
+
 	_, _ = p.updateAutomutingOnUserDisconnect(args.UserId)
 
 	return p.cmdSuccess(args, "Your account has been disconnected.")

server/command_test.go

@@ -24,6 +24,11 @@ func assertNoCommandResponse(t *testing.T, actual *model.CommandResponse) {
 	require.Equal(t, &model.CommandResponse{}, actual)
 }
 
+func assertWebsocketEvent(th *testHelper, t *testing.T, userID string, eventType string) {
+	t.Helper()
+	th.assertWebsocketEvent(t, userID, eventType)
+}
+
 func assertEphemeralResponse(th *testHelper, t *testing.T, args *model.CommandArgs, message string) {
 	t.Helper()
 	th.assertEphemeralMessage(t, args.UserId, args.ChannelId, message)
@@ -452,6 +457,7 @@ func TestExecuteDisconnectCommand(t *testing.T) {
 		commandResponse, appErr := th.p.executeDisconnectCommand(args)
 		require.Nil(t, appErr)
 		assertNoCommandResponse(t, commandResponse)
+		assertWebsocketEvent(th, t, user1.Id, makePluginWebsocketEventName(WSEventUserDisconnected))
 		assertEphemeralResponse(th, t, args, "Your account has been disconnected.")
 
 		require.Equal(t, storemodels.PreferenceValuePlatformMM, th.p.getPrimaryPlatform(user1.Id))

server/helper_test.go

@@ -480,6 +480,31 @@ func (th *testHelper) GetWebsocketClientForUser(t *testing.T, userID string) *mo
 	return websocketClient
 }
 
+func makePluginWebsocketEventName(short string) string {
+	return fmt.Sprintf("custom_%s_%s", manifest.Id, short)
+}
+
+func (th *testHelper) assertWebsocketEvent(t *testing.T, userID, eventType string) {
+	t.Helper()
+
+	websocketClient := th.GetWebsocketClientForUser(t, userID)
+
+	for {
+		select {
+		case event, ok := <-websocketClient.EventChannel:
+			if !ok {
+				t.Fatal("channel closed before getting websocket event")
+			}
+
+			if event.EventType() == model.WebsocketEventType(eventType) {
+				return
+			}
+		case <-time.After(5 * time.Second):
+			t.Fatal("failed to get websocket event " + eventType)
+		}
+	}
+}
+
 func (th *testHelper) assertEphemeralMessage(t *testing.T, userID, channelID, message string) {
 	t.Helper()
 

server/websocket_events.go

@@ -0,0 +1,6 @@
+package main
+
+const (
+	WSEventUserConnected    = "user_connected"
+	WSEventUserDisconnected = "user_disconnected"
+)

webapp/src/actions.ts

@@ -0,0 +1,9 @@
+import * as Actions from './types/actions';
+
+export const userConnected = (): Actions.UserHasConnected => ({
+    type: Actions.USER_CONNECTED,
+});
+
+export const userDisconnected = (): Actions.UserHasDisconnected => ({
+    type: Actions.USER_DISCONNECTED,
+});

webapp/src/client.ts

@@ -12,6 +12,10 @@ export interface SiteStats {
     total_users_sending: number;
 }
 
+export interface ConnectionStatus {
+    connected: boolean;
+}
+
 class ClientClass {
     url = '';
 
@@ -35,6 +39,14 @@ class ClientClass {
         return data as SiteStats;
     };
 
+    connectionStatus = async (): Promise<ConnectionStatus> => {
+        const data = await this.doGet(`${this.url}/connection-status`);
+        if (!data) {
+            return {connected: false};
+        }
+        return data as ConnectionStatus;
+    };
+
     doGet = async (url: string, headers: {[key: string]: any} = {}) => {
         headers['X-Timezone-Offset'] = new Date().getTimezoneOffset();