@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/Model/Contracts/Gateway.js

@@ -0,0 +1,98 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define(["require", "exports", "./BaseEncodable"], function (
+  require,
+  exports,
+  BaseEncodable
+) {
+  "use strict";
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.GATEWAY,
+        name.toUpperCase()
+      );
+      this.name = name;
+    }
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+  (function (GatewayStatus) {
+    GatewayStatus[(GatewayStatus["Online"] = 0)] = "Online";
+    GatewayStatus[(GatewayStatus["NeedRegistration"] = 1)] = "NeedRegistration";
+    GatewayStatus[(GatewayStatus["Offline"] = 2)] = "Offline";
+    GatewayStatus[(GatewayStatus["Upgrading"] = 3)] = "Upgrading";
+    GatewayStatus[(GatewayStatus["Other"] = 4)] = "Other";
+  })(exports.GatewayStatus || (exports.GatewayStatus = {}));
+  var GatewayStatus = exports.GatewayStatus;
+  (function (GatewayVersionStatus) {
+    GatewayVersionStatus[(GatewayVersionStatus["None"] = 0)] = "None";
+    GatewayVersionStatus[(GatewayVersionStatus["UpToDate"] = 1)] = "UpToDate";
+    GatewayVersionStatus[(GatewayVersionStatus["NewVersionAvailable"] = 2)] =
+      "NewVersionAvailable";
+    GatewayVersionStatus[(GatewayVersionStatus["Expiring"] = 3)] = "Expiring";
+    GatewayVersionStatus[(GatewayVersionStatus["Expired"] = 4)] = "Expired";
+    GatewayVersionStatus[(GatewayVersionStatus["Other"] = 5)] = "Other";
+  })(exports.GatewayVersionStatus || (exports.GatewayVersionStatus = {}));
+  var GatewayVersionStatus = exports.GatewayVersionStatus;
+  var GatewayDataHelper = (function () {
+    function GatewayDataHelper() {}
+    GatewayDataHelper.parseStatus = function (statusString) {
+      if (statusString.toLowerCase() === "online") {
+        return GatewayStatus.Online;
+      }
+      if (statusString.toLowerCase() === "needregistration") {
+        return GatewayStatus.NeedRegistration;
+      }
+      if (statusString.toLowerCase() === "offline") {
+        return GatewayStatus.Offline;
+      }
+      return GatewayStatus.Other;
+    };
+    GatewayDataHelper.parseVersionStatus = function (statusString) {
+      if (statusString.toLowerCase() === "none") {
+        return GatewayVersionStatus.None;
+      }
+      if (statusString.toLowerCase() === "uptodate") {
+        return GatewayVersionStatus.UpToDate;
+      }
+      if (statusString.toLowerCase() === "newversionavailable") {
+        return GatewayVersionStatus.NewVersionAvailable;
+      }
+      if (statusString.toLowerCase() === "expiring") {
+        return GatewayVersionStatus.Expiring;
+      }
+      if (statusString.toLowerCase() === "expired") {
+        return GatewayVersionStatus.Expired;
+      }
+      return GatewayVersionStatus.Other;
+    };
+    GatewayDataHelper.needUpdate = function (gateway) {
+      var gatewayStatus = GatewayDataHelper.parseVersionStatus(
+        gateway.properties().versionStatus()
+      );
+      if (
+        gatewayStatus === GatewayVersionStatus.Expired ||
+        gatewayStatus === GatewayVersionStatus.Expiring ||
+        gatewayStatus === GatewayVersionStatus.NewVersionAvailable
+      ) {
+        return true;
+      } else {
+        return false;
+      }
+    };
+    return GatewayDataHelper;
+  })();
+  exports.GatewayDataHelper = GatewayDataHelper;
+});
+//# sourceMappingURL=Gateway.js.map

package/scripts/Framework/Model/Contracts/LinkedService.js

@@ -0,0 +1,200 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define(["require", "exports", "./BaseEncodable"], function (
+  require,
+  exports,
+  BaseEncodable
+) {
+  "use strict";
+  var DefaultValues = (function () {
+    function DefaultValues() {}
+    DefaultValues.hdInsightOnDemand = {
+      timeToLive: "02:00:00",
+    };
+    return DefaultValues;
+  })();
+  exports.DefaultValues = DefaultValues;
+  var LinkedServiceType = (function () {
+    function LinkedServiceType() {}
+    LinkedServiceType.hdInsight = "hdinsight";
+    LinkedServiceType.hdInsightOnDemand = "hdinsightondemand";
+    LinkedServiceType.azureML = "azureml";
+    LinkedServiceType.azureSqlDatabase = "azuresqldatabase";
+    LinkedServiceType.azureSqlDW = "azuresqldw";
+    LinkedServiceType.onPremisesSqlServer = "onpremisessqlserver";
+    return LinkedServiceType;
+  })();
+  exports.LinkedServiceType = LinkedServiceType;
+  exports.linkedServiceTypeToResourceMap = {};
+  exports.linkedServiceTypeToResourceMap[LinkedServiceType.hdInsight] =
+    ClientResources.hDInsightLabel;
+  exports.linkedServiceTypeToResourceMap[LinkedServiceType.hdInsightOnDemand] =
+    ClientResources.onDemandHDInsightLabel;
+  exports.linkedServiceTypeToResourceMap[LinkedServiceType.azureML] =
+    ClientResources.DataStoreTypeAzureML;
+  exports.linkedServiceTypeToResourceMap[LinkedServiceType.azureSqlDatabase] =
+    ClientResources.DataStoreTypeSqlAzure;
+  exports.linkedServiceTypeToResourceMap[LinkedServiceType.azureSqlDW] =
+    ClientResources.azureSqlDataWarehouseLabel;
+  exports.linkedServiceTypeToResourceMap[
+    LinkedServiceType.onPremisesSqlServer
+  ] = ClientResources.onPremisesSqlServerLabel;
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.LINKED_SERVICE,
+        name.toUpperCase()
+      );
+      this.entities = new BaseEncodable.EncodableSet();
+      this.name = name;
+    }
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+  var Type;
+  (function (Type) {
+    Type.AzureStorage = "AzureStorage";
+  })((Type = exports.Type || (exports.Type = {})));
+  var DataStoreType = (function () {
+    function DataStoreType() {}
+    DataStoreType.getDataStoreTypeByName = function (name) {
+      var found = undefined;
+      $.each(DataStoreType.allDataStoreTypes, function (index, value) {
+        if (value.name === name) {
+          found = value;
+          return false;
+        }
+      });
+      return found;
+    };
+    DataStoreType.storageAccountAsset = {
+      name: "AzureStorageLinkedService",
+      localizedName: ClientResources.DataStoreTypeStorageAccount,
+    };
+    DataStoreType.sqlAzureAsset = {
+      name: "AzureSqlLinkedService",
+      localizedName: ClientResources.DataStoreTypeSqlAzure,
+    };
+    DataStoreType.sqlServerAsset = {
+      name: "OnPremisesSqlLinkedService",
+      localizedName: ClientResources.DataStoreTypeSqlServer,
+    };
+    DataStoreType.fileAsset = {
+      name: "OnPremisesFileSystemLinkedService",
+      localizedName: ClientResources.DataStoreTypeFileSystem,
+    };
+    DataStoreType.hdInsightAsset = {
+      name: "HDInsightBYOCLinkedService",
+      localizedName: ClientResources.DataStoreTypeHDInsight,
+    };
+    DataStoreType.onDemandHDInsightAsset = {
+      name: "HDInsightOnDemandLinkedService",
+      localizedName: ClientResources.DataStoreTypeHDInsight,
+    };
+    DataStoreType.azureMlAsset = {
+      name: "AzureMLLinkedService",
+      localizedName: ClientResources.DataStoreTypeAzureML,
+    };
+    DataStoreType.oracleAsset = {
+      name: "OnPremisesOracleLinkedService",
+      localizedName: ClientResources.DataStoreTypeOracle,
+    };
+    DataStoreType.postgreSqlAsset = {
+      name: "OnPremisesPostgreSqlLinkedService",
+      localizedName: ClientResources.onPremisesPostgreSqlLinkedService,
+    };
+    DataStoreType.mySqlAsset = {
+      name: "OnPremisesMySqlLinkedService",
+      localizedName: ClientResources.onPremisesMySqlLinkedService,
+    };
+    DataStoreType.teradataAsset = {
+      name: "OnPremisesTeradataLinkedService",
+      localizedName: ClientResources.onPremisesTeradataLinkedService,
+    };
+    DataStoreType.db2Asset = {
+      name: "OnPremisesDb2LinkedService",
+      localizedName: ClientResources.onPremisesDb2LinkedService,
+    };
+    DataStoreType.sybaseAsset = {
+      name: "OnPremisesSybaseLinkedService",
+      localizedName: ClientResources.onPremisesSybaseLinkedService,
+    };
+    DataStoreType.dynamicsAXAsset = {
+      name: "DynamicsAXService",
+      localizedName: ClientResources.DataStoreTypeDynamicsAX,
+    };
+    DataStoreType.salesforceAsset = {
+      name: "SalesforceService",
+      localizedName: ClientResources.DataStoreTypeSalesforce,
+    };
+    DataStoreType.mdsAsset = {
+      name: "MdsLinkedService",
+      localizedName: ClientResources.DataStoreTypeMds,
+    };
+    DataStoreType.azureSearchIndexAsset = {
+      name: "AzureSearchIndexLinkedService",
+      localizedName: ClientResources.DataStoreTypeAzureSearchIndex,
+    };
+    DataStoreType.azureServiceBusAsset = {
+      name: "AzureServiceBusLinkedService",
+      localizedName: ClientResources.DataStoreTypeServiceBus,
+    };
+    DataStoreType.customAsset = {
+      name: "CustomLinkedService",
+      localizedName: ClientResources.DataStoreTypeCustom,
+    };
+    DataStoreType.allAvailableDataStoreTypes = [
+      DataStoreType.storageAccountAsset,
+      DataStoreType.sqlAzureAsset,
+      DataStoreType.sqlServerAsset,
+      DataStoreType.fileAsset,
+      DataStoreType.oracleAsset,
+      DataStoreType.postgreSqlAsset,
+      DataStoreType.mySqlAsset,
+      DataStoreType.teradataAsset,
+      DataStoreType.db2Asset,
+      DataStoreType.sybaseAsset,
+    ];
+    DataStoreType.allComputeTypes = [
+      DataStoreType.hdInsightAsset,
+      DataStoreType.onDemandHDInsightAsset,
+      DataStoreType.azureMlAsset,
+      DataStoreType.azureServiceBusAsset,
+      DataStoreType.customAsset,
+    ];
+    DataStoreType.allDataStoreTypes = [
+      DataStoreType.storageAccountAsset,
+      DataStoreType.sqlAzureAsset,
+      DataStoreType.sqlServerAsset,
+      DataStoreType.fileAsset,
+      DataStoreType.hdInsightAsset,
+      DataStoreType.onDemandHDInsightAsset,
+      DataStoreType.azureMlAsset,
+      DataStoreType.oracleAsset,
+      DataStoreType.postgreSqlAsset,
+      DataStoreType.mySqlAsset,
+      DataStoreType.teradataAsset,
+      DataStoreType.db2Asset,
+      DataStoreType.sybaseAsset,
+      DataStoreType.dynamicsAXAsset,
+      DataStoreType.salesforceAsset,
+      DataStoreType.mdsAsset,
+      DataStoreType.azureSearchIndexAsset,
+      DataStoreType.azureServiceBusAsset,
+      DataStoreType.customAsset,
+    ];
+    return DataStoreType;
+  })();
+  exports.DataStoreType = DataStoreType;
+});
+//# sourceMappingURL=LinkedService.js.map

package/scripts/Framework/Model/Contracts/Pipeline.js

@@ -0,0 +1,197 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define(["require", "exports", "./BaseEncodable", "./Common"], function (
+  require,
+  exports,
+  BaseEncodable,
+  Common
+) {
+  "use strict";
+  function getPipelineKey(pipelineName) {
+    return "P" + pipelineName.toUpperCase();
+  }
+  exports.getPipelineKey = getPipelineKey;
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.PIPELINE,
+        name.toUpperCase()
+      );
+      this.name = name;
+    }
+    Encodable.prototype.getLegacyKey = function () {
+      return getPipelineKey(this.name);
+    };
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+  var PipelineType;
+  (function (PipelineType) {
+    PipelineType.Default = "Default";
+    PipelineType.SSIS = "SSISPipeline";
+  })((PipelineType = exports.PipelineType || (exports.PipelineType = {})));
+  var PipelineSchedulerExecutionStyle;
+  (function (PipelineSchedulerExecutionStyle) {
+    PipelineSchedulerExecutionStyle.StartOfInterval = "StartOfInterval";
+    PipelineSchedulerExecutionStyle.EndOfInterval = "EndOfInterval";
+  })(
+    (PipelineSchedulerExecutionStyle =
+      exports.PipelineSchedulerExecutionStyle ||
+      (exports.PipelineSchedulerExecutionStyle = {}))
+  );
+  (function (OneTimePipelineFilterState) {
+    OneTimePipelineFilterState[(OneTimePipelineFilterState["Loaded"] = 0)] =
+      "Loaded";
+    OneTimePipelineFilterState[(OneTimePipelineFilterState["Evaluating"] = 1)] =
+      "Evaluating";
+    OneTimePipelineFilterState[(OneTimePipelineFilterState["None"] = 2)] =
+      "None";
+  })(
+    exports.OneTimePipelineFilterState ||
+      (exports.OneTimePipelineFilterState = {})
+  );
+  var OneTimePipelineFilterState = exports.OneTimePipelineFilterState;
+  var PipelineStatusName;
+  (function (PipelineStatusName) {
+    PipelineStatusName.paused = "paused";
+    PipelineStatusName.active = "active";
+    PipelineStatusName.idle = "idle";
+    PipelineStatusName.failed = "failed";
+  })(
+    (PipelineStatusName =
+      exports.PipelineStatusName || (exports.PipelineStatusName = {}))
+  );
+  exports.PipelineStatusDisplayName = {};
+  exports.PipelineStatusDisplayName[PipelineStatusName.paused] =
+    ClientResources.pausedPipelineStatusText;
+  exports.PipelineStatusDisplayName[PipelineStatusName.active] =
+    ClientResources.activePipelineStatusText;
+  exports.PipelineStatusDisplayName[PipelineStatusName.idle] =
+    ClientResources.idlePipelineStatusText;
+  exports.PipelineStatusDisplayName[PipelineStatusName.failed] =
+    ClientResources.failedProvisioningStatusText;
+  function getPipelineStatus(provisioningState, isPaused) {
+    if (
+      provisioningState === Common.ProvisioningState.Failed ||
+      provisioningState === Common.ProvisioningState.Disabled
+    ) {
+      return PipelineStatusName.failed;
+    }
+    if (isPaused) {
+      return PipelineStatusName.paused;
+    }
+    return PipelineStatusName.active;
+  }
+  exports.getPipelineStatus = getPipelineStatus;
+  function getNextScheduledWindowTime(pipeline, currentDate) {
+    var activities = pipeline.properties().activities;
+    if (
+      !activities ||
+      getPipelineStatus(
+        pipeline.properties().provisioningState(),
+        pipeline.properties().isPaused()
+      ) !== PipelineStatusName.active ||
+      !pipeline.properties().start ||
+      !pipeline.properties().end
+    ) {
+      return null;
+    }
+    var startDate = new Date(pipeline.properties().start());
+    var endDate = new Date(pipeline.properties().end());
+    var activityDates = [];
+    activities()
+      .filter(function (activity) {
+        return activity.scheduler != null;
+      })
+      .forEach(function (activity) {
+        var scheduler = activity.scheduler();
+        var offset = moment.duration(0);
+        if (scheduler.offset) {
+          offset = moment.duration(scheduler.offset());
+        }
+        var tmoment = null;
+        tmoment = moment.utc(startDate);
+        tmoment.subtract(offset);
+        tmoment.startOf(scheduler.frequency());
+        tmoment.add(offset);
+        if (tmoment.valueOf() > startDate.getTime()) {
+          tmoment.subtract(scheduler.interval(), scheduler.frequency());
+        }
+        if (
+          !(
+            scheduler.style &&
+            scheduler.style() ===
+              PipelineSchedulerExecutionStyle.StartOfInterval
+          )
+        ) {
+          tmoment.add(scheduler.interval(), scheduler.frequency());
+        }
+        var nextExecutionDate = upperBoundDate(
+          tmoment.toDate(),
+          currentDate,
+          scheduler.frequency(),
+          scheduler.interval()
+        );
+        if (nextExecutionDate.getTime() < currentDate.getTime()) {
+          nextExecutionDate = moment(nextExecutionDate)
+            .add(scheduler.interval(), scheduler.frequency())
+            .toDate();
+        }
+        if (
+          startDate.getTime() <= nextExecutionDate.getTime() &&
+          nextExecutionDate.getTime() < endDate.getTime()
+        ) {
+          activityDates.push(nextExecutionDate);
+        } else {
+          activityDates.push(null);
+        }
+      });
+    var nextScheduledExecution = activityDates.reduce(function (
+      prevDate,
+      curDate
+    ) {
+      if (prevDate === null) {
+        return curDate;
+      }
+      if (curDate === null) {
+        return prevDate;
+      }
+      return prevDate.getTime() < curDate.getTime() ? prevDate : curDate;
+    });
+    return nextScheduledExecution;
+  }
+  exports.getNextScheduledWindowTime = getNextScheduledWindowTime;
+  function upperBoundDate(curDate, upperBound, frequency, interval) {
+    var curMoment = moment.utc(curDate),
+      upperBoundMillis = upperBound.getTime(),
+      bestUpperBound = curDate.getTime();
+    var start = -100000,
+      end = 100000,
+      mid = 0;
+    while (start <= end) {
+      mid = Math.floor((start + end) / 2);
+      var tempMoment = curMoment
+        .clone()
+        .add(mid * interval, frequency)
+        .valueOf();
+      if (tempMoment <= upperBoundMillis) {
+        bestUpperBound = tempMoment;
+        start = mid + 1;
+      } else {
+        end = mid - 1;
+      }
+    }
+    return new Date(bestUpperBound);
+  }
+});
+//# sourceMappingURL=Pipeline.js.map

package/scripts/Framework/Model/DataCache.js

@@ -0,0 +1,105 @@
+define(["require", "exports", "../Util/Util"], function (
+  require,
+  exports,
+  Util
+) {
+  "use strict";
+  var DataCache = (function () {
+    function DataCache(params) {
+      this._params = null;
+      this._params = params;
+    }
+    DataCache.prototype.fetch = function () {
+      var _this = this;
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i - 0] = arguments[_i];
+      }
+      var deferred = Q.defer();
+      var promise = null;
+      if (this._params.serviceMethod) {
+        promise = this._params.serviceMethod.apply(
+          this._params.serviceObject,
+          args
+        );
+      } else {
+        var requestParams = JSON.parse(
+          JSON.stringify(this._params.requestParams)
+        );
+        requestParams.data = args[0];
+        promise = this._params.serviceObject.ajax(requestParams);
+      }
+      promise.then(
+        function (responseData) {
+          var data = responseData;
+          if (_this._params.processServerResponse) {
+            data = _this._params.processServerResponse(responseData);
+          }
+          deferred.resolve(data);
+        },
+        function (reason) {
+          deferred.reject(reason);
+        }
+      );
+      return deferred.promise;
+    };
+    DataCache.prototype.createView = function (cache) {
+      if (cache === void 0) {
+        cache = false;
+      }
+      if (!this.view) {
+        this.view = new DataCacheView(this, cache);
+      }
+      return this.view;
+    };
+    return DataCache;
+  })();
+  exports.DataCache = DataCache;
+  var DataCacheView = (function () {
+    function DataCacheView(dataCache, cache) {
+      if (cache === void 0) {
+        cache = false;
+      }
+      this.items = ko.observable();
+      this._dataCache = null;
+      this._cache = false;
+      this._deferred = null;
+      this._time = null;
+      this._dataCache = dataCache;
+      this._cache = cache;
+    }
+    DataCacheView.prototype.fetch = function () {
+      var _this = this;
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i - 0] = arguments[_i];
+      }
+      if (this._cache && this._deferred) {
+        if (
+          new Date().getTime() - this._time.getTime() <=
+          DataCacheView.timeDelta
+        ) {
+          return this._deferred.promise;
+        }
+      }
+      var deferred = Q.defer();
+      this._deferred = deferred;
+      this._time = new Date();
+      var fetchPromise = this._dataCache.fetch.apply(this._dataCache, args);
+      fetchPromise.then(
+        function (responseData) {
+          _this.items(Util.objectToObservables(responseData)());
+          deferred.resolve(_this.items());
+        },
+        function (reason) {
+          deferred.reject(reason);
+        }
+      );
+      return deferred.promise;
+    };
+    DataCacheView.timeDelta = 1 * 60 * 1000;
+    return DataCacheView;
+  })();
+  exports.DataCacheView = DataCacheView;
+});
+//# sourceMappingURL=DataCache.js.map

package/scripts/Framework/Model/DataFactoryCache.js

@@ -0,0 +1,24 @@
+define([
+  "require",
+  "exports",
+  "./DataCache",
+  "../Shared/DataConstants",
+], function (require, exports, DataCache, DataConstants) {
+  "use strict";
+  var DataFactoryCache = (function () {
+    function DataFactoryCache(service) {
+      this.runLogsCacheObject = null;
+      this.runLogsCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        requestParams: {
+          url: DataConstants.RunLogUri + "/ListRunLogs",
+          type: "GET",
+          contentType: "application/json",
+        },
+      });
+    }
+    return DataFactoryCache;
+  })();
+  exports.DataFactoryCache = DataFactoryCache;
+});
+//# sourceMappingURL=DataFactoryCache.js.map