@webex/plugin-meetings 2.38.1 → 2.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.38.1",
+  "version": "2.39.0",
   "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 ./types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "2.38.1",
-    "@webex/test-helper-chai": "2.38.1",
-    "@webex/test-helper-mocha": "2.38.1",
-    "@webex/test-helper-mock-webex": "2.38.1",
-    "@webex/test-helper-retry": "2.38.1",
-    "@webex/test-helper-test-users": "2.38.1",
+    "@webex/plugin-meetings": "2.39.0",
+    "@webex/test-helper-chai": "2.39.0",
+    "@webex/test-helper-mocha": "2.39.0",
+    "@webex/test-helper-mock-webex": "2.39.0",
+    "@webex/test-helper-retry": "2.39.0",
+    "@webex/test-helper-test-users": "2.39.0",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -45,18 +45,18 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "2.38.1",
+    "@webex/common": "2.39.0",
     "@webex/internal-media-core": "0.0.7-beta",
-    "@webex/internal-plugin-conversation": "2.38.1",
-    "@webex/internal-plugin-device": "2.38.1",
-    "@webex/internal-plugin-mercury": "2.38.1",
-    "@webex/internal-plugin-metrics": "2.38.1",
-    "@webex/internal-plugin-support": "2.38.1",
-    "@webex/internal-plugin-user": "2.38.1",
-    "@webex/plugin-people": "2.38.1",
-    "@webex/plugin-rooms": "2.38.1",
+    "@webex/internal-plugin-conversation": "2.39.0",
+    "@webex/internal-plugin-device": "2.39.0",
+    "@webex/internal-plugin-mercury": "2.39.0",
+    "@webex/internal-plugin-metrics": "2.39.0",
+    "@webex/internal-plugin-support": "2.39.0",
+    "@webex/internal-plugin-user": "2.39.0",
+    "@webex/plugin-people": "2.39.0",
+    "@webex/plugin-rooms": "2.39.0",
     "@webex/ts-sdp": "1.0.1",
-    "@webex/webex-core": "2.38.1",
+    "@webex/webex-core": "2.39.0",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
     "dotenv": "^4.0.0",

package/src/constants.ts

@@ -724,6 +724,10 @@ export const DISPLAY_HINTS = {
   TRANSCRIPTION_CONTROL_STOP: 'TRANSCRIPTION_CONTROL_STOP',
   WEBEX_ASSISTANT_STATUS_ACTIVE: 'WEBEX_ASSISTANT_STATUS_ACTIVE',
   WAITING_FOR_OTHERS: 'WAITING_FOR_OTHERS',
+  ENABLE_MUTE_ON_ENTRY: 'ENABLE_MUTE_ON_ENTRY',
+  DISABLE_MUTE_ON_ENTRY: 'DISABLE_MUTE_ON_ENTRY',
+  ENABLE_HARD_MUTE: 'ENABLE_HARD_MUTE',
+  DISABLE_HARD_MUTE: 'DISABLE_HARD_MUTE',
 };
 
 export const SELF_ROLES = {

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

@@ -0,0 +1,5 @@
+const ENABLED = 'enabled';
+const CAN_SET = 'canSet';
+const CAN_UNSET = 'canUnset';
+
+export {ENABLED, CAN_SET, CAN_UNSET};

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

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

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

@@ -0,0 +1,183 @@
+import {camelCase} from 'lodash';
+import PermissionError from '../common/errors/permission';
+import {CONTROLS, HTTP_VERBS} from '../constants';
+import MeetingRequest from '../meeting/request';
+import LoggerProxy from '../common/logs/logger-proxy';
+import Setting from './enums';
+import Util from './util';
+import {CAN_SET, CAN_UNSET, ENABLED} from './constants';
+
+/**
+ * docs
+ * https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html
+ * https://confluence-eng-gpk2.cisco.com/conf/display/LOCUS/Hard+Mute+and+Audio+Privacy#HardMuteandAudioPrivacy-SelfMuteonEntry
+ * https://confluence-eng-gpk2.cisco.com/conf/pages/viewpage.action?spaceKey=UC&title=WEBEX-124454%3A+UCF%3A+Hard+mute+support+for+Teams+joining+Webex+meeting
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-180867
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-393351
+ */
+
+/**
+ * @description ControlsOptionsManager is responsible for handling the behavior of participant controls when somebody joins a meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class ControlsOptionsManager {
+  /**
+   * @instance
+   * @type {MeetingRequest}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private request: MeetingRequest;
+
+  /**
+   * @instance
+   * @type {Array}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private displayHints: Array<string> = [];
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private locusUrl: string;
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {Object} options
+   * @constructor
+   * @memberof ControlsOptionsManager
+   */
+  constructor(
+    request: MeetingRequest,
+    options?: {
+      locusUrl: string;
+      displayHints?: Array<string>;
+    }
+  ) {
+    this.initialize(request);
+    this.set(options);
+  }
+
+  /**
+   * @param {MeetingRequest} request
+   * @returns {void}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private initialize(request: MeetingRequest) {
+    this.request = request;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public set(options?: {locusUrl: string; displayHints?: Array<string>}) {
+    this.extract(options);
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public setLocusUrl(url: string) {
+    this.locusUrl = url;
+  }
+
+  /**
+   * @param {Array} hints
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public setDisplayHints(hints: Array<string>) {
+    this.displayHints = hints;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public getLocusUrl() {
+    return this.locusUrl;
+  }
+
+  /**
+   * @returns {Array}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public getDisplayHints() {
+    return this.displayHints;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private extract(options?: {locusUrl: string; displayHints?: Array<string>}) {
+    this.setDisplayHints(options?.displayHints);
+    this.setLocusUrl(options?.locusUrl);
+  }
+
+  /**
+   * @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,
+      });
+    }
+
+    return Promise.reject(
+      new PermissionError(`${setting} [${enabled}] not allowed, due to moderator property.`)
+    );
+  }
+
+  /**
+   * @public
+   * @param {boolean} enabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setMuteOnEntry(enabled: boolean): Promise<any> {
+    return this.setControls(Setting.muteOnEntry, enabled);
+  }
+
+  /**
+   * @public
+   * @param {boolean} enabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setDisallowUnmute(enabled: boolean): Promise<any> {
+    return this.setControls(Setting.disallowUnmute, enabled);
+  }
+}

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

@@ -0,0 +1,20 @@
+import {DISPLAY_HINTS} from '../constants';
+
+const canSetMuteOnEntry = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY);
+
+const canSetDisallowUnmute = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_HARD_MUTE);
+
+const canUnsetMuteOnEntry = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY);
+
+const canUnsetDisallowUnmute = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.DISABLE_HARD_MUTE);
+
+export default {
+  canSetMuteOnEntry,
+  canSetDisallowUnmute,
+  canUnsetMuteOnEntry,
+  canUnsetDisallowUnmute,
+};

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

@@ -13,6 +13,10 @@ interface IInMeetingActions {
   canAdmitParticipant?: boolean;
   canLock?: boolean;
   canUnlock?: boolean;
+  canSetMuteOnEntry?: boolean;
+  canUnsetMuteOnEntry?: boolean;
+  canSetDisallowUnmute?: boolean;
+  canUnsetDisallowUnmute?: boolean;
   canAssignHost?: boolean;
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
@@ -57,6 +61,14 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canStopRecording = null;
 
+  canSetMuteOnEntry = null;
+
+  canUnsetMuteOnEntry = null;
+
+  canSetDisallowUnmute = null;
+
+  canUnsetDisallowUnmute = null;
+
   canRaiseHand = null;
 
   canLowerAllHands = null;
@@ -93,6 +105,10 @@ export default class InMeetingActions implements IInMeetingActions {
     canLock: this.canLock,
     canUnlock: this.canUnlock,
     canAssignHost: this.canAssignHost,
+    canSetMuteOnEntry: this.canSetMuteOnEntry,
+    canUnsetMuteOnEntry: this.canUnsetMuteOnEntry,
+    canSetDisallowUnmute: this.canSetDisallowUnmute,
+    canUnsetDisallowUnmute: this.canUnsetDisallowUnmute,
     canStartRecording: this.canStartRecording,
     canPauseRecording: this.canPauseRecording,
     canResumeRecording: this.canResumeRecording,

package/src/meeting/index.ts

@@ -31,6 +31,7 @@ import MeetingRequest from './request';
 import Members from '../members/index';
 import MeetingUtil from './util';
 import RecordingUtil from '../recording-controller/util';
+import ControlsOptionsUtil from '../controls-options-manager/util';
 import MediaUtil from '../media/util';
 import Transcription from '../transcription';
 import PasswordError from '../common/errors/password-error';
@@ -90,6 +91,7 @@ import {Reaction, ReactionType, SkinToneType} from '../reactions/reactions.type'
 
 import InMeetingActions from './in-meeting-actions';
 import RecordingController from '../recording-controller';
+import ControlsOptionsManager from '../controls-options-manager';
 
 const {isBrowser} = BrowserDetection();
 
@@ -455,6 +457,7 @@ export default class Meeting extends StatelessWebexPlugin {
   queuedMediaUpdates: any[];
   recording: any;
   recordingController: RecordingController;
+  controlsOptionsManager: ControlsOptionsManager;
   requiredCaptcha: any;
   shareStatus: string;
   statsAnalyzer: StatsAnalyzer;
@@ -1002,6 +1005,18 @@ export default class Meeting extends StatelessWebexPlugin {
       displayHints: [],
     });
 
+    /**
+     * The class that helps to control recording functions: start, stop, pause, resume, etc
+     * @instance
+     * @type {ControlsOptionsManager}
+     * @public
+     * @memberof Meeting
+     */
+    this.controlsOptionsManager = new ControlsOptionsManager(this.meetingRequest, {
+      locusUrl: this.locusInfo?.url,
+      displayHints: [],
+    });
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
     this.hasJoinedOnce = false;
@@ -2020,6 +2035,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.locusUrl = payload;
       this.locusId = this.locusUrl?.split('/').pop();
       this.recordingController.setLocusUrl(this.locusUrl);
+      this.controlsOptionsManager.setLocusUrl(this.locusUrl);
     });
   }
 
@@ -2085,6 +2101,16 @@ export default class Meeting extends StatelessWebexPlugin {
           canAdmitParticipant: MeetingUtil.canAdmitParticipant(payload.info.userDisplayHints),
           canLock: MeetingUtil.canUserLock(payload.info.userDisplayHints),
           canUnlock: MeetingUtil.canUserUnlock(payload.info.userDisplayHints),
+          canSetDisallowUnmute: ControlsOptionsUtil.canSetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canUnsetDisallowUnmute: ControlsOptionsUtil.canUnsetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canSetMuteOnEntry: ControlsOptionsUtil.canSetMuteOnEntry(payload.info.userDisplayHints),
+          canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
+            payload.info.userDisplayHints
+          ),
           canStartRecording: RecordingUtil.canUserStart(payload.info.userDisplayHints),
           canStopRecording: RecordingUtil.canUserStop(payload.info.userDisplayHints),
           canPauseRecording: RecordingUtil.canUserPause(payload.info.userDisplayHints),
@@ -2113,6 +2139,7 @@ export default class Meeting extends StatelessWebexPlugin {
         });
 
         this.recordingController.setDisplayHints(payload.info.userDisplayHints);
+        this.controlsOptionsManager.setDisplayHints(payload.info.userDisplayHints);
 
         if (changed) {
           Trigger.trigger(
@@ -4900,32 +4927,6 @@ export default class Meeting extends StatelessWebexPlugin {
             )
           )
           .then(() => this.checkForStopShare(mediaSettings.sendShare, previousSendShareStatus))
-          .then((startShare) => {
-            // This is a special case if we do an /floor grant followed by /media
-            // we actually get a OFFER from the server and a GLAR condition happens
-            if (startShare) {
-              // We are assuming that the clients are connected when doing an update
-              // @ts-ignore
-              return this.share();
-            }
-
-            return Promise.resolve();
-          })
-          .then(() =>
-            logRequest(
-              this.roap.sendRoapMediaRequest({
-                sdp: this.mediaProperties.peerConnection.sdp,
-                roapSeq: this.roapSeq,
-                meeting: this, // or can pass meeting ID
-              }),
-              {
-                header: `${LOG_HEADER} sendRoapMediaRequest being sent`,
-                success: `${LOG_HEADER} sendRoadMediaRequest successful`,
-                failure: `${LOG_HEADER} Error updateMedia on send roap media request, `,
-              }
-            )
-          )
-          .then(() => this.checkForStopShare(mediaSettings.sendShare, previousSendShareStatus))
           .then((startShare) => {
             // This is a special case if we do an /floor grant followed by /media
             // we actually get a OFFER from the server and a GLAR condition happens
@@ -5552,6 +5553,28 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.recordingController.startRecording();
   }
 
+  /**
+   * set the mute on entry flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteOnEntry(enabled: boolean) {
+    return this.controlsOptionsManager.setMuteOnEntry(enabled);
+  }
+
+  /**
+   * set the disallow unmute flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setDisallowUnmute(enabled: boolean) {
+    return this.controlsOptionsManager.setDisallowUnmute(enabled);
+  }
+
   /**
    * End the recording of this meeting
    * @returns {Promise}

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

@@ -0,0 +1,124 @@
+import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('controls-options-manager tests', () => {
+        describe('index', () => {
+            let request;
+
+            describe('class tests', () => {
+                it('can set and extract new values later on', () => {
+                    const manager = new ControlsOptionsManager({});
+                    assert.isUndefined(manager.getLocusUrl());
+                    manager.set({
+                      locusUrl: 'test/id',
+                    })
+                    assert(manager.getLocusUrl(), 'test/id');
+                });
+            });
+
+            describe('Mute On Entry', () => {
+                let manager;
+            
+                beforeEach(() => {
+                  request = {
+                    request: sinon.stub().returns(Promise.resolve()),
+                  };
+
+                  manager = new ControlsOptionsManager(request);
+
+                  manager.set({
+                    locusUrl: 'test/id',
+                    displayHints: [],
+                  })
+                });
+
+                describe('setMuteOnEntry', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+
+                  describe('setDisallowUnmute', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+            });
+          });
+    });
+});

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

@@ -0,0 +1,66 @@
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
+import { assert } from 'chai';
+
+describe('plugin-meetings', () => {
+    describe('controls-option-manager tests', () => {
+        describe('util tests', () => {
+
+            let locusInfo;
+        
+            beforeEach(() => {
+              locusInfo = {
+                parsedLocus: {
+                  info: {
+                    userDisplayHints: [],
+                  },
+                },
+              };
+            });
+        
+            describe('canUserSetMuteOnEntry', () => {
+              it('can set mute on entry enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set mute on entry disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present for setting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present for unsetting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canSetDisallowUnmute', () => {
+              it('can set disallow unmute enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set disallow unmute disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+        });
+    });
+});

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

@@ -13,6 +13,10 @@ describe('plugin-meetings', () => {
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
+        canSetMuteOnEntry: null,
+        canUnsetMuteOnEntry: null,
+        canSetDisallowUnmute: null,
+        canUnsetDisallowUnmute: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
@@ -49,6 +53,10 @@ describe('plugin-meetings', () => {
       'canPauseRecording',
       'canResumeRecording',
       'canStopRecording',
+      'canSetMuteOnEntry',
+      'canUnsetMuteOnEntry',
+      'canSetDisallowUnmute',
+      'canUnsetDisallowUnmute',
       'canRaiseHand',
       'canLowerAllHands',
       'canLowerSomeoneElsesHand',