@webex/plugin-meetings 3.7.0 → 3.8.0-next.10

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -18,7 +18,8 @@ import MeetingInfo, {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2AdhocMeetingError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError,
+  MeetingInfoV2JoinForbiddenError,
 } from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 import Metrics from '@webex/plugin-meetings/src/metrics';
@@ -895,9 +896,14 @@ describe('plugin-meetings', () => {
           {errorCode: 403021},
           {errorCode: 403022},
           {errorCode: 403024},
+          {errorCode: 403137},
+          {errorCode: 423007},
+          {errorCode: 403026},
+          {errorCode: 403037},
+          {errorCode: 403137},
         ],
         ({errorCode}) => {
-          it(`should throw a MeetingInfoV2WebinarRegistrationError for error code ${errorCode}`, async () => {
+          it(`should throw a MeetingInfoV2JoinWebinarError for error code ${errorCode}`, async () => {
             const message = 'a message';
             const meetingInfoData = {meetingInfo: {registrationUrl: 'registrationUrl'}};
 
@@ -909,7 +915,7 @@ describe('plugin-meetings', () => {
               await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
               assert.fail('createAdhocSpaceMeeting should have thrown, but has not done that');
             } catch (err) {
-              assert.instanceOf(err, MeetingInfoV2WebinarRegistrationError);
+              assert.instanceOf(err, MeetingInfoV2JoinWebinarError);
               assert.deepEqual(err.message, `${message}, code=${errorCode}`);
               assert.equal(err.wbxAppApiCode, errorCode);
               assert.deepEqual(err.meetingInfo, meetingInfoData);
@@ -917,7 +923,43 @@ describe('plugin-meetings', () => {
               assert(Metrics.sendBehavioralMetric.calledOnce);
               assert.calledWith(
                 Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.WEBINAR_REGISTRATION_ERROR,
+                BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR,
+                {code: errorCode}
+              );
+
+            }
+          });
+        }
+      );
+
+      forEach(
+        [
+          {errorCode: 403003},
+        ],
+        ({errorCode}) => {
+          it(`should throw a MeetingInfoV2JoinForbiddenError for error code ${errorCode}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+            });
+            try {
+              await meetingInfo.fetchMeetingInfo('1234323', DESTINATION_TYPE.MEETING_ID, 'abc', {
+                id: '999',
+                code: 'aabbcc11',
+              });
+            } catch (err) {
+              assert.instanceOf(err, MeetingInfoV2JoinForbiddenError);
+              assert.deepEqual(err.message, `${message}, code=${errorCode}`);
+              assert.equal(err.wbxAppApiCode, errorCode);
+              assert.deepEqual(err.meetingInfo, meetingInfoData);
+
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.JOIN_FORBIDDEN_ERROR,
                 {code: errorCode}
               );
 

package/test/unit/spec/meeting-info/utilv2.js

@@ -192,6 +192,15 @@ describe('plugin-meetings', () => {
         assert.equal(res.meetingUUID, 'xsddsdsdsdssdsdsdsdsd');
       });
 
+      it('for registrationId', () => {
+        const res = MeetingInfoUtil.getRequestBody({
+          type: DESTINATION_TYPE.MEETING_UUID,
+          registrationId: 'registrationId',
+        });
+
+        assert.equal(res.registrationId, 'registrationId');
+      });
+
       it('for DESTINATION_TYPE.LOCUS_ID', () => {
         const res = MeetingInfoUtil.getRequestBody({
           type: DESTINATION_TYPE.LOCUS_ID,
@@ -345,5 +354,22 @@ describe('plugin-meetings', () => {
         );
       });
     });
+
+    describe('#isMeetingLink', () => {
+      it('should return true for valid join meeting link with MTID', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://cisco.webex.com/cisco/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return true for valid join meeting link without cisco domain', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return false for an invalid meeting link', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MiD=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.false;
+      });
+    });
   });
 });

package/test/unit/spec/meetings/index.js

@@ -37,11 +37,13 @@ import {
   LOCUSINFO,
   EVENT_TRIGGERS,
   DESTINATION_TYPE,
+  INITIAL_REGISTRATION_STATUS,
 } from '../../../../src/constants';
 import CaptchaError from '@webex/plugin-meetings/src/common/errors/captcha-error';
 import {forEach} from 'lodash';
 import PasswordError from '@webex/plugin-meetings/src/common/errors/password-error';
 import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
+import JoinForbiddenError from '@webex/plugin-meetings/src/common/errors/join-forbidden-error';
 import {NoiseReductionEffect, VirtualBackgroundEffect} from '@webex/media-helpers';
 import NoMeetingInfoError from '../../../../src/common/errors/no-meeting-info';
 
@@ -131,9 +133,9 @@ describe('plugin-meetings', () => {
         logger,
         people: {
           _getMe: sinon.stub().resolves({
-            type: 'validuser', 
+            type: 'validuser',
           }),
-        }
+        },
       });
 
       startReachabilityStub = sinon.stub(webex.meetings, 'startReachability').resolves();
@@ -267,6 +269,33 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_setLogUploadIntervalMultiplicationFactor', () => {
+      it('should have _setLogUploadIntervalMultiplicationFactor', () => {
+        assert.equal(typeof webex.meetings._setLogUploadIntervalMultiplicationFactor, 'function');
+      });
+
+      describe('success', () => {
+        it('should update the config', () => {
+          const someValue = 1.23;
+
+          webex.meetings._setLogUploadIntervalMultiplicationFactor(someValue);
+          assert.equal(webex.meetings.config.logUploadIntervalMultiplicationFactor, someValue);
+        });
+      });
+
+      describe('failure', () => {
+        it('should not accept non-number input', () => {
+          const logUploadIntervalMultiplicationFactor = webex.meetings.config.logUploadIntervalMultiplicationFactor;
+
+          webex.meetings._setLogUploadIntervalMultiplicationFactor('test');
+          assert.equal(
+            webex.meetings.config.logUploadIntervalMultiplicationFactor,
+            logUploadIntervalMultiplicationFactor
+          );
+        });
+      });
+    });
+
     describe('#_toggleUnifiedMeetings', () => {
       it('should have toggleUnifiedMeetings', () => {
         assert.equal(typeof webex.meetings._toggleUnifiedMeetings, 'function');
@@ -375,21 +404,21 @@ describe('plugin-meetings', () => {
           assert.isTrue(webex.meetings.registered);
         });
 
-        it('rejects when SDK canAuthorize is false', () => {
+        it('rejects when SDK canAuthorize is false', async () => {
           webex.canAuthorize = false;
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when device.register fails', () => {
+        it('rejects when device.register fails', async () => {
           webex.canAuthorize = true;
           webex.internal.device.register = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when mercury.connect fails', () => {
+        it('rejects when mercury.connect fails', async () => {
           webex.canAuthorize = true;
           webex.internal.mercury.connect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
         it('resolves immediately if already registered', async () => {
@@ -412,6 +441,19 @@ describe('plugin-meetings', () => {
           assert.isTrue(webex.meetings.registered);
         });
 
+        it('resolves even if startReachability() rejects', async () => {
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+          webex.meetings.startReachability = sinon.stub().rejects(new Error('fake error'));
+
+          await webex.meetings.register();
+          assert.calledOnceWithExactly(webex.internal.device.register, undefined);
+          assert.called(webex.internal.services.getMeetingPreferences);
+          assert.called(webex.internal.services.fetchClientRegionInfo);
+          assert.called(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
+        });
+
         it('passes on the device registration options', async () => {
           webex.canAuthorize = true;
           webex.meetings.registered = false;
@@ -420,6 +462,100 @@ describe('plugin-meetings', () => {
             includeDetails: CatalogDetails.features,
           });
         });
+
+        it('updates registration status as expected', async () => {
+          const clock = sinon.useFakeTimers();
+
+          const delay = (secs) => () =>
+            new Promise((resolve) => {
+              setTimeout(resolve, secs * 1000);
+            });
+
+          let i = 1;
+          sinon.stub(webex.meetings, 'fetchUserPreferredWebexSite').callsFake(delay(i++));
+          MeetingsUtil.checkH264Support.callsFake(delay(i++));
+          webex.meetings.startReachability.callsFake(delay(i++));
+          webex.internal.device.register.callsFake(delay(i++));
+          sinon.stub(webex.meetings, 'getGeoHint').callsFake(delay(i++));
+          webex.internal.mercury.connect.callsFake(delay(i++));
+
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+
+          const registerPromise = webex.meetings.register({
+            includeDetails: CatalogDetails.features,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.fetchUserPreferredWebexSite;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: false,
+          });
+
+          await clock.tick(1000);
+          await MeetingsUtil.checkH264Support;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.startReachability;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.internal.device.register;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.getGeoHint;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(6000);
+          await webex.internal.mercury.connect;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: true,
+            checkH264Support: true,
+          });
+
+          await registerPromise;
+
+          clock.restore();
+        });
       });
 
       describe('#unregister', () => {
@@ -440,27 +576,36 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('rejects when device.unregister fails', () => {
+        it('rejects when device.unregister fails', async () => {
           webex.meetings.registered = true;
           webex.internal.device.unregister = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('rejects when mercury.disconnect fails', () => {
+        it('rejects when mercury.disconnect fails', async () => {
           webex.meetings.registered = true;
           webex.internal.mercury.disconnect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('resolves immediately if already registered', (done) => {
+        it('resolves immediately if not registered', (done) => {
           webex.meetings.registered = false;
           webex.meetings.unregister().then(() => {
-            assert.notCalled(webex.internal.device.register);
-            assert.notCalled(webex.internal.mercury.connect);
+            assert.notCalled(webex.internal.device.unregister);
+            assert.notCalled(webex.internal.mercury.disconnect);
             assert.isFalse(webex.meetings.registered);
             done();
           });
         });
+
+        it('resets registration status', (done) => {
+          webex.meetings.registered = true;
+          webex.meetings.registrationStatus = {foo: 'bar'};
+          webex.meetings.unregister().then(() => {
+            assert.deepEqual(webex.meetings.registrationStatus, INITIAL_REGISTRATION_STATUS);
+            done();
+          });
+        });
       });
 
       describe('virtual background effect', () => {
@@ -1921,6 +2066,11 @@ describe('plugin-meetings', () => {
                 debugLogMessage:
                   'Meetings:index#createMeeting --> Debug PermissionError: Not allowed to execute the function, some properties on server, or local client state do not allow you to complete this action. fetching /meetingInfo for creation.',
               },
+              {
+                error: new JoinForbiddenError(),
+                debugLogMessage:
+                  'Meetings:index#createMeeting --> Debug JoinForbiddenError: Meeting join forbidden. fetching /meetingInfo for creation.',
+              },
               {
                 error: new Error(),
                 infoLogMessage: true,
@@ -1985,6 +2135,8 @@ describe('plugin-meetings', () => {
             const meetingIds = {
               meetingId: meeting.id,
               correlationId: meeting.correlationId,
+              roles: meeting.roles,
+              callStateForMetrics: meeting.callStateForMetrics,
             };
 
             webex.meetings.destroy(meeting, test1);
@@ -2021,6 +2173,8 @@ describe('plugin-meetings', () => {
 
             assert.equal(deletedMeetingInfo.id, meetingIds.meetingId);
             assert.equal(deletedMeetingInfo.correlationId, meetingIds.correlationId);
+            assert.equal(deletedMeetingInfo.roles, meetingIds.roles);
+            assert.equal(deletedMeetingInfo.callStateForMetrics, meetingIds.callStateForMetrics);
           });
         });
 
@@ -2092,7 +2246,7 @@ describe('plugin-meetings', () => {
           );
         });
 
-        const setup = ({me = { type: 'validuser'}, user} = {}) => {
+        const setup = ({me = {type: 'validuser'}, user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
 
@@ -2113,9 +2267,9 @@ describe('plugin-meetings', () => {
 
         it('should not call request.getMeetingPreferences if user is a guest', async () => {
           setup({me: {type: 'appuser'}});
-      
+
           await webex.meetings.fetchUserPreferredWebexSite();
-      
+
           assert.equal(webex.meetings.preferredWebexSite, '');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
           assert.notCalled(webex.internal.services.getMeetingPreferences);

package/test/unit/spec/meetings/utils.js

@@ -290,4 +290,14 @@ describe('plugin-meetings', () => {
       assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), true);
     });
   });
+
+  describe('#getMediaServer', () => {
+    it('returns the contents of o-line lower cased', () => {
+      const sdp1 = 'v=0\r\no=homer 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
+      assert.equal(MeetingsUtil.getMediaServer(sdp1), 'homer');
+
+      const sdp2 = 'v=0\r\no=HOMER 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
+      assert.equal(MeetingsUtil.getMediaServer(sdp2), 'homer');
+    });
+  })
 });

package/test/unit/spec/member/util.js

@@ -5,13 +5,13 @@ import {_SEND_RECEIVE_, _RECEIVE_ONLY_} from '../../../../src/constants';
 
 describe('plugin-meetings', () => {
   describe('isHandRaised', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isHandRaised();
       }, 'Raise hand could not be processed, participant is undefined.');
     });
 
-    it('returns false when controls is not there', () => {
+    it('returns false when controls are not present', () => {
       const participant = {};
 
       assert.isFalse(MemberUtil.isHandRaised(participant));
@@ -51,7 +51,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.canReclaimHost', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.canReclaimHost();
       }, 'canReclaimHostRole could not be processed, participant is undefined.');
@@ -352,8 +352,49 @@ describe('plugin-meetings', () => {
     });
   });
 
+  describe('MemberUtil.isBrb', () => {
+    it('returns true when brb is enabled', () => {
+      const participant = {
+        controls: {
+          brb: {
+            enabled: true,
+          },
+        },
+      };
+
+      assert.isTrue(MemberUtil.isBrb(participant));
+    });
+
+    it('returns false when brb is disabled', () => {
+      const participant = {
+        controls: {
+          brb: {
+            enabled: false,
+          },
+        },
+      };
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+
+
+    it('returns false when brb is not present', () => {
+      const participant = {
+        controls: {},
+      };
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+
+    it('returns false when controls is not present', () => {
+      const participant = {};
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+  });
+
   describe('MemberUtil.isBreakoutsSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isBreakoutsSupported();
       }, 'Breakout support could not be processed, participant is undefined.');
@@ -377,7 +418,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isLiveAnnotationSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isLiveAnnotationSupported();
       }, 'LiveAnnotation support could not be processed, participant is undefined.');
@@ -401,7 +442,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isInterpretationSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isInterpretationSupported();
       }, 'Interpretation support could not be processed, participant is undefined.');
@@ -432,7 +473,7 @@ describe('plugin-meetings', () => {
   };
 
   describe('MemberUtil.isAudioMuted', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isAudioMuted();
       }, 'Audio could not be processed, participant is undefined.');
@@ -475,7 +516,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isVideoMuted', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isVideoMuted();
       }, 'Video could not be processed, participant is undefined.');
@@ -519,7 +560,7 @@ describe('plugin-meetings', () => {
 });
 
 describe('extractMediaStatus', () => {
-  it('throws error when there is no participant', () => {
+  it('throws an error when there is no participant', () => {
     assert.throws(() => {
       MemberUtil.extractMediaStatus()
     }, 'Media status could not be extracted, participant is undefined.');
@@ -529,7 +570,7 @@ describe('extractMediaStatus', () => {
     const participant = {
       status: {}
     };
-    
+
     const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: undefined, video: undefined});
@@ -542,7 +583,7 @@ describe('extractMediaStatus', () => {
         videoStatus: 'SENDRECV'
       }
     };
-    
+
     const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: 'RECVONLY', video: 'SENDRECV'});

package/test/unit/spec/members/utils.js

@@ -262,5 +262,100 @@ describe('plugin-meetings', () => {
         testParams(false);
       });
     });
+
+    describe('#getAddMemberBody', () => {
+      it('returns the correct body with email address and roles', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1', 'role2'],
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1', 'role2'],
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('returns the correct body with phone number and no roles', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
+      it('returns the correct body with fallback to email', () => {
+        const options = {
+          invitee: {
+            email: 'fallback@example.com',
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'fallback@example.com',
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('handles missing `alertIfActive` gracefully', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1'],
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1'],
+            },
+          ],
+          alertIfActive: undefined,
+        });
+      });
+
+      it('ignores roles if not provided', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+    });
   });
 });