@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Handlers/WinJSHandlers.js

@@ -0,0 +1,265 @@
+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",
+  "../../_generated/Svg",
+  "../Framework/Views/HoverFlyout",
+  "../Framework/Util/Util",
+], function (require, exports, Svg, Flyout, Util) {
+  "use strict";
+  var flyoutContentSelector = ".adf-flyoutContent";
+  var calloutContentSelector = ".adf-calloutContent";
+  var dialogContentSelector = ".adf-dialogContent";
+  var FlyoutHandler = (function () {
+    function FlyoutHandler() {
+      var _this = this;
+      this._template =
+        '<div id="adf-flyout"><div class = "adf-flyoutContent"></div>';
+      this._requestId = 0;
+      this._onTimeoutMaker = function (requestId) {
+        return function () {
+          if (requestId === _this._requestId) {
+            _this._flyout.hide();
+          }
+        };
+      };
+      this._onHide = function () {
+        if (_this._requests.length === 0) {
+          _this._currentRequest = null;
+          return;
+        }
+        _this._executeRequest(_this._requests.shift());
+      };
+      this._requests = [];
+      this._flyout = null;
+    }
+    FlyoutHandler.prototype.dispose = function () {};
+    FlyoutHandler.prototype.addRequest = function (request) {
+      this.createFlyoutHelper(flyoutContentSelector);
+      if (!this._currentRequest && this._requests.length === 0) {
+        this._executeRequest(request);
+      } else {
+        this._requests.push(request);
+      }
+    };
+    FlyoutHandler.prototype.createFlyoutHelper = function (contentSelector) {
+      if (!this._flyout) {
+        this._flyoutHost = $(this._template).appendTo("body")[0];
+        this._flyout = new WinJS.UI.Flyout(this._flyoutHost, {
+          placement: "auto",
+        });
+        this._flyoutContent = this._flyoutHost.querySelector(contentSelector);
+        this._flyout.addEventListener("afterhide", this._onHide);
+      }
+    };
+    FlyoutHandler.prototype._executeRequest = function (request) {
+      this._requestId++;
+      this._currentRequest = request;
+      this._flyoutContent.innerHTML = request.innerHTML;
+      this._flyout.show(request.anchor);
+      if (this._currentRequest.timeout) {
+        window.setTimeout(
+          this._onTimeoutMaker(this._requestId),
+          this._currentRequest.timeout
+        );
+      }
+    };
+    return FlyoutHandler;
+  })();
+  exports.FlyoutHandler = FlyoutHandler;
+  var CalloutHandler = (function (_super) {
+    __extends(CalloutHandler, _super);
+    function CalloutHandler() {
+      _super.apply(this, arguments);
+      this._template =
+        '<div id="adf-callout"><div id="adf-callout-svg"></div><div class = "adf-calloutContent"></div>';
+    }
+    CalloutHandler.prototype.addRequest = function (request) {
+      var _this = this;
+      this.createFlyoutHelper(calloutContentSelector);
+      if (request.autohide) {
+        Flyout.setupFlyoutAutohide(this._flyout, request.anchor);
+      }
+      if (request.placement) {
+        this._flyout.placement = request.placement;
+      }
+      var afterFlyoutShows, beforeFlyoutHides;
+      var caretContainer = $("#adf-callout-svg")[0];
+      afterFlyoutShows = function () {
+        _this._flyout.addEventListener("beforehide", beforeFlyoutHides);
+        var placement = _this.getPlacement(
+          request.anchor,
+          _this._flyout.element
+        );
+        var caret = "";
+        switch (placement) {
+          case "left":
+            caret = Svg.caret_right;
+            $(caretContainer).removeClass().addClass("right");
+            break;
+          case "right":
+            caret = Svg.caret_left;
+            $(caretContainer).removeClass().addClass("left");
+            break;
+          case "top":
+            caret = Svg.caret_down;
+            $(caretContainer).removeClass().addClass("bottom");
+            break;
+          case "bottom":
+            caret = Svg.caret_up;
+            $(caretContainer).removeClass().addClass("top");
+            break;
+          default:
+            break;
+        }
+        $(caretContainer).html(caret);
+      };
+      beforeFlyoutHides = function () {
+        _this._flyout.removeEventListener("aftershow", afterFlyoutShows);
+        _this._flyout.removeEventListener("beforehide", beforeFlyoutHides);
+      };
+      _super.prototype.addRequest.call(this, request);
+    };
+    CalloutHandler.prototype.getPlacement = function (anchor, flyout) {
+      var cXAnchor = $(anchor).offset().left + $(anchor).width() / 2;
+      var cYAnchor = $(anchor).offset().top + $(anchor).height() / 2;
+      var cXFlyout = $(flyout).offset().left + $(flyout).width() / 2;
+      var cYFlyout = $(flyout).offset().top + $(flyout).height() / 2;
+      var xDiff = cXAnchor - cXFlyout;
+      var yDiff = cYFlyout - cYAnchor;
+      if (Math.abs(xDiff) >= Math.abs(yDiff)) {
+        return xDiff >= 0 ? "left" : "right";
+      } else {
+        return yDiff >= 0 ? "bottom" : "top";
+      }
+    };
+    return CalloutHandler;
+  })(FlyoutHandler);
+  exports.CalloutHandler = CalloutHandler;
+  var DismissalResult = (function () {
+    function DismissalResult() {}
+    DismissalResult.none = WinJS.UI.ContentDialog.DismissalResult.none;
+    DismissalResult.primary = WinJS.UI.ContentDialog.DismissalResult.primary;
+    DismissalResult.secondary =
+      WinJS.UI.ContentDialog.DismissalResult.secondary;
+    return DismissalResult;
+  })();
+  exports.DismissalResult = DismissalResult;
+  var DialogHandler = (function () {
+    function DialogHandler() {
+      var _this = this;
+      this._template =
+        '<div id="adf-dialog"><div class = "adf-dialogContent"></div>';
+      this._currentRequest = null;
+      this._onHide = function (eventInfo) {
+        if (typeof eventInfo.detail.result === "undefined") {
+          eventInfo.detail.result = DismissalResult.none;
+        }
+        if (_this._currentRequest.dismissalHandler) {
+          _this._currentRequest.dismissalHandler(eventInfo.detail.result);
+        }
+        if (_this._currentRequest.uniqueKey) {
+          delete _this._set[_this._currentRequest.uniqueKey];
+        }
+        _this._currentRequest = null;
+        if (_this._requests.length === 0) {
+          return;
+        }
+        var request = _this._requests.shift();
+        _this._executeRequest(request);
+      };
+      this._requests = [];
+      this._set = {};
+      this._dialog = null;
+    }
+    DialogHandler.prototype.okayCancelRequest = function (
+      title,
+      question,
+      onSuccess,
+      onFailure
+    ) {
+      var request = {
+        title: title,
+        innerHTML: question,
+        primaryCommandText: ClientResources.ok,
+        secondaryCommandText: ClientResources.Cancel,
+        dismissalHandler: function (result) {
+          if (result === DismissalResult.primary) {
+            onSuccess();
+          } else if (onFailure) {
+            onFailure();
+          }
+        },
+      };
+      this.addRequest(request);
+    };
+    DialogHandler.prototype.okayRequest = function (
+      title,
+      information,
+      callback
+    ) {
+      var request = {
+        title: title,
+        innerHTML: information,
+        primaryCommandText: ClientResources.ok,
+        dismissalHandler: function (result) {
+          if (callback) {
+            callback();
+          }
+        },
+      };
+      this.addRequest(request);
+    };
+    DialogHandler.prototype.addRequest = function (request, rejectIfInQueue) {
+      if (!this._dialog) {
+        this._dialogHost = $(this._template).appendTo("body")[0];
+        this._dialogContent = this._dialogHost.querySelector(
+          dialogContentSelector
+        );
+        this._dialog = new WinJS.UI.ContentDialog(this._dialogHost);
+        this._dialog.addEventListener("afterhide", this._onHide);
+      }
+      if (rejectIfInQueue) {
+        if (!request.uniqueKey) {
+          request.uniqueKey = Util.hashCode(request.innerHTML);
+        }
+        if (this._set[request.uniqueKey]) {
+          return this._dialog;
+        }
+        this._set[request.uniqueKey] = 1;
+      }
+      if (!this._currentRequest && this._requests.length === 0) {
+        this._executeRequest(request);
+      } else {
+        this._requests.push(request);
+      }
+      return this._dialog;
+    };
+    DialogHandler.prototype.dispose = function () {};
+    DialogHandler.prototype._executeRequest = function (request) {
+      this._currentRequest = request;
+      if (!request.primaryCommandText) {
+        request.primaryCommandText =
+          ClientResources.defaultDialogPrimaryCommandText;
+      }
+      this._dialog.primaryCommandText = request.primaryCommandText;
+      this._dialog.secondaryCommandText = request.secondaryCommandText;
+      this._dialog.title = request.title;
+      this._dialogContent.innerHTML = request.innerHTML;
+      this._currentRequest = request;
+      this._dialog.show();
+    };
+    return DialogHandler;
+  })();
+  exports.DialogHandler = DialogHandler;
+});
+//# sourceMappingURL=WinJSHandlers.js.map

package/scripts/MonitoringViewContext.js

@@ -0,0 +1,75 @@
+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",
+  "./ViewContext",
+  "./Framework/Model/Contracts/ActivityWindow",
+  "./Framework/Util/Datetime",
+  "./Handlers/MonitoringViewHandler",
+  "./Framework/Model/ActivityWindowCache",
+], function (
+  require,
+  exports,
+  ViewContext_1,
+  ActivityWindowModel,
+  Datetime,
+  MonitoringViewHandler,
+  ActivityWindowCache
+) {
+  "use strict";
+  var MonitoringViewContext = (function (_super) {
+    __extends(MonitoringViewContext, _super);
+    function MonitoringViewContext() {
+      var _this = this;
+      _super.call(this);
+      this.dateRange = null;
+      this.globalActivityWindowFilter = null;
+      var startDate = moment().subtract(1, Datetime.TimeUnit.Week).toDate();
+      startDate.setSeconds(0, 0);
+      var endDate = new Date(new Date().getTime() + 60 * 60 * 1000 * 24);
+      endDate.setSeconds(0, 0);
+      this.dateRange = Datetime.getDateRangeObservable({
+        startDate: startDate,
+        endDate: endDate,
+      });
+      this.globalActivityWindowFilter = ko.pureComputed(function () {
+        var windowStartColName =
+          ActivityWindowModel.ServiceColumnNames.ExtendedProperties.WindowStart;
+        var windowEndColName =
+          ActivityWindowModel.ServiceColumnNames.ExtendedProperties.WindowEnd;
+        var activityTypeColName =
+          ActivityWindowModel.ServiceColumnNames.ExtendedProperties
+            .ActivityType;
+        var filter =
+          "(({0} lt {1} and {2} lt {3}) and ({4} ne '' and {4} ne 'Validation'))".format(
+            _this.dateRange().startDate.toISOString(),
+            windowEndColName,
+            windowStartColName,
+            _this.dateRange().endDate.toISOString(),
+            activityTypeColName
+          );
+        return filter;
+      });
+      this.monitoringViewHandler =
+        new MonitoringViewHandler.MonitoringViewHandler();
+      this.activityWindowCache = new ActivityWindowCache.ActivityWindowCache(
+        this.globalActivityWindowFilter
+      );
+    }
+    MonitoringViewContext.prototype.dispose = function () {
+      this.globalActivityWindowFilter.dispose();
+    };
+    return MonitoringViewContext;
+  })(ViewContext_1.ViewContext);
+  exports.MonitoringViewContext = MonitoringViewContext;
+});
+//# sourceMappingURL=MonitoringViewContext.js.map

package/scripts/Services/AzureInsightsService.js

@@ -0,0 +1,162 @@
+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",
+  "../Framework/Util/Log",
+  "./BaseService",
+], function (require, exports, Log, BaseService) {
+  "use strict";
+  var logger = Log.getLogger({ loggerName: "AzureInsightsService" });
+  var AzureInsightsService = (function (_super) {
+    __extends(AzureInsightsService, _super);
+    function AzureInsightsService(appcontext) {
+      _super.call(this, appcontext, logger);
+      this._apiVersion = "2015-04-01";
+      this._insightsResourceProviderNamespace = "Microsoft.Insights";
+      this._datafactoryResourceProviderNamespace = "Microsoft.DataFactory";
+      this._insightsBaseUrl =
+        "/subscriptions/{subscriptionId}/resourcegroups/" +
+        "{resourceGroupName}/providers/" +
+        this._insightsResourceProviderNamespace;
+      this._datafactoryBaseUrl =
+        "/subscriptions/{subscriptionId}/resourcegroups/" +
+        "{resourceGroupName}/providers/" +
+        this._datafactoryResourceProviderNamespace;
+      this._alertUrl = this._insightsBaseUrl + "/alertRules/{alertRuleName}";
+      this._listRulesUrl = this._insightsBaseUrl + "/alertRules";
+      this._factoryResourceUrl =
+        this._datafactoryBaseUrl + "/datafactories/{factoryName}";
+    }
+    AzureInsightsService.prototype.createOrUpdateRule = function (
+      resourceParams,
+      createOrUpdateRuleJsonParams
+    ) {
+      var url = this.getBaseUrl(this._alertUrl, resourceParams);
+      var data = this.getCreateOrUpdateAlertRuleJson(
+        resourceParams,
+        createOrUpdateRuleJsonParams
+      );
+      var promise = this.ajaxQ({
+        url: url,
+        data: data,
+        type: "PUT",
+        contentType: "application/json",
+      });
+      promise.fail(
+        this._appContext.errorHandler.makeResourceFailedHandler(
+          "Creating alert rule {0} failed".format(resourceParams.alertRuleName),
+          url
+        )
+      );
+      return promise;
+    };
+    AzureInsightsService.prototype.deleteRule = function (alertParams) {
+      var url = this.getBaseUrl(this._alertUrl, alertParams);
+      var promise = this.ajaxQ({
+        url: url,
+        type: "DELETE",
+        contentType: "application/json",
+      });
+      promise.fail(
+        this._appContext.errorHandler.makeResourceFailedHandler(
+          "Deleting alert rule {0} failed".format(alertParams.alertRuleName),
+          url
+        )
+      );
+      return promise;
+    };
+    AzureInsightsService.prototype.getRule = function (alertParams) {
+      var url = this.getBaseUrl(this._alertUrl, alertParams);
+      var promise = this.ajaxQ({
+        url: url,
+        type: "GET",
+        contentType: "application/json",
+      });
+      promise.fail(
+        this._appContext.errorHandler.makeResourceFailedHandler(
+          "Getting information about alert rule {0} failed".format(
+            alertParams.alertRuleName
+          ),
+          url
+        )
+      );
+      return promise;
+    };
+    AzureInsightsService.prototype.listRules = function (baseUrlParams) {
+      var _this = this;
+      var url = this.getBaseUrl(this._listRulesUrl, baseUrlParams);
+      var promise = this.ajaxQ({
+        url: url,
+        type: "GET",
+        contentType: "application/json",
+      });
+      promise.fail(function (error) {
+        _this.logMessage(
+          error.status,
+          "Failed to fetch alerts {0}".format(JSON.stringify(error))
+        );
+      });
+      return promise;
+    };
+    AzureInsightsService.prototype.getCreateOrUpdateAlertRuleJson = function (
+      resourceParams,
+      params
+    ) {
+      var resourceUri = this.getBaseUrl(
+        this._factoryResourceUrl,
+        resourceParams
+      );
+      var jsonTemplate = {
+        type: "microsoft.insights/alertrules",
+        properties: {
+          condition: {
+            "odata.type":
+              "Microsoft.Azure.Management.Insights.Models.ManagementEventRuleCondition",
+            dataSource: {
+              "odata.type":
+                "Microsoft.Azure.Management.Insights.Models.RuleManagementEventDataSource",
+              resourceUri: resourceUri,
+            },
+          },
+          action: {
+            "odata.type":
+              "Microsoft.Azure.Management.Insights.Models.RuleEmailAction",
+          },
+        },
+      };
+      var jsonObject = JSON.parse(JSON.stringify(jsonTemplate));
+      jsonObject.name = params.name;
+      jsonObject.location = params.location;
+      jsonObject.properties.name = params.name;
+      jsonObject.properties.description = params.description;
+      jsonObject.properties.isEnabled = params.isEnabled;
+      jsonObject.properties.condition.dataSource.operationName =
+        params.operationName;
+      jsonObject.properties.condition.dataSource.status = params.status;
+      jsonObject.properties.condition.dataSource.subStatus = params.subStatus;
+      if (params.windowSize) {
+        jsonObject.properties.condition.aggregation = {
+          operator: params.operator,
+          windowSize: params.windowSize,
+          threshold: params.threshold,
+        };
+      }
+      jsonObject.properties.action.customEmails = params.customEmails;
+      jsonObject.properties.action.sendToServiceOwners =
+        params.sendToServiceOwners;
+      return JSON.stringify(jsonObject);
+    };
+    return AzureInsightsService;
+  })(BaseService.BaseService);
+  exports.AzureInsightsService = AzureInsightsService;
+});
+//# sourceMappingURL=AzureInsightsService.js.map