@webex/plugin-meetings 3.6.0-next.9 → 3.7.0-ipv6-multi-turn-urls.1

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,18 +10,28 @@ 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', () => {
             it('sets the locus url', () => {
                 webinar.locusUrlUpdate('newUrl');
@@ -29,32 +40,450 @@ describe('plugin-meetings', () => {
             });
         });
 
-        describe('#webcastUrlUpdate', () => {
-            it('sets the webcast url', () => {
-                webinar.webcastUrlUpdate('newUrl');
+        describe('#updateWebcastUrl', () => {
+            it('sets the webcast instance url', () => {
+                webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
 
-                assert.equal(webinar.webcastUrl, 'newUrl');
+                assert.equal(webinar.webcastInstanceUrl, 'newUrl');
             });
         });
 
-        describe('#webinarAttendeesSearchingUrlUpdate', () => {
-            it('sets the webinarAttendeesSearching url', () => {
-                webinar.webinarAttendeesSearchingUrlUpdate('newUrl');
 
-                assert.equal(webinar.webinarAttendeesSearchingUrl, 'newUrl');
+        describe('#updateCanManageWebcast', () => {
+          it('sets the webcast instance url when valid', () => {
+            webinar.updateWebcastUrl({resources: {webcastInstance: {url:'newUrl'}}});
+            assert.equal(webinar.webcastInstanceUrl, 'newUrl', 'webcast instance URL should be updated');
+          });
+
+          it('handles missing resources gracefully', () => {
+              webinar.updateWebcastUrl({});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+
+          it('handles missing webcastInstance gracefully', () => {
+              webinar.updateWebcastUrl({resources: {}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+
+          it('handles missing URL gracefully', () => {
+              webinar.updateWebcastUrl({resources: {webcastInstance: {}}});
+              assert.isUndefined(webinar.webcastInstanceUrl, 'webcast instance URL should be undefined');
+          });
+        });
+
+      describe('#updateRoleChanged', () => {
+        it('updates roles when promoted from attendee to panelist', () => {
+          const payload = {
+            oldRoles: ['ATTENDEE'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, false, 'self should not have manage webcast capability');
+          assert.equal(result.isPromoted, true, 'should indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when demoted from panelist to attendee', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            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'],
+            newRoles: ['MODERATOR']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, false, 'self should not be a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not be an attendee');
+          assert.equal(webinar.canManageWebcast, true, 'self should have manage webcast capability');
+          assert.equal(result.isPromoted, false, 'should not indicate promotion');
+          assert.equal(result.isDemoted, false, 'should not indicate demotion');
+        });
+
+        it('updates roles when unchanged (remains as panelist)', () => {
+          const payload = {
+            oldRoles: ['PANELIST'],
+            newRoles: ['PANELIST']
+          };
+
+          const result = webinar.updateRoleChanged(payload);
+
+          assert.equal(webinar.selfIsPanelist, true, 'self should remain a panelist');
+          assert.equal(webinar.selfIsAttendee, false, 'self should not 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, false, 'should not indicate demotion');
+        });
+      });
+
+      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");
+          });
         });
 
-        describe('#updateCanManageWebcast', () => {
-          it('update canManageWebcast', () => {
-            webinar.updateCanManageWebcast(true);
+        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));
+          }
 
-            assert.equal(webinar.canManageWebcast, true);
+          errorLogger.restore();
+        });
+      });
+
+      describe('#updatePracticeSessionStatus', () => {
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: true});
 
-            webinar.updateCanManageWebcast(false);
+          assert.equal(webinar.practiceSessionEnabled, true);
+        });
+        it('sets PS state true', () => {
+          webinar.updatePracticeSessionStatus({enabled: false});
 
-            assert.equal(webinar.canManageWebcast, 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;
-  }
-}