aspire_core/dist/Errors.js

Core api

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var SalesforceAuthError = exports.SalesforceAuthError = function (_Error) {
  _inherits(SalesforceAuthError, _Error);

  function SalesforceAuthError(err) {
    _classCallCheck(this, SalesforceAuthError);

    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(SalesforceAuthError).call(this, err));

    _this.type = "SFAuthError";
    _this.message = "Salesforce Auth failure " + err;
    _this.name = 'SalesforceAuthError';
    Error.captureStackTrace(_this, SalesforceAuthError);
    return _this;
  }

  return SalesforceAuthError;
}(Error);

var PhysicianGroupError = exports.PhysicianGroupError = function (_Error2) {
  _inherits(PhysicianGroupError, _Error2);

  function PhysicianGroupError(err) {
    _classCallCheck(this, PhysicianGroupError);

    var _this2 = _possibleConstructorReturn(this, Object.getPrototypeOf(PhysicianGroupError).call(this, err));

    _this2.type = "PhysicianGroupError";
    _this2.message = "Failed to process Physician Groups " + err;
    _this2.name = 'PhysicianGroupError';
    Error.captureStackTrace(_this2, PhysicianGroupError);
    return _this2;
  }

  return PhysicianGroupError;
}(Error);

var PhysicianPracticeError = exports.PhysicianPracticeError = function (_Error3) {
  _inherits(PhysicianPracticeError, _Error3);

  function PhysicianPracticeError(err) {
    _classCallCheck(this, PhysicianPracticeError);

    var _this3 = _possibleConstructorReturn(this, Object.getPrototypeOf(PhysicianPracticeError).call(this, err));

    _this3.type = "PhysicianPracticeError";
    _this3.message = "Failed to process Physician Practices " + err;
    _this3.name = 'PhysicianPracticeError';
    Error.captureStackTrace(_this3, PhysicianPracticeError);
    return _this3;
  }

  return PhysicianPracticeError;
}(Error);

var PatientError = exports.PatientError = function (_Error4) {
  _inherits(PatientError, _Error4);

  function PatientError(err) {
    _classCallCheck(this, PatientError);

    var _this4 = _possibleConstructorReturn(this, Object.getPrototypeOf(PatientError).call(this, err));

    _this4.type = "PatientError";
    _this4.message = "Failed to process PatientError " + err;
    _this4.name = 'PatientError';
    Error.captureStackTrace(_this4, PatientError);
    return _this4;
  }

  return PatientError;
}(Error);

var SFPhysicianPracticeError = exports.SFPhysicianPracticeError = function (_Error5) {
  _inherits(SFPhysicianPracticeError, _Error5);

  function SFPhysicianPracticeError(err) {
    _classCallCheck(this, SFPhysicianPracticeError);

    var _this5 = _possibleConstructorReturn(this, Object.getPrototypeOf(SFPhysicianPracticeError).call(this, err));

    _this5.type = "SFPhysicianPracticeError";
    _this5.message = "Failed to process SF Physician Practices " + err;
    _this5.name = 'SFPhysicianPracticeError';
    Error.captureStackTrace(_this5, SFPhysicianPracticeError);
    return _this5;
  }

  return SFPhysicianPracticeError;
}(Error);

var SFPhysicianError = exports.SFPhysicianError = function (_Error6) {
  _inherits(SFPhysicianError, _Error6);

  function SFPhysicianError(err) {
    _classCallCheck(this, SFPhysicianError);

    var _this6 = _possibleConstructorReturn(this, Object.getPrototypeOf(SFPhysicianError).call(this, err));

    _this6.type = "SFPhysicianError";
    _this6.message = "Failed to process SF Physician " + err;
    _this6.name = 'SFPhysicianError';
    Error.captureStackTrace(_this6, SFPhysicianError);
    return _this6;
  }

  return SFPhysicianError;
}(Error);

var PhysicianError = exports.PhysicianError = function (_Error7) {
  _inherits(PhysicianError, _Error7);

  function PhysicianError(err) {
    _classCallCheck(this, PhysicianError);

    var _this7 = _possibleConstructorReturn(this, Object.getPrototypeOf(PhysicianError).call(this, err));

    _this7.type = "PhysicianError";
    _this7.message = "Failed to process Physician " + err;
    _this7.name = 'PhysicianError';
    Error.captureStackTrace(_this7, PhysicianError);
    return _this7;
  }

  return PhysicianError;
}(Error);

var NormalizeVerificationError = exports.NormalizeVerificationError = function (_Error8) {
  _inherits(NormalizeVerificationError, _Error8);

  function NormalizeVerificationError(err) {
    _classCallCheck(this, NormalizeVerificationError);

    var _this8 = _possibleConstructorReturn(this, Object.getPrototypeOf(NormalizeVerificationError).call(this, err));

    _this8.type = "NormalizeVerificationError";
    _this8.message = "Failed to verify normalization " + err;
    _this8.name = 'NormalizeVerificationError';
    Error.captureStackTrace(_this8, NormalizeVerificationError);
    return _this8;
  }

  return NormalizeVerificationError;
}(Error);

var MMCTrackerError = exports.MMCTrackerError = function (_Error9) {
  _inherits(MMCTrackerError, _Error9);

  function MMCTrackerError(err) {
    _classCallCheck(this, MMCTrackerError);

    var _this9 = _possibleConstructorReturn(this, Object.getPrototypeOf(MMCTrackerError).call(this, err));

    _this9.type = "MMCTrackerError";
    _this9.message = "Failed to update MMC Tracker " + err;
    _this9.name = 'MMCTrackerError';
    Error.captureStackTrace(_this9, MMCTrackerError);
    return _this9;
  }

  return MMCTrackerError;
}(Error);

var AssignmentError = exports.AssignmentError = function (_Error10) {
  _inherits(AssignmentError, _Error10);

  function AssignmentError(err) {
    _classCallCheck(this, AssignmentError);

    var _this10 = _possibleConstructorReturn(this, Object.getPrototypeOf(AssignmentError).call(this, err));

    _this10.type = "AssignmentError";
    _this10.message = "Failed to update AssignmentError " + err;
    _this10.name = 'AssignmentError';
    Error.captureStackTrace(_this10, AssignmentError);
    return _this10;
  }

  return AssignmentError;
}(Error);

var GeospatialError = exports.GeospatialError = function (_Error11) {
  _inherits(GeospatialError, _Error11);

  function GeospatialError(err) {
    _classCallCheck(this, GeospatialError);

    var _this11 = _possibleConstructorReturn(this, Object.getPrototypeOf(GeospatialError).call(this, err));

    _this11.type = "GeospatialError";
    _this11.message = "Failed to update GeospatialError " + err;
    _this11.name = 'GeospatialError';
    Error.captureStackTrace(_this11, GeospatialError);
    return _this11;
  }

  return GeospatialError;
}(Error);

var CampaignError = exports.CampaignError = function (_Error12) {
  _inherits(CampaignError, _Error12);

  function CampaignError(err) {
    _classCallCheck(this, CampaignError);

    var _this12 = _possibleConstructorReturn(this, Object.getPrototypeOf(CampaignError).call(this, err));

    _this12.type = "CampaignError ";
    _this12.message = "Failed to update CampaignError " + err;
    _this12.name = 'CampaignError ';
    Error.captureStackTrace(_this12, CampaignError);
    return _this12;
  }

  return CampaignError;
}(Error);