versacall-core-library-react 2.0.70 → 2.0.71

package/dist/context/Channels/ChannelsConsumer.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _OrganizationChannel = _interopRequireDefault(require("./OrganizationChannel"));
+var _EveryoneChannel = _interopRequireDefault(require("./EveryoneChannel"));
+var _EntityChannel = _interopRequireDefault(require("./EntityChannel"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _UserChannel = _interopRequireDefault(require("./UserChannel"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+class ChannelsConsumer extends _react.Component {
+  componentDidMount() {
+    this.props.channels.registerHandlers(this.props.id, this.props.handler, this.props.connectionChanged, this.props.subscribing);
+  }
+  componentWillUnmount() {
+    this.props.channels.unregisterHandlers(this.props.id);
+  }
+  render() {
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, this.props.addDefaultChannels && /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_EveryoneChannel.default, null), /*#__PURE__*/_react.default.createElement(_UserChannel.default, null), /*#__PURE__*/_react.default.createElement(_OrganizationChannel.default, null), /*#__PURE__*/_react.default.createElement(_EntityChannel.default, null)), this.props.children);
+  }
+}
+ChannelsConsumer.propTypes = {
+  children: _propTypes.default.node,
+  id: _propTypes.default.string.isRequired,
+  handler: _propTypes.default.func.isRequired,
+  connectionChanged: _propTypes.default.func,
+  subscribing: _propTypes.default.func,
+  addDefaultChannels: _propTypes.default.bool,
+  channels: _propTypes.default.objectOf(_propTypes.default.func).isRequired
+};
+ChannelsConsumer.defaultProps = {
+  connectionChanged: null,
+  subscribing: null,
+  addDefaultChannels: true,
+  children: null
+};
+var _default = exports.default = (0, _withChannels.default)(ChannelsConsumer);

package/dist/context/Channels/ChannelsContext.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const ChannelsContext = /*#__PURE__*/_react.default.createContext();
+var _default = exports.default = ChannelsContext;

package/dist/context/Channels/ChannelsProvider.js

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _ChannelsContext = _interopRequireDefault(require("./ChannelsContext"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const namespace = 'ChannelsProvider';
+const emitter = require('emitter-io');
+const channelTimeoutHandlers = [];
+const channelInformation = [];
+const channelFunctions = [];
+const handlers = [];
+const connectionChangedHandlers = [];
+const subscribingHandlers = [];
+let client;
+function compareChannelInfo(ci1, ci2) {
+  if (ci1 !== null) {
+    if (ci2 !== null) {
+      if (ci1.channelKey === ci2.channelKey) {
+        if (ci1.channelName === ci2.channelName) {
+          return true;
+        }
+        return false;
+      }
+      return false;
+    }
+    return false;
+  }
+  if (ci2 !== null) {
+    return false;
+  }
+  return true;
+}
+const registerHandlers = (id, handler, connectionChanged, subscribing) => {
+  const existing = handlers.find(x => x.id === id);
+  if (existing !== undefined) {
+    existing.handler = handler;
+  } else {
+    handlers.push({
+      id: id,
+      handler: handler
+    });
+  }
+  if (connectionChanged) {
+    const existingConnectionChanged = connectionChangedHandlers.find(x => x.id === id);
+    if (existingConnectionChanged !== undefined) {
+      existingConnectionChanged.handler = connectionChanged;
+    } else {
+      connectionChangedHandlers.push({
+        id: id,
+        handler: connectionChanged
+      });
+    }
+  }
+  if (subscribing) {
+    const existingSubscribing = subscribingHandlers.find(x => x.id === id);
+    if (existingSubscribing !== undefined) {
+      existingSubscribing.handler = subscribing;
+    } else {
+      subscribingHandlers.push({
+        id: id,
+        handler: subscribing
+      });
+    }
+  }
+};
+const unregisterHandlers = id => {
+  const existing = handlers.find(x => x.id === id);
+  if (existing !== undefined) {
+    handlers.splice(handlers.indexOf(existing), 1);
+  }
+  const existingConnectionChanged = connectionChangedHandlers.find(x => x.id === id);
+  if (existingConnectionChanged !== undefined) {
+    connectionChangedHandlers.splice(connectionChangedHandlers.indexOf(existingConnectionChanged), 1);
+  }
+  const existingSubscribing = subscribingHandlers.find(x => x.id === id);
+  if (existingSubscribing !== undefined) {
+    subscribingHandlers.splice(subscribingHandlers.indexOf(existingSubscribing), 1);
+  }
+};
+const registerChannel = (id, channelFunction) => {
+  const existing = channelFunctions.find(x => x.id === id);
+  if (existing !== undefined) {
+    existing.channelFunction = data => channelFunction(data);
+  } else {
+    channelFunctions.push({
+      id: id,
+      channelFunction: data => channelFunction(data)
+    });
+  }
+};
+const isChannelRegistered = id => {
+  const existing = channelFunctions.find(x => x.id === id);
+  return existing !== undefined;
+};
+const clearTimeoutHandler = id => {
+  const existing = channelTimeoutHandlers.find(x => x.id === id);
+  if (existing !== undefined) {
+    clearTimeout(existing.handler);
+    channelTimeoutHandlers.splice(channelTimeoutHandlers.indexOf(existing), 1);
+  }
+};
+const processMessage = (channel, obj) => {
+  handlers.forEach(x => {
+    x.handler(channel, obj);
+  });
+};
+const notifyConnectionChanged = connected => {
+  connectionChangedHandlers.forEach(x => {
+    x.handler(connected);
+  });
+};
+const notifySubscribing = channel => {
+  subscribingHandlers.forEach(x => {
+    x.handler(channel);
+  });
+};
+class ChannelsProvider extends _react.Component {
+  constructor(props) {
+    const methodName = 'constructor()';
+    super(props);
+    this.state = {
+      connected: true
+    };
+    const urlArray = props.core.baseUrl.split('://');
+    const modifiedUrl = urlArray[urlArray.length - 1];
+    client = emitter.connect({
+      host: modifiedUrl,
+      port: 9090,
+      secure: true
+    });
+    client.on('connect', conack => {
+      this.props.core.log('system', namespace, methodName, 'Emitter Connect', conack);
+      if (this.state.connected === false) {
+        this.resubscribeToChannels();
+        this.setState({
+          connected: true
+        });
+        notifyConnectionChanged(true);
+      }
+    });
+    client.on('disconnect', () => {
+      this.props.core.log('system', namespace, methodName, 'Emitter Disconnect');
+      if (this.state.connected === true) {
+        this.setState({
+          connected: false
+        });
+        notifyConnectionChanged(false);
+      }
+    });
+    client.on('offline', () => {
+      this.props.core.log('system', namespace, methodName, 'Emitter Offline');
+      if (this.state.connected === true) {
+        this.setState({
+          connected: false
+        });
+        notifyConnectionChanged(false);
+      }
+    });
+    client.on('message', msg => {
+      processMessage(msg.channel, JSON.parse(msg.asString()));
+    });
+    client.on('error', error => {
+      this.props.core.log('error', namespace, methodName, error);
+    });
+  }
+  updateChannel(id, data) {
+    const existing = channelTimeoutHandlers.find(x => x.id === id);
+    if (existing !== undefined) {
+      clearTimeout(existing.handler);
+      existing.handler = setTimeout(() => {
+        this.callChannelFunction(id, data);
+      }, 500);
+    } else {
+      channelTimeoutHandlers.push({
+        id: id,
+        handler: setTimeout(() => {
+          this.callChannelFunction(id, data);
+        }, 500)
+      });
+    }
+  }
+  callChannelFunction(id, data) {
+    const methodName = 'callChannelFunction()';
+    clearTimeoutHandler(id);
+    const existingFunction = channelFunctions.find(x => x.id === id);
+    if (existingFunction !== undefined) {
+      existingFunction.channelFunction(data).then(channelInfo => {
+        if (channelInfo != null) {
+          let channelInfoChanged = true;
+          const existingChannelInfo = channelInformation.find(x => x.id === id);
+          if (existingChannelInfo !== undefined) {
+            if (!compareChannelInfo(channelInfo, existingChannelInfo.channelInfo)) {
+              this.unsubscribe(existingChannelInfo.channelInfo);
+              existingChannelInfo.channelInfo = channelInfo;
+            } else {
+              channelInfoChanged = false;
+            }
+          } else {
+            channelInformation.push({
+              id: id,
+              channelInfo: channelInfo
+            });
+          }
+          if (channelInfoChanged) {
+            this.subscribe(channelInfo);
+          }
+        }
+      }).catch(error => {
+        this.props.core.log('error', namespace, methodName, error);
+      });
+    }
+  }
+  subscribe(channelInfo) {
+    const methodName = 'subscribe()';
+    this.props.core.log('system', namespace, methodName, "Subscribing to ".concat(channelInfo.channelName));
+    client.subscribe({
+      key: channelInfo.channelKey,
+      channel: channelInfo.channelName
+    });
+    notifySubscribing(channelInfo.channelName);
+  }
+  unsubscribe(channelInfo) {
+    const methodName = 'unsubscribe()';
+    this.props.core.log('system', namespace, methodName, "Unsubscribing from ".concat(channelInfo.channelName));
+    client.unsubscribe({
+      key: channelInfo.channelKey,
+      channel: channelInfo.channelName
+    });
+  }
+  resubscribeToChannels() {
+    channelInformation.forEach((item, i) => {
+      this.subscribe(item.channelInfo);
+    });
+  }
+  render() {
+    return /*#__PURE__*/_react.default.createElement(_ChannelsContext.default.Provider, {
+      value: {
+        unregisterHandlers: id => unregisterHandlers(id),
+        isChannelRegistered: id => isChannelRegistered(id),
+        updateChannel: (id, data) => this.updateChannel(id, data),
+        registerHandlers: (id, handler, connectionChanged, subscribing) => registerHandlers(id, handler, connectionChanged, subscribing),
+        registerChannel: (id, channelFunction) => registerChannel(id, channelFunction)
+      }
+    }, this.props.children);
+  }
+}
+ChannelsProvider.propTypes = {
+  children: _propTypes.default.node.isRequired,
+  core: _propTypes.default.shape().isRequired
+};
+var _default = exports.default = (0, _withCore.default)(ChannelsProvider);

package/dist/context/Channels/DataChannel.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _withAuthentication = _interopRequireDefault(require("../Authentication/withAuthentication"));
+var _withOrganization = _interopRequireDefault(require("../Organization/withOrganization"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const namespace = 'DataChannel';
+const channelId = 'data';
+class DataChannel extends _react.Component {
+  componentDidMount() {
+    if (!this.props.channels.isChannelRegistered(channelId)) {
+      this.props.channels.registerChannel(channelId, data => this.channelFunction(data));
+      if (this.props.organization.entity !== null) {
+        this.props.channels.updateChannel(channelId, {
+          entityId: this.props.organization.entity.id
+        });
+      }
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.organization.entity !== prevProps.organization.entity) {
+      this.props.channels.updateChannel(channelId, {
+        entityId: this.props.organization.entity.id
+      });
+    }
+  }
+  channelFunction(data) {
+    const methodName = 'channelFunction()';
+    return new Promise((resolve, reject) => {
+      if (this.props.authentication.authenticated) {
+        this.props.authentication.http({
+          method: 'get',
+          url: "".concat(this.props.core.baseUrl, "/api/data/subscribe/").concat(data.entityId)
+        }).then(results => {
+          resolve(results.data);
+        }).catch(error => {
+          this.props.core.log('error', namespace, methodName, error);
+          reject(error);
+        });
+      } else {
+        reject(new Error({
+          message: 'Not Authenticated'
+        }));
+      }
+    });
+  }
+  render() {
+    return '';
+  }
+}
+DataChannel.propTypes = {
+  core: _propTypes.default.shape().isRequired,
+  organization: _propTypes.default.shape().isRequired,
+  authentication: _propTypes.default.shape().isRequired,
+  channels: _propTypes.default.shape({
+    updateChannel: _propTypes.default.func,
+    registerChannel: _propTypes.default.func,
+    isChannelRegistered: _propTypes.default.func
+  }).isRequired
+};
+var _default = exports.default = (0, _withChannels.default)((0, _withCore.default)((0, _withAuthentication.default)((0, _withOrganization.default)(DataChannel))));

package/dist/context/Channels/EntityChannel.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _withAuthentication = _interopRequireDefault(require("../Authentication/withAuthentication"));
+var _withOrganization = _interopRequireDefault(require("../Organization/withOrganization"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const namespace = 'EntityChannel';
+const channelId = 'entity';
+class EntityChannel extends _react.Component {
+  componentDidMount() {
+    if (!this.props.channels.isChannelRegistered(channelId)) {
+      this.props.channels.registerChannel(channelId, data => this.channelFunction(data));
+      if (this.props.organization.entity !== null) {
+        this.props.channels.updateChannel(channelId, {
+          entityId: this.props.organization.entity.id
+        });
+      }
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.organization.entity !== prevProps.organization.entity) {
+      this.props.channels.updateChannel(channelId, {
+        entityId: this.props.organization.entity.id
+      });
+    }
+  }
+  channelFunction(data) {
+    const methodName = 'channelFunction()';
+    return new Promise((resolve, reject) => {
+      if (this.props.authentication.authenticated) {
+        this.props.authentication.http({
+          method: 'get',
+          url: "".concat(this.props.core.baseUrl, "/api/administration/entities/subscribe"),
+          params: data
+        }).then(results => {
+          resolve(results.data);
+        }).catch(error => {
+          this.props.core.log('error', namespace, methodName, error);
+          reject(error);
+        });
+      } else {
+        reject(new Error({
+          message: 'Not Authenticated'
+        }));
+      }
+    });
+  }
+  render() {
+    return '';
+  }
+}
+EntityChannel.propTypes = {
+  core: _propTypes.default.shape().isRequired,
+  organization: _propTypes.default.shape().isRequired,
+  authentication: _propTypes.default.shape().isRequired,
+  channels: _propTypes.default.shape({
+    updateChannel: _propTypes.default.func,
+    registerChannel: _propTypes.default.func,
+    isChannelRegistered: _propTypes.default.func
+  }).isRequired
+};
+var _default = exports.default = (0, _withChannels.default)((0, _withCore.default)((0, _withAuthentication.default)((0, _withOrganization.default)(EntityChannel))));

package/dist/context/Channels/EveryoneChannel.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _withAuthentication = _interopRequireDefault(require("../Authentication/withAuthentication"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const namespace = 'EveryoneChannel';
+const channelId = 'everyone';
+class EveryoneChannel extends _react.Component {
+  componentDidMount() {
+    if (!this.props.channels.isChannelRegistered(channelId)) {
+      this.props.channels.registerChannel(channelId, data => this.channelFunction(data));
+      this.props.channels.updateChannel(channelId, null);
+    }
+  }
+  channelFunction() {
+    const methodName = 'channelFunction()';
+    return new Promise((resolve, reject) => {
+      if (this.props.authentication.authenticated) {
+        this.props.authentication.http({
+          method: 'get',
+          url: "".concat(this.props.core.baseUrl, "/api/administration/everyone/subscribe")
+        }).then(results => {
+          resolve(results.data);
+        }).catch(error => {
+          this.props.core.log('error', namespace, methodName, error);
+          reject(error);
+        });
+      } else {
+        reject(new Error({
+          message: 'Not Authenticated'
+        }));
+      }
+    });
+  }
+  render() {
+    return '';
+  }
+}
+EveryoneChannel.propTypes = {
+  core: _propTypes.default.shape().isRequired,
+  authentication: _propTypes.default.shape().isRequired,
+  channels: _propTypes.default.shape({
+    updateChannel: _propTypes.default.func,
+    registerChannel: _propTypes.default.func,
+    isChannelRegistered: _propTypes.default.func
+  }).isRequired
+};
+var _default = exports.default = (0, _withChannels.default)((0, _withAuthentication.default)((0, _withCore.default)(EveryoneChannel)));

package/dist/context/Channels/OrganizationChannel.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _withAuthentication = _interopRequireDefault(require("../Authentication/withAuthentication"));
+var _withOrganization = _interopRequireDefault(require("../Organization/withOrganization"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const namespace = 'OrganizationChannel';
+const channelId = 'organization';
+class OrganizationChannel extends _react.Component {
+  componentDidMount() {
+    if (!this.props.channels.isChannelRegistered(channelId)) {
+      this.props.channels.registerChannel(channelId, data => this.channelFunction(data));
+      if (this.props.organization.organization !== null) {
+        this.props.channels.updateChannel(channelId, {
+          organizationId: this.props.organization.organization.id
+        });
+      }
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.organization.organization !== prevProps.organization.organization) {
+      this.props.channels.updateChannel(channelId, {
+        organizationId: this.props.organization.organization.id
+      });
+    }
+  }
+  channelFunction(data) {
+    const methodName = 'channelFunction()';
+    return new Promise((resolve, reject) => {
+      if (this.props.authentication.authenticated) {
+        this.props.authentication.http({
+          method: 'get',
+          url: "".concat(this.props.core.baseUrl, "/api/administration/organizations/subscribe"),
+          params: data
+        }).then(results => {
+          resolve(results.data);
+        }).catch(error => {
+          this.props.core.log('error', namespace, methodName, error);
+          reject(error);
+        });
+      } else {
+        reject(new Error({
+          message: 'Not Authenticated'
+        }));
+      }
+    });
+  }
+  render() {
+    return '';
+  }
+}
+OrganizationChannel.propTypes = {
+  core: _propTypes.default.shape().isRequired,
+  organization: _propTypes.default.shape().isRequired,
+  authentication: _propTypes.default.shape().isRequired,
+  channels: _propTypes.default.shape({
+    updateChannel: _propTypes.default.func,
+    registerChannel: _propTypes.default.func,
+    isChannelRegistered: _propTypes.default.func
+  }).isRequired
+};
+var _default = exports.default = (0, _withChannels.default)((0, _withCore.default)((0, _withAuthentication.default)((0, _withOrganization.default)(OrganizationChannel))));

package/dist/context/Channels/README.md

@@ -0,0 +1,52 @@
+# Channels Context
+
+This adds the capability to communicate with emitter channels.  Typically implemented by adding [CoreWrapper](../../components/CoreWrapper) though it can be added by adding ChannelsProvider directly.
+
+To utilize this you need to add ChannelsConsumer to your component:
+
+```
+processMessage(channel, obj) {
+  if (obj.what !== undefined) {
+    if (obj.what === 'package_enabled') {
+      this.refreshPackages();
+    }
+  }
+}
+
+connectionChanged(connected) {
+  if (connected) {
+    console.log('We are connected');
+    } else {
+      console.log('We are disconnected');
+    }
+  }
+  
+  render() {
+    return (
+      <div>
+      <ChannelsConsumer
+      id="mycomponent"
+      handler={(channel, obj) => this.processMessage(channel, obj)}
+      connectionChanged={connected => this.connectionChanged(connected)}
+      addDefaultChannels
+      />
+      </div>
+      );
+    }
+    ```
+    
+    ## ChannelConsumer Props
+    - id : This is a unique id inside your application to represent your component.  It is used to map handlers.
+    - handler : This is function that is called when something is received on a channel.
+    - connectionChanged : This is a function that is called when the connection changed.  NOTE: It is not called initially.  Assume that we started connected.  It will notify when the connection is dropped and re-connected.
+    - addDefaultChannels : If true (default), adds the default channels: EveryoneChannel, UserChannel, OrganizationChannel, EntityChannel
+    
+    ## Available functions
+    These are functions available once adding HOC withChannels to your application.  These are typically only used inside a Channel component.  Most application components should be using a Channel component to speak to a channel.
+    
+    ### registerHandlers(id, handler, connectionChanged)
+    ### unregisterHandlers(id)
+    ### registerChannel(id, channelFunction)
+    ### updateChannel(id, data)
+    ### isChannelRegistered(id)
+    

package/dist/context/Channels/UserChannel.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _withAuthentication = _interopRequireDefault(require("../Authentication/withAuthentication"));
+var _withChannels = _interopRequireDefault(require("./withChannels"));
+var _withCore = _interopRequireDefault(require("../Core/withCore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const namespace = 'UserChannel';
+const channelId = 'user';
+class UserChannel extends _react.Component {
+  componentDidMount() {
+    if (!this.props.channels.isChannelRegistered(channelId)) {
+      this.props.channels.registerChannel(channelId, data => this.channelFunction(data));
+      this.props.channels.updateChannel(channelId, null);
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.props.authentication.didChange(prevProps.authentication)) {
+      this.props.channels.updateChannel(channelId, null);
+    }
+  }
+  channelFunction() {
+    const methodName = 'channelFunction()';
+    return new Promise((resolve, reject) => {
+      if (this.props.authentication.authenticated) {
+        this.props.authentication.http({
+          method: 'get',
+          url: "".concat(this.props.core.baseUrl, "/api/administration/users/subscribe")
+        }).then(results => {
+          resolve(results.data);
+        }).catch(error => {
+          this.props.core.log('error', namespace, methodName, error);
+          reject(error);
+        });
+      } else {
+        reject(new Error({
+          message: 'Not Authenticated'
+        }));
+      }
+    });
+  }
+  render() {
+    return '';
+  }
+}
+UserChannel.propTypes = {
+  core: _propTypes.default.shape().isRequired,
+  authentication: _propTypes.default.shape().isRequired,
+  channels: _propTypes.default.shape({
+    updateChannel: _propTypes.default.func,
+    registerChannel: _propTypes.default.func,
+    isChannelRegistered: _propTypes.default.func
+  }).isRequired
+};
+var _default = exports.default = (0, _withChannels.default)((0, _withCore.default)((0, _withAuthentication.default)(UserChannel)));