@webex/plugin-meetings 3.7.0 → 3.8.0

package/test/unit/spec/webinar/index.ts

@@ -2,6 +2,7 @@ import {assert, expect} from '@webex/test-helper-chai';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import Webinar from '@webex/plugin-meetings/src/webinar';
 import MockWebex from '@webex/test-helper-mock-webex';
+import uuid from 'uuid';
 import sinon from 'sinon';
 
 describe('plugin-meetings', () => {
@@ -9,16 +10,27 @@ describe('plugin-meetings', () => {
 
         let webex;
         let webinar;
+        let uuidStub;
+        let getUserTokenStub;
 
         beforeEach(() => {
             // @ts-ignore
+            getUserTokenStub = sinon.stub().resolves('test-token');
+            uuidStub = sinon.stub(uuid,'v4').returns('test-uuid');
             webex = new MockWebex({});
             webex.internal.mercury.on = sinon.stub();
             webinar = new Webinar({}, {parent: webex});
             webinar.locusUrl = 'locusUrl';
+            webinar.webcastInstanceUrl = 'webcastInstanceUrl';
             webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
             webex.meetings = {};
+            webex.credentials.getUserToken = getUserTokenStub;
             webex.meetings.getMeetingByType = sinon.stub();
+
+        });
+
+        afterEach(() => {
+          sinon.restore();
         });
 
         describe('#locusUrlUpdate', () => {
@@ -91,6 +103,21 @@ describe('plugin-meetings', () => {
           assert.equal(result.isDemoted, true, 'should indicate demotion');
         });
 
+        it('updates roles when attendee just join meeting', () => {
+          const payload = {
+            oldRoles: [''],
+            newRoles: ['ATTENDEE']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, true, 'self should be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, true, 'should indicate demotion');
+        });
+
         it('updates roles when promoted to moderator', () => {
           const payload = {
             oldRoles: ['PANELIST'],
@@ -122,5 +149,482 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#updateStatusByRole', () => {
+        let updateLLMConnection;
+        let updateMediaShares;
+        beforeEach(() => {
+          // @ts-ignore
+          updateLLMConnection = sinon.stub();
+          updateMediaShares = sinon.stub()
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              updateLLMConnection: updateLLMConnection,
+              shareStatus: 'whiteboard_share_active',
+              locusInfo: {
+                mediaShares: 'mediaShares',
+                updateMediaShares: updateMediaShares
+              }
+            })
+          };
+        });
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        it('trigger updateLLMConnection if PS started', () => {
+
+          webinar.practiceSessionEnabled = true;
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.calledOnce(updateLLMConnection);
+        });
+
+        it('Not trigger updateLLMConnection if PS not started', () => {
+
+          webinar.practiceSessionEnabled = false;
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.notCalled(updateLLMConnection);
+        });
+
+        it('trigger updateMediaShares if promoted', () => {
+
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.calledOnce(updateMediaShares);
+        });
+
+        it('Not trigger updateMediaShares if no role change', () => {
+
+          const roleChange = {isPromoted: false, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.notCalled(updateMediaShares);
+        });
+        it('trigger updateMediaShares if is promoted', () => {
+
+          const roleChange = {isPromoted: true, isDemoted: false};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.calledOnce(updateMediaShares);
+        });
+
+        it('trigger updateMediaShares if is attendee with whiteboard share', () => {
+
+          const roleChange = {isPromoted: false, isDemoted: true};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.calledOnce(updateMediaShares);
+        });
+
+        it('Not trigger updateMediaShares if is attendee with screen share', () => {
+
+          webinar.webex.meetings = {
+            getMeetingByType: sinon.stub().returns({
+              id: 'meeting-id',
+              updateLLMConnection: updateLLMConnection,
+              shareStatus: 'remote_share_active',
+              locusInfo: {
+                mediaShares: 'mediaShares',
+                updateMediaShares: updateMediaShares
+              }
+            })
+          };
+
+          const roleChange = {isPromoted: false, isDemoted: true};
+
+          const result = webinar.updateStatusByRole(roleChange);
+
+          assert.notCalled(updateMediaShares);
+        });
+      });
+
+      describe("#setPracticeSessionState", () => {
+        [true, false].forEach((enabled) => {
+          it(`sends a PATCH request to ${enabled ? "enable" : "disable"} the practice session`, async () => {
+            const result = await webinar.setPracticeSessionState(enabled);
+            assert.calledOnce(webex.request);
+            assert.calledWith(webex.request, {
+              method: "PATCH",
+              uri: `${webinar.locusUrl}/controls`,
+              body: {
+                practiceSession: { enabled }
+              }
+            });
+            assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+          });
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.setPracticeSessionState(true);
+            assert.fail('setPracticeSessionState should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#setPracticeSessionState failed', sinon.match.instanceOf(Error));
+          }
+
+          errorLogger.restore();
+        });
+      });
+
+      describe('#isJoinPracticeSessionDataChannel', () => {
+        it('check whether should join PS data channel', () => {
+          webinar.selfIsPanelist = true;
+          webinar.practiceSessionEnabled = false;
+
+          assert.equal(webinar.isJoinPracticeSessionDataChannel(), false);
+
+          webinar.selfIsPanelist = true;
+          webinar.practiceSessionEnabled = true;
+
+          assert.equal(webinar.isJoinPracticeSessionDataChannel(), true);
+
+          webinar.selfIsPanelist = false;
+          webinar.practiceSessionEnabled = false;
+
+          assert.equal(webinar.isJoinPracticeSessionDataChannel(), false);
+
+          webinar.selfIsPanelist = false;
+          webinar.practiceSessionEnabled = true;
+
+          assert.equal(webinar.isJoinPracticeSessionDataChannel(), false);
+        });
+      });
+
+      describe('#updatePracticeSessionStatus', () => {
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: true});
+
+          assert.equal(webinar.practiceSessionEnabled, true);
+        });
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: false});
+
+          assert.equal(webinar.practiceSessionEnabled, false);
+        });
+      });
+
+      describe("#startWebcast", () => {
+        const meeting = {
+          locusId: 'locusId',
+          correlationId: 'correlationId',
+        }
+        const layout = {
+          videoLayout: 'Prominent',
+          contentLayout: 'Prominent',
+          syncStageLayout: false,
+          syncStageInMeeting: false,
+        }
+        it(`sends a PUT request to start the webcast`, async () => {
+          const result = await webinar.startWebcast(meeting, layout);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/streaming`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              action: 'start',
+              meetingInfo: {
+                locusId: meeting.locusId,
+                correlationId: meeting.correlationId,
+              },
+              layout,
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('should handle undefined meeting parameter', async () => {
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.startWebcast(undefined, layout);
+            assert.fail('startWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'Meeting parameter does not meet expectations', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, `Meeting:webinar#startWebcast failed --> meeting parameter : ${undefined}`);
+          } finally {
+            errorLogger.restore();
+          }
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.startWebcast(meeting, layout);
+            assert.fail('startWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#startWebcast failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+      describe("#stopWebcast", () => {
+        it(`sends a PUT request to stop the webcast`, async () => {
+          const result = await webinar.stopWebcast();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/streaming`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              action: 'stop',
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.stopWebcast();
+            assert.fail('stopWebcast should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#stopWebcast failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+
+      describe("#queryWebcastLayout", () => {
+        it(`sends a GET request to query the webcast layout`, async () => {
+          const result = await webinar.queryWebcastLayout();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/layout`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.queryWebcastLayout();
+            assert.fail('queryWebcastLayout should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#queryWebcastLayout failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+      describe("#updateWebcastLayout", () => {
+        const layout = {
+          videoLayout: 'Prominent',
+          contentLayout: 'Prominent',
+          syncStageLayout: false,
+          syncStageInMeeting: false,
+        }
+        it(`sends a PUT request to update the webcast layout`, async () => {
+          const result = await webinar.updateWebcastLayout(layout);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "PUT",
+            uri: `${webinar.webcastInstanceUrl}/layout`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+              'Content-Type': 'application/json'
+            },
+            body: {
+              ...layout
+            }
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.updateWebcastLayout(layout);
+            assert.fail('updateWebcastLayout should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#updateWebcastLayout failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+      describe("#searchWebcastAttendees", () => {
+        const queryString = 'queryString';
+        const specialCharsQuery = 'query@string!';
+        const emptyQuery = '';
+
+        it("sends a GET request to search the webcast attendees", async () => {
+          const result = await webinar.searchWebcastAttendees(queryString);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(queryString)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.searchWebcastAttendees(queryString);
+            assert.fail('searchWebcastAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#searchWebcastAttendees failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+
+        it("should handle empty query string", async () => {
+          const result = await webinar.searchWebcastAttendees(emptyQuery);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(emptyQuery)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it("should handle query string with special characters", async () => {
+          const result = await webinar.searchWebcastAttendees(specialCharsQuery);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees?keyword=${encodeURIComponent(specialCharsQuery)}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+      });
+
+
+      describe("#viewAllWebcastAttendees", () => {
+        it(`sends a GET request to view all the webcast attendees`, async () => {
+          const result = await webinar.viewAllWebcastAttendees();
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            uri: `${webinar.webcastInstanceUrl}/attendees`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.viewAllWebcastAttendees();
+            assert.fail('viewAllWebcastAttendees should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#viewAllWebcastAttendees failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
+
+      describe("#expelWebcastAttendee", () => {
+        const participantId = 'participantId'
+        it(`sends a DELETE request to expel the webcast attendee`, async () => {
+          const result = await webinar.expelWebcastAttendee(participantId);
+          assert.calledOnce(webex.request);
+          assert.calledWith(webex.request, {
+            method: "DELETE",
+            uri: `${webinar.webcastInstanceUrl}/attendees/${participantId}`,
+            headers: {
+              authorization: 'test-token',
+              trackingId: 'webex-js-sdk_test-uuid',
+            },
+          });
+          assert.equal(result, "REQUEST_RETURN_VALUE", "should return the resolved value from the request");
+        });
+
+        it('handles API call failures gracefully', async () => {
+          webex.request.rejects(new Error('API_ERROR'));
+          const errorLogger = sinon.stub(LoggerProxy.logger, 'error');
+
+          try {
+            await webinar.expelWebcastAttendee(participantId);
+            assert.fail('expelWebcastAttendee should throw an error');
+          } catch (error) {
+            assert.equal(error.message, 'API_ERROR', 'should throw the correct error');
+            assert.calledOnce(errorLogger);
+            assert.calledWith(errorLogger, 'Meeting:webinar#expelWebcastAttendee failed', sinon.match.instanceOf(Error));
+          } finally {
+            errorLogger.restore();
+          }
+        });
+      });
     })
 })

package/dist/common/errors/webinar-registration-error.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_constants","require","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","_createSuperInternal","Super","_getPrototypeOf2","default","result","NewTarget","constructor","_Reflect$construct","arguments","apply","_possibleConstructorReturn2","Reflect","sham","Proxy","Boolean","prototype","valueOf","call","e","WebinarRegistrationError","exports","_Error","_inherits2","_super","_this","message","length","undefined","ERROR_DICTIONARY","MESSAGE","error","_classCallCheck2","_defineProperty2","_assertThisInitialized2","name","NAME","sdkMessage","stack","Error","code","CODE","_createClass2","_wrapNativeSuper2"],"sources":["webinar-registration-error.ts"],"sourcesContent":["import {ERROR_DICTIONARY} from '../../constants';\n\n/**\n * Error occurred while the webinar required registration\n */\nexport default class WebinarRegistrationError extends Error {\n  code: number;\n  error: any;\n  sdkMessage: string;\n\n  /**\n   * @constructor\n   * @param {String} [message]\n   * @param {Object} [error]\n   */\n  constructor(\n    message: string = ERROR_DICTIONARY.WebinarRegistrationError.MESSAGE,\n    error: any = null\n  ) {\n    super(message);\n    this.name = ERROR_DICTIONARY.WebinarRegistrationError.NAME;\n    this.sdkMessage = ERROR_DICTIONARY.WebinarRegistrationError.MESSAGE;\n    this.error = error;\n    this.stack = error ? error.stack : new Error().stack;\n    this.code = ERROR_DICTIONARY.WebinarRegistrationError.CODE;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAAiD,SAAAC,aAAAC,OAAA,QAAAC,yBAAA,GAAAC,yBAAA,oBAAAC,qBAAA,QAAAC,KAAA,OAAAC,gBAAA,CAAAC,OAAA,EAAAN,OAAA,GAAAO,MAAA,MAAAN,yBAAA,QAAAO,SAAA,OAAAH,gBAAA,CAAAC,OAAA,QAAAG,WAAA,EAAAF,MAAA,GAAAG,kBAAA,CAAAN,KAAA,EAAAO,SAAA,EAAAH,SAAA,YAAAD,MAAA,GAAAH,KAAA,CAAAQ,KAAA,OAAAD,SAAA,gBAAAE,2BAAA,CAAAP,OAAA,QAAAC,MAAA;AAAA,SAAAL,0BAAA,eAAAY,OAAA,qBAAAJ,kBAAA,oBAAAA,kBAAA,CAAAK,IAAA,2BAAAC,KAAA,oCAAAC,OAAA,CAAAC,SAAA,CAAAC,OAAA,CAAAC,IAAA,CAAAV,kBAAA,CAAAO,OAAA,8CAAAI,CAAA;AAEjD;AACA;AACA;AAFA,IAGqBC,wBAAwB,GAAAC,OAAA,CAAAjB,OAAA,0BAAAkB,MAAA;EAAA,IAAAC,UAAA,CAAAnB,OAAA,EAAAgB,wBAAA,EAAAE,MAAA;EAAA,IAAAE,MAAA,GAAA3B,YAAA,CAAAuB,wBAAA;EAK3C;AACF;AACA;AACA;AACA;EACE,SAAAA,yBAAA,EAGE;IAAA,IAAAK,KAAA;IAAA,IAFAC,OAAe,GAAAjB,SAAA,CAAAkB,MAAA,QAAAlB,SAAA,QAAAmB,SAAA,GAAAnB,SAAA,MAAGoB,2BAAgB,CAACT,wBAAwB,CAACU,OAAO;IAAA,IACnEC,KAAU,GAAAtB,SAAA,CAAAkB,MAAA,QAAAlB,SAAA,QAAAmB,SAAA,GAAAnB,SAAA,MAAG,IAAI;IAAA,IAAAuB,gBAAA,CAAA5B,OAAA,QAAAgB,wBAAA;IAEjBK,KAAA,GAAAD,MAAA,CAAAN,IAAA,OAAMQ,OAAO;IAAE,IAAAO,gBAAA,CAAA7B,OAAA,MAAA8B,uBAAA,CAAA9B,OAAA,EAAAqB,KAAA;IAAA,IAAAQ,gBAAA,CAAA7B,OAAA,MAAA8B,uBAAA,CAAA9B,OAAA,EAAAqB,KAAA;IAAA,IAAAQ,gBAAA,CAAA7B,OAAA,MAAA8B,uBAAA,CAAA9B,OAAA,EAAAqB,KAAA;IACfA,KAAA,CAAKU,IAAI,GAAGN,2BAAgB,CAACT,wBAAwB,CAACgB,IAAI;IAC1DX,KAAA,CAAKY,UAAU,GAAGR,2BAAgB,CAACT,wBAAwB,CAACU,OAAO;IACnEL,KAAA,CAAKM,KAAK,GAAGA,KAAK;IAClBN,KAAA,CAAKa,KAAK,GAAGP,KAAK,GAAGA,KAAK,CAACO,KAAK,GAAG,IAAIC,KAAK,CAAC,CAAC,CAACD,KAAK;IACpDb,KAAA,CAAKe,IAAI,GAAGX,2BAAgB,CAACT,wBAAwB,CAACqB,IAAI;IAAC,OAAAhB,KAAA;EAC7D;EAAC,WAAAiB,aAAA,CAAAtC,OAAA,EAAAgB,wBAAA;AAAA,oBAAAuB,iBAAA,CAAAvC,OAAA,EApBmDmC,KAAK"}

package/src/common/errors/webinar-registration-error.ts

@@ -1,27 +0,0 @@
-import {ERROR_DICTIONARY} from '../../constants';
-
-/**
- * Error occurred while the webinar required registration
- */
-export default class WebinarRegistrationError extends Error {
-  code: number;
-  error: any;
-  sdkMessage: string;
-
-  /**
-   * @constructor
-   * @param {String} [message]
-   * @param {Object} [error]
-   */
-  constructor(
-    message: string = ERROR_DICTIONARY.WebinarRegistrationError.MESSAGE,
-    error: any = null
-  ) {
-    super(message);
-    this.name = ERROR_DICTIONARY.WebinarRegistrationError.NAME;
-    this.sdkMessage = ERROR_DICTIONARY.WebinarRegistrationError.MESSAGE;
-    this.error = error;
-    this.stack = error ? error.stack : new Error().stack;
-    this.code = ERROR_DICTIONARY.WebinarRegistrationError.CODE;
-  }
-}