@webex/plugin-meetings 3.0.0-beta.42 → 3.0.0-beta.43

package/dist/types/constants.d.ts

@@ -615,6 +615,8 @@ export declare const DISPLAY_HINTS: {
     DISABLE_MUTE_ON_ENTRY: string;
     ENABLE_HARD_MUTE: string;
     DISABLE_HARD_MUTE: string;
+    MUTE_ALL: string;
+    UNMUTE_ALL: string;
 };
 export declare const SELF_ROLES: {
     COHOST: string;

package/dist/types/controls-options-manager/enums.d.ts

@@ -1,5 +1,6 @@
 declare enum Setting {
     disallowUnmute = "DisallowUnmute",
-    muteOnEntry = "MuteOnEntry"
+    muteOnEntry = "MuteOnEntry",
+    muted = "Muted"
 }
 export default Setting;

package/dist/types/controls-options-manager/index.d.ts

@@ -97,7 +97,6 @@ export default class ControlsOptionsManager {
     private extract;
     /**
      * @param {Setting} setting
-     * @param {boolean} enabled
      * @private
      * @memberof ControlsOptionsManager
      * @returns {Promise}
@@ -117,4 +116,13 @@ export default class ControlsOptionsManager {
      * @returns {Promise}
      */
     setDisallowUnmute(enabled: boolean): Promise<any>;
+    /**
+     * @public
+     * @param {boolean} mutedEnabled
+     * @param {boolean} disallowUnmuteEnabled
+     * @param {boolean} muteOnEntryEnabled
+     * @memberof ControlsOptionsManager
+     * @returns {Promise}
+     */
+    setMuteAll(mutedEnabled: boolean, disallowUnmuteEnabled: boolean, muteOnEntryEnabled: boolean): Promise<any>;
 }

package/dist/types/controls-options-manager/util.d.ts

@@ -1,7 +1,9 @@
 declare const _default: {
     canSetMuteOnEntry: (displayHints: string[]) => boolean;
     canSetDisallowUnmute: (displayHints: string[]) => boolean;
+    canSetMuted: (displayHints: string[]) => boolean;
     canUnsetMuteOnEntry: (displayHints: string[]) => boolean;
     canUnsetDisallowUnmute: (displayHints: string[]) => boolean;
+    canUnsetMuted: (displayHints: string[]) => boolean;
 };
 export default _default;

package/dist/types/meeting/in-meeting-actions.d.ts

@@ -14,6 +14,8 @@ interface IInMeetingActions {
     canUnsetMuteOnEntry?: boolean;
     canSetDisallowUnmute?: boolean;
     canUnsetDisallowUnmute?: boolean;
+    canSetMuted?: boolean;
+    canUnsetMuted?: boolean;
     canAssignHost?: boolean;
     canStartRecording?: boolean;
     canPauseRecording?: boolean;
@@ -53,6 +55,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canUnsetMuteOnEntry: any;
     canSetDisallowUnmute: any;
     canUnsetDisallowUnmute: any;
+    canSetMuted: any;
+    canUnsetMuted: any;
     canRaiseHand: any;
     canLowerAllHands: any;
     canLowerSomeoneElsesHand: any;

package/dist/types/meeting/index.d.ts

@@ -1401,6 +1401,16 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     setDisallowUnmute(enabled: boolean): Promise<any>;
+    /**
+     * set the mute all flag for participants if you're the host
+     * @returns {Promise}
+     * @param {boolean} mutedEnabled
+     * @param {boolean} disallowUnmuteEnabled
+     * @param {boolean} muteOnEntryEnabled
+     * @public
+     * @memberof Meeting
+     */
+    setMuteAll(mutedEnabled: boolean, disallowUnmuteEnabled: boolean, muteOnEntryEnabled: boolean): Promise<any>;
     /**
      * End the recording of this meeting
      * @returns {Promise}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.42",
+  "version": "3.0.0-beta.43",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,12 +32,12 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.42",
-    "@webex/test-helper-chai": "3.0.0-beta.42",
-    "@webex/test-helper-mocha": "3.0.0-beta.42",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.42",
-    "@webex/test-helper-retry": "3.0.0-beta.42",
-    "@webex/test-helper-test-users": "3.0.0-beta.42",
+    "@webex/plugin-meetings": "3.0.0-beta.43",
+    "@webex/test-helper-chai": "3.0.0-beta.43",
+    "@webex/test-helper-mocha": "3.0.0-beta.43",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.43",
+    "@webex/test-helper-retry": "3.0.0-beta.43",
+    "@webex/test-helper-test-users": "3.0.0-beta.43",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -46,18 +46,18 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.42",
+    "@webex/common": "3.0.0-beta.43",
     "@webex/internal-media-core": "1.35.2",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.42",
-    "@webex/internal-plugin-device": "3.0.0-beta.42",
-    "@webex/internal-plugin-llm": "3.0.0-beta.42",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.42",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.42",
-    "@webex/internal-plugin-support": "3.0.0-beta.42",
-    "@webex/internal-plugin-user": "3.0.0-beta.42",
-    "@webex/plugin-people": "3.0.0-beta.42",
-    "@webex/plugin-rooms": "3.0.0-beta.42",
-    "@webex/webex-core": "3.0.0-beta.42",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.43",
+    "@webex/internal-plugin-device": "3.0.0-beta.43",
+    "@webex/internal-plugin-llm": "3.0.0-beta.43",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.43",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.43",
+    "@webex/internal-plugin-support": "3.0.0-beta.43",
+    "@webex/internal-plugin-user": "3.0.0-beta.43",
+    "@webex/plugin-people": "3.0.0-beta.43",
+    "@webex/plugin-rooms": "3.0.0-beta.43",
+    "@webex/webex-core": "3.0.0-beta.43",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/constants.ts

@@ -781,6 +781,8 @@ export const DISPLAY_HINTS = {
   DISABLE_MUTE_ON_ENTRY: 'DISABLE_MUTE_ON_ENTRY',
   ENABLE_HARD_MUTE: 'ENABLE_HARD_MUTE',
   DISABLE_HARD_MUTE: 'DISABLE_HARD_MUTE',
+  MUTE_ALL: 'MUTE_ALL',
+  UNMUTE_ALL: 'UNMUTE_ALL',
 };
 
 export const SELF_ROLES = {

package/src/controls-options-manager/enums.ts

@@ -1,6 +1,7 @@
 enum Setting {
   disallowUnmute = 'DisallowUnmute',
   muteOnEntry = 'MuteOnEntry',
+  muted = 'Muted',
 }
 
 export default Setting;

package/src/controls-options-manager/index.ts

@@ -135,30 +135,45 @@ export default class ControlsOptionsManager {
 
   /**
    * @param {Setting} setting
-   * @param {boolean} enabled
    * @private
    * @memberof ControlsOptionsManager
    * @returns {Promise}
    */
-  private setControls(setting: Setting, enabled: boolean): Promise<any> {
-    LoggerProxy.logger.log(`ControlsOptionsManager:index#setControls --> ${setting} [${enabled}]`);
-
-    if (Util?.[`${enabled ? CAN_SET : CAN_UNSET}${setting}`](this.displayHints)) {
-      // @ts-ignore
-      return this.request.request({
-        uri: `${this.locusUrl}/${CONTROLS}`,
-        body: {
-          [camelCase(setting)]: {
-            [ENABLED]: enabled,
-          },
-        },
-        method: HTTP_VERBS.PATCH,
-      });
+  private setControls(setting: {[key in Setting]?: boolean}): Promise<any> {
+    const muteUnmuteAll = Object.keys(setting).includes(Setting.muted);
+
+    const body = muteUnmuteAll ? {audio: {}} : {};
+    for (const [key, value] of Object.entries(setting)) {
+      LoggerProxy.logger.log(`ControlsOptionsManager:index#setControls --> ${key} [${value}]`);
+      // mute unmute all has different body structure than toggling disable hard mute
+      // or mute on entry by themselves
+      if (muteUnmuteAll) {
+        if (Util?.[`${value ? CAN_SET : CAN_UNSET}${Setting.muted}`](this.displayHints)) {
+          body.audio[camelCase(key)] = value;
+        } else {
+          return Promise.reject(
+            new PermissionError(
+              `${Setting.muted} [${value}] not allowed, due to moderator property.`
+            )
+          );
+        }
+      } else if (Util?.[`${value ? CAN_SET : CAN_UNSET}${key}`](this.displayHints)) {
+        body[camelCase(key)] = {
+          [ENABLED]: value,
+        };
+      } else {
+        return Promise.reject(
+          new PermissionError(`${key} [${value}] not allowed, due to moderator property.`)
+        );
+      }
     }
 
-    return Promise.reject(
-      new PermissionError(`${setting} [${enabled}] not allowed, due to moderator property.`)
-    );
+    // @ts-ignore
+    return this.request.request({
+      uri: `${this.locusUrl}/${CONTROLS}`,
+      body,
+      method: HTTP_VERBS.PATCH,
+    });
   }
 
   /**
@@ -168,7 +183,7 @@ export default class ControlsOptionsManager {
    * @returns {Promise}
    */
   public setMuteOnEntry(enabled: boolean): Promise<any> {
-    return this.setControls(Setting.muteOnEntry, enabled);
+    return this.setControls({[Setting.muteOnEntry]: enabled});
   }
 
   /**
@@ -178,6 +193,26 @@ export default class ControlsOptionsManager {
    * @returns {Promise}
    */
   public setDisallowUnmute(enabled: boolean): Promise<any> {
-    return this.setControls(Setting.disallowUnmute, enabled);
+    return this.setControls({[Setting.disallowUnmute]: enabled});
+  }
+
+  /**
+   * @public
+   * @param {boolean} mutedEnabled
+   * @param {boolean} disallowUnmuteEnabled
+   * @param {boolean} muteOnEntryEnabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setMuteAll(
+    mutedEnabled: boolean,
+    disallowUnmuteEnabled: boolean,
+    muteOnEntryEnabled: boolean
+  ): Promise<any> {
+    return this.setControls({
+      [Setting.muted]: mutedEnabled,
+      [Setting.disallowUnmute]: disallowUnmuteEnabled,
+      [Setting.muteOnEntry]: muteOnEntryEnabled,
+    });
   }
 }

package/src/controls-options-manager/util.ts

@@ -12,9 +12,19 @@ const canUnsetMuteOnEntry = (displayHints: Array<string>): boolean =>
 const canUnsetDisallowUnmute = (displayHints: Array<string>): boolean =>
   displayHints.includes(DISPLAY_HINTS.DISABLE_HARD_MUTE);
 
+// 'Muted' in the context of controls options manager refers to mute/unmute all.
+// This was chosen because locus uses "muted" in the /controls API
+const canSetMuted = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.MUTE_ALL);
+
+const canUnsetMuted = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.UNMUTE_ALL);
+
 export default {
   canSetMuteOnEntry,
   canSetDisallowUnmute,
+  canSetMuted,
   canUnsetMuteOnEntry,
   canUnsetDisallowUnmute,
+  canUnsetMuted,
 };

package/src/meeting/in-meeting-actions.ts

@@ -17,6 +17,8 @@ interface IInMeetingActions {
   canUnsetMuteOnEntry?: boolean;
   canSetDisallowUnmute?: boolean;
   canUnsetDisallowUnmute?: boolean;
+  canSetMuted?: boolean;
+  canUnsetMuted?: boolean;
   canAssignHost?: boolean;
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
@@ -71,6 +73,10 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canUnsetDisallowUnmute = null;
 
+  canSetMuted = null;
+
+  canUnsetMuted = null;
+
   canRaiseHand = null;
 
   canLowerAllHands = null;
@@ -114,6 +120,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canSetMuteOnEntry: this.canSetMuteOnEntry,
     canUnsetMuteOnEntry: this.canUnsetMuteOnEntry,
     canSetDisallowUnmute: this.canSetDisallowUnmute,
+    canSetMuted: this.canSetMuted,
+    canUnsetMuted: this.canUnsetMuted,
     canUnsetDisallowUnmute: this.canUnsetDisallowUnmute,
     canStartRecording: this.canStartRecording,
     canPauseRecording: this.canPauseRecording,

package/src/meeting/index.ts

@@ -2290,6 +2290,8 @@ export default class Meeting extends StatelessWebexPlugin {
           canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
             payload.info.userDisplayHints
           ),
+          canSetMuted: ControlsOptionsUtil.canSetMuted(payload.info.userDisplayHints),
+          canUnsetMuted: ControlsOptionsUtil.canUnsetMuted(payload.info.userDisplayHints),
           canStartRecording: RecordingUtil.canUserStart(payload.info.userDisplayHints),
           canStopRecording: RecordingUtil.canUserStop(payload.info.userDisplayHints),
           canPauseRecording: RecordingUtil.canUserPause(payload.info.userDisplayHints),
@@ -6216,6 +6218,27 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.controlsOptionsManager.setDisallowUnmute(enabled);
   }
 
+  /**
+   * set the mute all flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} mutedEnabled
+   * @param {boolean} disallowUnmuteEnabled
+   * @param {boolean} muteOnEntryEnabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteAll(
+    mutedEnabled: boolean,
+    disallowUnmuteEnabled: boolean,
+    muteOnEntryEnabled: boolean
+  ) {
+    return this.controlsOptionsManager.setMuteAll(
+      mutedEnabled,
+      disallowUnmuteEnabled,
+      muteOnEntryEnabled
+    );
+  }
+
   /**
    * End the recording of this meeting
    * @returns {Promise}

package/test/unit/spec/controls-options-manager/index.js

@@ -119,6 +119,62 @@ describe('plugin-meetings', () => {
                     });
                   });
             });
+
+            describe('Mute/Unmute All', () => {
+              let manager;
+              beforeEach(() => {
+                request = {
+                  request: sinon.stub().returns(Promise.resolve()),
+                };
+
+                manager = new ControlsOptionsManager(request);
+
+                manager.set({
+                  locusUrl: 'test/id',
+                  displayHints: [],
+                })
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=false', () => {  
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('rejects when correct display hint is not present mutedEnabled=true', () => {  
+                const result = manager.setMuteAll(true, false, false);
+
+                assert.notCalled(request.request);
+
+                assert.isRejected(result);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'ENABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all when the display hint is available mutedEnabled=false', () => {
+                manager.setDisplayHints(['UNMUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(false, false, false);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                body: { audio: { muted: false, disallowUnmute: false, muteOnEntry: false } },
+                method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+            });
           });
     });
 });

package/test/unit/spec/controls-options-manager/util.js

@@ -61,6 +61,26 @@ describe('plugin-meetings', () => {
               });
             });
 
+            describe('canSetMuteAll', () => {
+              it('can mute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('MUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can unmute all', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('UNMUTE_ALL');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuted(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
         });
     });
 });

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -17,6 +17,8 @@ describe('plugin-meetings', () => {
         canUnsetMuteOnEntry: null,
         canSetDisallowUnmute: null,
         canUnsetDisallowUnmute: null,
+        canSetMuted: null,
+        canUnsetMuted: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,