[MM-58259] [MM-58260] Move the /call end command to host controls

e2e/page.ts

@@ -64,7 +64,7 @@ export default class PlaywrightDevPage {
         await expect(this.page.locator('#calls-widget')).toBeVisible();
     }
 
-    async endCall() {
+    async slashCallEnd() {
         await this.sendSlashCommand('/call end');
         let modal = this.page.locator('#calls-end-call-modal');
         if (await modal.isVisible()) {

e2e/tests/channel_toast.spec.ts

@@ -54,4 +54,16 @@ test.describe('channel toast', () => {
 
         await userPage.leaveCall();
     });
+
+    test('does not reappear after leaving call (call ends)', async () => {
+        const user0Page = await startCall(userStorages[0]);
+
+        await expect(user0Page.page.locator('#calls-channel-toast')).toBeHidden();
+
+        await user0Page.leaveCall();
+
+        await user0Page.wait(3000);
+
+        await expect(user0Page.page.locator('#calls-channel-toast')).toBeHidden();
+    });
 });

e2e/tests/host_controls.spec.ts

@@ -21,7 +21,7 @@ test.beforeEach(async ({page, context}) => {
 });
 test.afterEach(async ({page, context}) => {
     const devPage = new PlaywrightDevPage(page);
-    await devPage.endCall();
+    await devPage.slashCallEnd();
 });
 
 test.describe('host controls', () => {

e2e/tests/slash_commands.spec.ts

@@ -0,0 +1,52 @@
+import {chromium, expect, test} from '@playwright/test';
+import {readFile} from 'fs/promises';
+
+import PlaywrightDevPage from '../page';
+import {getUserIdxForTest, getUsernamesForTest, getUserStoragesForTest, joinCall, startCall} from '../utils';
+
+const userStorages = getUserStoragesForTest();
+const usernames = getUsernamesForTest();
+
+test.beforeEach(async ({page, context}) => {
+    const devPage = new PlaywrightDevPage(page);
+    await devPage.goto();
+});
+
+test.describe('slash commands', () => {
+    const userIdx = getUserIdxForTest();
+    test.use({storageState: getUserStoragesForTest()[0]});
+
+    test('end call', async ({page}) => {
+        const devPage = new PlaywrightDevPage(page);
+        await devPage.startCall();
+
+        await expect(page.locator('#calls-widget')).toBeVisible();
+        await expect(page.getByTestId('calls-widget-loading-overlay')).toBeHidden();
+
+        await devPage.slashCallEnd();
+
+        // /call end cleans up all indicators of a running call
+        await expect(page.locator('#calls-widget')).toBeHidden();
+        await expect(page.locator('#calls-channel-toast')).toBeHidden();
+        await expect(page.locator(`#sidebarItem_calls${userIdx}`).getByTestId('calls-sidebar-active-call-icon')).toBeHidden();
+    });
+
+    test('end call as second host', async () => {
+        const user0Page = await startCall(userStorages[0]);
+        const user1Page = await joinCall(userStorages[1]);
+
+        await expect(user0Page.page.locator('#calls-widget')).toBeVisible();
+        await expect(user0Page.page.getByTestId('calls-widget-loading-overlay')).toBeHidden();
+
+        await user0Page.sendSlashCommand(`/call host @${usernames[1]}`);
+        await user0Page.wait(1000);
+        await user0Page.expectHostToBe(usernames[1]);
+
+        await user1Page.slashCallEnd();
+
+        // /call end cleans up all indicators of a running call
+        await expect(user0Page.page.locator('#calls-widget')).toBeHidden();
+        await expect(user0Page.page.locator('#calls-channel-toast')).toBeHidden();
+        await expect(user0Page.page.locator(`#sidebarItem_calls${userIdx}`).getByTestId('calls-sidebar-active-call-icon')).toBeHidden();
+    });
+});

server/api.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"net/http"
 	"path/filepath"
-	"time"
 
 	"golang.org/x/time/rate"
 
@@ -212,80 +211,6 @@ func (p *Plugin) handleGetAllCallChannelStates(w http.ResponseWriter, r *http.Re
 	}
 }
 
-func (p *Plugin) handleEndCall(w http.ResponseWriter, r *http.Request) {
-	var res httpResponse
-	defer p.httpAudit("handleEndCall", &res, w, r)
-
-	userID := r.Header.Get("Mattermost-User-Id")
-	channelID := mux.Vars(r)["channel_id"]
-
-	isAdmin := p.API.HasPermissionTo(userID, model.PermissionManageSystem)
-
-	state, err := p.lockCallReturnState(channelID)
-	if err != nil {
-		res.Err = fmt.Errorf("failed to lock call: %w", err).Error()
-		res.Code = http.StatusInternalServerError
-		return
-	}
-	defer p.unlockCall(channelID)
-
-	if state == nil {
-		res.Err = "no call ongoing"
-		res.Code = http.StatusBadRequest
-		return
-	}
-
-	if !isAdmin && state.Call.OwnerID != userID {
-		res.Err = "no permissions to end the call"
-		res.Code = http.StatusForbidden
-		return
-	}
-
-	if state.Call.EndAt == 0 {
-		setCallEnded(&state.Call)
-	}
-
-	if err := p.store.UpdateCall(&state.Call); err != nil {
-		res.Err = fmt.Errorf("failed to update call: %w", err).Error()
-		res.Code = http.StatusInternalServerError
-		return
-	}
-
-	p.publishWebSocketEvent(wsEventCallEnd, map[string]interface{}{}, &WebSocketBroadcast{ChannelID: channelID, ReliableClusterSend: true})
-
-	callID := state.Call.ID
-	nodeID := state.Call.Props.NodeID
-
-	go func() {
-		// We wait a few seconds for the call to end cleanly. If this doesn't
-		// happen we force end it.
-		time.Sleep(5 * time.Second)
-
-		call, err := p.store.GetCall(callID, db.GetCallOpts{})
-		if err != nil {
-			p.LogError("failed to get call", "err", err.Error())
-		}
-
-		sessions, err := p.store.GetCallSessions(callID, db.GetCallSessionOpts{})
-		if err != nil {
-			p.LogError("failed to get call sessions", "err", err.Error())
-		}
-
-		for _, session := range sessions {
-			if err := p.closeRTCSession(session.UserID, session.ID, channelID, nodeID, callID); err != nil {
-				p.LogError(err.Error())
-			}
-		}
-
-		if err := p.cleanCallState(call); err != nil {
-			p.LogError(err.Error())
-		}
-	}()
-
-	res.Code = http.StatusOK
-	res.Msg = "success"
-}
-
 func (p *Plugin) handleDismissNotification(w http.ResponseWriter, r *http.Request) {
 	var res httpResponse
 	defer p.httpAudit("handleDismissNotification", &res, w, r)

server/api_router.go

@@ -93,10 +93,12 @@ func (p *Plugin) newAPIRouter() *mux.Router {
 	// router.HandleFunc("/channels/{channel_id:[a-z0-9]{26}}", p.handlePostCallsChannel).Methods("POST")
 
 	// Calls
-	router.HandleFunc("/calls/{channel_id:[a-z0-9]{26}}/end", p.handleEndCall).Methods("POST")
 	router.HandleFunc("/calls/{channel_id:[a-z0-9]{26}}/dismiss-notification", p.handleDismissNotification).Methods("POST")
 	router.HandleFunc("/calls/{call_id:[a-z0-9]{26}}/recording/{action}", p.handleRecordingAction).Methods("POST")
 
+	// Deprecated for hostCtrlRounder /end, but needed for mobile backward compatibility (pre 2.18)
+	router.HandleFunc("/calls/{call_id:[a-z0-9]{26}}/end", p.handleEnd).Methods("POST")
+
 	// Host Controls
 	hostCtrlRouter := router.PathPrefix("/calls/{call_id:[a-z0-9]{26}}/host").Subrouter()
 	hostCtrlRouter.HandleFunc("/make", p.handleMakeHost).Methods("POST")
@@ -105,6 +107,7 @@ func (p *Plugin) newAPIRouter() *mux.Router {
 	hostCtrlRouter.HandleFunc("/lower-hand", p.handleLowerHand).Methods("POST")
 	hostCtrlRouter.HandleFunc("/remove", p.handleRemoveSession).Methods("POST")
 	hostCtrlRouter.HandleFunc("/mute-others", p.handleMuteOthers).Methods("POST")
+	hostCtrlRouter.HandleFunc("/end", p.handleEnd).Methods("POST")
 
 	// Bot
 	botRouter := router.PathPrefix("/bot").Subrouter()

server/host_controls.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/mattermost/mattermost-plugin-calls/server/db"
+
 	"github.com/mattermost/mattermost/server/public/model"
 	"github.com/pkg/errors"
 )
@@ -255,3 +257,62 @@ func (p *Plugin) hostRemoveSession(requesterID, channelID, sessionID string) err
 
 	return nil
 }
+
+func (p *Plugin) hostEnd(requesterID, channelID string) error {
+	state, err := p.lockCallReturnState(channelID)
+	if err != nil {
+		return fmt.Errorf("failed to lock call: %w", err)
+	}
+	defer p.unlockCall(channelID)
+
+	if state == nil {
+		return ErrNoCallOngoing
+	}
+
+	if requesterID != state.Call.GetHostID() {
+		if isAdmin := p.API.HasPermissionTo(requesterID, model.PermissionManageSystem); !isAdmin {
+			return ErrNoPermissions
+		}
+	}
+
+	if state.Call.EndAt == 0 {
+		setCallEnded(&state.Call)
+	}
+
+	if err := p.store.UpdateCall(&state.Call); err != nil {
+		return fmt.Errorf("failed to update call: %w", err)
+	}
+
+	p.publishWebSocketEvent(wsEventCallEnd, map[string]interface{}{}, &WebSocketBroadcast{ChannelID: channelID, ReliableClusterSend: true})
+
+	callID := state.Call.ID
+	nodeID := state.Call.Props.NodeID
+
+	go func() {
+		// We wait a few seconds for the call to end cleanly. If this doesn't
+		// happen we force end it.
+		time.Sleep(5 * time.Second)
+
+		call, err := p.store.GetCall(callID, db.GetCallOpts{})
+		if err != nil {
+			p.LogError("failed to get call", "err", err.Error())
+		}
+
+		sessions, err := p.store.GetCallSessions(callID, db.GetCallSessionOpts{})
+		if err != nil {
+			p.LogError("failed to get call sessions", "err", err.Error())
+		}
+
+		for _, session := range sessions {
+			if err := p.closeRTCSession(session.UserID, session.ID, channelID, nodeID, callID); err != nil {
+				p.LogError(err.Error())
+			}
+		}
+
+		if err := p.cleanCallState(call); err != nil {
+			p.LogError(err.Error())
+		}
+	}()
+
+	return nil
+}

server/host_controls_api.go

@@ -149,6 +149,22 @@ func (p *Plugin) handleRemoveSession(w http.ResponseWriter, r *http.Request) {
 	res.Msg = "success"
 }
 
+func (p *Plugin) handleEnd(w http.ResponseWriter, r *http.Request) {
+	var res httpResponse
+	defer p.httpAudit("handleEnd", &res, w, r)
+
+	userID := r.Header.Get("Mattermost-User-Id")
+	callID := mux.Vars(r)["call_id"]
+
+	if err := p.hostEnd(userID, callID); err != nil {
+		p.handleHostControlsError(err, &res, "handleEnd")
+		return
+	}
+
+	res.Code = http.StatusOK
+	res.Msg = "success"
+}
+
 func (p *Plugin) handleHostControlsError(err error, res *httpResponse, handlerName string) {
 	p.LogError(handlerName, "err", err.Error())
 

webapp/src/action_types.ts

@@ -40,7 +40,8 @@ export const RINGING_FOR_CALL = pluginId + '_ringing_for_call';
 export const DID_RING_FOR_CALL = pluginId + '_did_ring_for_call';
 export const DID_NOTIFY_FOR_CALL = pluginId + '_did_notify_for_call';
 
-// CALL_END is sent when the `/call end` command is used
+// CALL_END is sent when the `/call end` command is used,
+//  and when the last session in the call leaves the call
 export const CALL_END = pluginId + '_call_end';
 
 export const RECEIVED_CALLS_CONFIG = pluginId + '_received_calls_config';

webapp/src/actions.ts

@@ -27,11 +27,10 @@ import RestClient from 'src/rest_client';
 import {
     callDismissedNotification,
     calls,
-    channelHasCall,
     hostChangeAtForCurrentCall,
     idForCurrentCall,
     incomingCalls,
-    ringingEnabled,
+    numSessionsInCallInChannel,
     ringingForCall,
 } from 'src/selectors';
 import * as Telemetry from 'src/types/telemetry';
@@ -49,6 +48,7 @@ import {modals, notificationSounds, openPricingModal} from 'src/webapp_globals';
 
 import {
     ADD_INCOMING_CALL,
+    CALL_END,
     CALL_HOST,
     CALL_LIVE_CAPTIONS_STATE,
     CALL_REC_PROMPT_DISMISSED,
@@ -221,7 +221,7 @@ export const requestOnPremTrialLicense = async (users: number, termsAccepted: bo
 
 export const endCall = (channelID: string) => {
     return RestClient.fetch(
-        `${getPluginPath()}/calls/${channelID}/end`,
+        `${getPluginPath()}/calls/${channelID}/host/end`,
         {method: 'post'},
     );
 };
@@ -402,8 +402,14 @@ export const userLeft = (channelID: string, userID: string, sessionID: string) =
             },
         });
 
-        if (ringingEnabled(getState()) && !channelHasCall(getState(), channelID)) {
-            await dispatch(removeIncomingCallNotification(callID));
+        if (numSessionsInCallInChannel(getState(), channelID) === 0) {
+            dispatch({
+                type: CALL_END,
+                data: {
+                    channelID,
+                    callID,
+                },
+            });
         }
     };
 };

webapp/src/components/channel_call_toast.tsx

@@ -27,13 +27,13 @@ const ChannelCallToast = () => {
     const callID = useSelector(callInCurrentChannel)?.ID || '';
     const [onDismiss, onJoin] = useDismissJoin(currChannelID, callID);
 
-    const hasCall = (currChannelID !== connectedID && profiles.length > 0);
+    const hasCall = (call && currChannelID !== connectedID);
 
     if (!hasCall || dismissed || limitRestricted) {
         return null;
     }
 
-    const timestampFn = () => callStartedTimestampFn(intl, call?.startAt);
+    const timestampFn = () => callStartedTimestampFn(intl, call.startAt);
 
     return (
         <div

webapp/src/components/channel_header_button.tsx

@@ -11,11 +11,11 @@ import {
     callsShowButton,
     channelIDForCurrentCall,
     clientConnecting,
+    currentChannelHasCall,
     isCloudProfessionalOrEnterpriseOrTrial,
     isCloudStarter,
     isLimitRestricted,
     maxParticipants,
-    profilesInCallInCurrentChannel,
 } from 'src/selectors';
 import {getUserIdFromDM, isDMChannel} from 'src/utils';
 import styled, {css} from 'styled-components';
@@ -28,7 +28,7 @@ const ChannelHeaderButton = () => {
     const isDeactivatedDM = isDMChannel(channel) && otherUser?.delete_at > 0;
     const show = useSelector((state: GlobalState) => callsShowButton(state, channel?.id));
     const inCall = useSelector(channelIDForCurrentCall) === channel?.id;
-    const hasCall = useSelector(profilesInCallInCurrentChannel).length > 0;
+    const hasCall = useSelector(currentChannelHasCall);
     const isAdmin = useSelector(isCurrentUserSystemAdmin);
     const cloudStarter = useSelector(isCloudStarter);
     const isCloudPaid = useSelector(isCloudProfessionalOrEnterpriseOrTrial);