@ms-atlas-module/datastudio-datafactory 0.1.36

package/bootstrapper/StatusCalendarFlyoutKnockoutBinding.js

@@ -0,0 +1,398 @@
+define([
+  "require",
+  "exports",
+  "../scripts/AppContext",
+  "../scripts/MonitoringViewContext",
+  "../_generated/Framework",
+  "Hulljs",
+  "../scripts/Framework/Util/Log",
+  "../scripts/Framework/Model/Contracts/ActivityWindow",
+  "text!./Templates/GraphNodeStatusTemplate.html",
+], function (
+  require,
+  exports,
+  AppContext,
+  MonitoringViewContext_1,
+  Framework,
+  Hulljs,
+  Log,
+  ActivityWindowModel
+) {
+  "use strict";
+  var DataConstants = Framework.DataConstants;
+  var StatusCalendar = Framework.StatusCalendar;
+  var LifetimeManager = Framework.Disposable.DisposableLifetimeManager;
+  var Util = Framework.Util;
+  var logger = Log.getLogger({
+    loggerName: "StatusCalendarFlyoutKnockoutBinding",
+  });
+  (function (FlyoutBindingType) {
+    FlyoutBindingType[(FlyoutBindingType["Activity"] = 0)] = "Activity";
+    FlyoutBindingType[(FlyoutBindingType["Table"] = 1)] = "Table";
+  })(exports.FlyoutBindingType || (exports.FlyoutBindingType = {}));
+  var FlyoutBindingType = exports.FlyoutBindingType;
+  var flyoutClickeaterSelector = ".win-flyoutmenuclickeater";
+  var actionForShow = "mouseenter";
+  var calendarId = "graphNodeStatusHover";
+  var flyoutSelector = ".adfGraphNodeStatusFlyout";
+  var GraphNodeStatusBindingHandler = (function () {
+    function GraphNodeStatusBindingHandler() {}
+    GraphNodeStatusBindingHandler.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      if (!viewModel) {
+        return;
+      }
+      var value = valueAccessor();
+      element.innerHTML = GraphNodeStatusBindingHandler.template;
+      var appContext = AppContext.AppContext.getInstance();
+      var viewContext = appContext.getViewContext(
+        MonitoringViewContext_1.MonitoringViewContext
+      );
+      var nodeStatus = ko.observable([]);
+      var shouldDisplay = ko.observable(true);
+      ko.applyBindingsToDescendants(
+        {
+          nodeStatus: nodeStatus,
+          shouldDisplay: shouldDisplay,
+        },
+        element
+      );
+      if (value.additionalQueryFilter === null) {
+        shouldDisplay(false);
+        return { controlsDescendantBindings: true };
+      }
+      var lifetimeManager = new LifetimeManager();
+      var availability = null;
+      value.availabilityPromise.then(function (valueAvailability) {
+        availability = valueAvailability;
+      });
+      if (value.recentActivityWindows) {
+        lifetimeManager.registerForDispose(
+          Util.subscribeAndCall(
+            value.recentActivityWindows,
+            function (recentActivityWindows) {
+              value.availabilityPromise.then(
+                function () {
+                  nodeStatus(
+                    getLastFewStatusBoxes(
+                      availability.frequency(),
+                      availability.interval(),
+                      recentActivityWindows,
+                      viewContext.dateRange().endDate
+                    )
+                  );
+                },
+                function (reason) {
+                  if (reason) {
+                    logger.logError(
+                      "Failed to display graph node status for {0}, reason: {1}".format(
+                        value.calendarHeader,
+                        reason
+                      ),
+                      reason
+                    );
+                  }
+                }
+              );
+            }
+          )
+        );
+      }
+      var flyoutHostDiv = bindingContext.$root.func.element
+        .parent()[0]
+        .querySelector(flyoutSelector);
+      var flyout = flyoutHostDiv.winControl;
+      var clickEaterElement = $(flyoutClickeaterSelector)[0];
+      var statusCalendar =
+        StatusCalendar.StatusCalendar.statusCalendars[calendarId];
+      var boundedConvexPolygon = null;
+      var afterFlyoutShows, beforeFlyoutHides;
+      var clickEaterMouseMoveListener;
+      afterFlyoutShows = function () {
+        flyout.addEventListener("beforehide", beforeFlyoutHides);
+        var verticesToCover = getRectVertices(
+          flyoutHostDiv.getBoundingClientRect()
+        );
+        verticesToCover = verticesToCover.concat(
+          getRectVertices(element.getBoundingClientRect())
+        );
+        boundedConvexPolygon = Hulljs(verticesToCover, Infinity, [".x", ".y"]);
+        clickEaterElement.addEventListener(
+          "mousemove",
+          clickEaterMouseMoveListener
+        );
+      };
+      beforeFlyoutHides = function () {
+        clickEaterElement.removeEventListener(
+          "mousemove",
+          clickEaterMouseMoveListener
+        );
+        boundedConvexPolygon = null;
+        flyout.removeEventListener("aftershow", afterFlyoutShows);
+        flyout.removeEventListener("beforehide", beforeFlyoutHides);
+      };
+      clickEaterMouseMoveListener = function (mouseevent) {
+        var curPos = { x: mouseevent.clientX, y: mouseevent.clientY };
+        if (!isPointInsideConvexPolygon(curPos, boundedConvexPolygon)) {
+          flyout.hide();
+        }
+      };
+      var frequency = null;
+      var interval = null;
+      var hightlightedDates = ko.pureComputed(function () {
+        var hightlighted = [];
+        nodeStatus().forEach(function (nodeStatusRow) {
+          nodeStatusRow.forEach(function (nodeStatusField) {
+            hightlighted.push(nodeStatusField.date.getTime());
+          });
+        });
+        return hightlighted;
+      });
+      var calendarPageCallback = function (dateRange) {
+        var deferred = Q.defer();
+        getActivityWindows(
+          value.additionalQueryFilter,
+          dateRange.startDate,
+          dateRange.endDate
+        ).then(
+          function (activityWindows) {
+            if (
+              activityWindows.length > 0 &&
+              value.recentActivityWindows &&
+              value.recentActivityWindows().length === 0
+            ) {
+              value.recentActivityWindows.push(activityWindows[0]);
+            } else if (
+              activityWindows.length === 0 &&
+              value.recentActivityWindows &&
+              value.recentActivityWindows().length > 0
+            ) {
+              activityWindows.push(value.recentActivityWindows()[0]);
+            }
+            var data = activityWindows.map(function (activityWindow) {
+              var windowStartTime = new Date(activityWindow().windowStart);
+              var statusBox = {
+                date: windowStartTime,
+                status: ko.pureComputed(function () {
+                  return activityWindow().statusCalendarStatus;
+                }),
+                tooltip: ko.pureComputed(function () {
+                  return ClientResources.statusCalendarBoxTooltip.format(
+                    activityWindow().displayState,
+                    activityWindow().windowStartPair.UTC,
+                    activityWindow().windowEndPair.UTC
+                  );
+                }),
+              };
+              statusBox.clickCallback = function (statusBoxArg) {
+                statusCalendar.updateSelection(statusBoxArg.date);
+                AppContext.AppContext.getInstance().selectionHandler.pushState(
+                  GraphNodeStatusBindingHandler.className,
+                  [new ActivityWindowModel.Encodable(activityWindow)]
+                );
+              };
+              statusBox.doubleClickCallback = function (statusBoxArg) {
+                statusBox.clickCallback(statusBoxArg);
+                AppContext.AppContext.getInstance().openActivityWindowExplorer();
+              };
+              return statusBox;
+            });
+            deferred.resolve(data);
+          },
+          function (reason) {
+            logger.logError(
+              "Could not load data: {0}".format(reason.responseText)
+            );
+            deferred.reject(
+              "StatusCalendarFlyoutKnockoutBinding: Could not load data."
+            );
+          }
+        );
+        return deferred.promise;
+      };
+      var showFlyout = function () {
+        setTimeout(function () {
+          if (
+            value.availabilityPromise.isFulfilled() &&
+            !value.availabilityPromise.isRejected() &&
+            $(element).is(":hover")
+          ) {
+            frequency = availability.frequency();
+            interval = availability.interval();
+            var footer = [
+              ClientResources.frequencyAndIntervalText.format(
+                frequency,
+                interval
+              ),
+              ClientResources.datetimeInUTCLabel,
+            ];
+            var returnVal = StatusCalendar.findCorrectFrequencyAndInterval(
+              frequency,
+              interval
+            );
+            frequency = returnVal[0];
+            interval = returnVal[1];
+            var curDate = viewContext.dateRange().endDate;
+            statusCalendar
+              .update({
+                header: value.calendarHeader,
+                subHeader: ClientResources.activityWindowListTitle,
+                footer: footer,
+                frequency: frequency,
+                interval: interval,
+                pageCallback: calendarPageCallback,
+                baseDate: curDate,
+                dateRange: viewContext.dateRange(),
+                highlightedDates: hightlightedDates,
+              })
+              .then(
+                function (updateResult) {
+                  flyout.addEventListener("aftershow", afterFlyoutShows);
+                  flyout.show(element);
+                },
+                function (reason) {
+                  if (
+                    reason.result !==
+                    StatusCalendar.StatusCalendarUpdateResultEnum.aborted
+                  ) {
+                    logger.logError(
+                      "Failed to update hover calendar: " + reason.reason
+                    );
+                  }
+                }
+              );
+          }
+        }, 200);
+      };
+      element.addEventListener(actionForShow, showFlyout);
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+        element.removeEventListener(actionForShow, showFlyout);
+        flyout.removeEventListener("aftershow", afterFlyoutShows);
+        flyout.removeEventListener("beforehide", beforeFlyoutHides);
+        lifetimeManager.dispose();
+      });
+      return { controlsDescendantBindings: true };
+    };
+    GraphNodeStatusBindingHandler.className =
+      DataConstants.GraphNodeStatusBindingHandler;
+    GraphNodeStatusBindingHandler.template = require("text!./Templates/GraphNodeStatusTemplate.html");
+    return GraphNodeStatusBindingHandler;
+  })();
+  exports.GraphNodeStatusBindingHandler = GraphNodeStatusBindingHandler;
+  function sideSign(a, l1, l2) {
+    var mf = l1.y - l2.y;
+    var mc = l2.y * l1.x - l1.y * l2.x;
+    return mf * a.x + mc - a.y * (l1.x - l2.x);
+  }
+  function isPointInsideConvexPolygon(p, polygon) {
+    if (polygon.length < 3) {
+      logger.logError("Too few points specified for polygon");
+    }
+    var centroid = { x: 0, y: 0 };
+    for (var i = 0; i < polygon.length; i++) {
+      centroid.x += polygon[i].x / polygon.length;
+      centroid.y += polygon[i].y / polygon.length;
+    }
+    for (var i = 0; i < polygon.length; i++) {
+      var a = polygon[i];
+      var b = polygon[(i + 1) % polygon.length];
+      if (sideSign(p, a, b) * sideSign(centroid, a, b) < 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getRectVertices(clientRect) {
+    var x1 = clientRect.left;
+    var x2 = clientRect.left + clientRect.width;
+    var y1 = clientRect.top;
+    var y2 = clientRect.top + clientRect.height;
+    return [
+      { x: x1, y: y1 },
+      { x: x2, y: y1 },
+      { x: x2, y: y2 },
+      { x: x1, y: y2 },
+    ];
+  }
+  function getActivityWindows(filter, slotStart, slotEnd, top) {
+    var deferred = Q.defer();
+    if (!top) {
+      top = StatusCalendar.maxNumberOfSlotsInACalendar;
+    }
+    var colNames = ActivityWindowModel.ServiceColumnNames.ExtendedProperties;
+    var finalFilter = "{0} le {1} and {2} lt {3} and ({4})".format(
+      slotStart.toISOString(),
+      colNames.WindowStart,
+      colNames.WindowStart,
+      slotEnd.toISOString(),
+      filter
+    );
+    AppContext.AppContext.getInstance()
+      .viewContext.activityWindowCache.fetchTop(
+        finalFilter,
+        "{0} desc".format(colNames.WindowStart),
+        top
+      )
+      .then(
+        function (activityRunPrimaryEvents) {
+          activityRunPrimaryEvents.reverse();
+          deferred.resolve(activityRunPrimaryEvents);
+        },
+        function (reason) {
+          logger.logError(
+            "Failed to fetch activity window: {0}".format(reason.responseText)
+          );
+          deferred.reject(ClientResources.failedToFetchActivityWindowText);
+        }
+      );
+    return deferred.promise;
+  }
+  function getLastFewStatusBoxes(
+    frequency,
+    interval,
+    recentActivityWindows,
+    baseDate
+  ) {
+    var recentStatus = [];
+    recentActivityWindows.forEach(function (activityWindow) {
+      recentStatus.push({
+        date: new Date(activityWindow().windowStart),
+        status: ko.pureComputed(function () {
+          return activityWindow().statusCalendarStatus;
+        }),
+      });
+    });
+    var returnVal = StatusCalendar.findCorrectFrequencyAndInterval(
+      frequency,
+      interval
+    );
+    frequency = returnVal[0];
+    interval = returnVal[1];
+    var hasGenericCalendar = StatusCalendar.hasGenericCalendar(
+      frequency,
+      interval
+    );
+    var dateRange = StatusCalendar.getStartEndDateRange(
+      baseDate,
+      frequency,
+      interval,
+      hasGenericCalendar,
+      false
+    );
+    var data = StatusCalendar.sanitizeIncomingData(
+      recentStatus,
+      dateRange,
+      frequency,
+      interval,
+      hasGenericCalendar,
+      false
+    );
+    return data;
+  }
+});
+//# sourceMappingURL=StatusCalendarFlyoutKnockoutBinding.js.map

package/bootstrapper/StatusCalendarKnockoutBinding.js

@@ -0,0 +1,107 @@
+define(["require", "exports", "../_generated/Framework"], function (
+  require,
+  exports,
+  Framework_1
+) {
+  "use strict";
+  var StatusCalendarKnockoutBinding = (function () {
+    function StatusCalendarKnockoutBinding() {}
+    StatusCalendarKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var value = valueAccessor();
+      var statusCalendar = ko.utils.unwrapObservable(value.viewModel);
+      element.innerHTML = Framework_1.StatusCalendar.StatusCalendar.template;
+      ko.applyBindings(statusCalendar, element.firstChild);
+      Framework_1.StatusCalendar.StatusCalendar.statusCalendars[value.id] =
+        statusCalendar;
+      return { controlsDescendantBindings: true };
+    };
+    StatusCalendarKnockoutBinding.className = "statusCalendar";
+    return StatusCalendarKnockoutBinding;
+  })();
+  exports.StatusCalendarKnockoutBinding = StatusCalendarKnockoutBinding;
+  var StatusBoxKnockoutBinding = (function () {
+    function StatusBoxKnockoutBinding() {}
+    StatusBoxKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var statusBox = ko.utils.unwrapObservable(valueAccessor());
+      var jQueryElement = $(element);
+      var childNode = document.createElement("div");
+      element.appendChild(childNode);
+      ko.applyBindingsToNode(childNode, {
+        css: statusBox.status,
+        text: statusBox.boxLabel,
+      });
+      jQueryElement.children().addClass("center row");
+      ko.applyBindingsToNode(element, {
+        css: ko.pureComputed(function () {
+          return statusBox.highlight && statusBox.highlight()
+            ? "highlight"
+            : "";
+        }),
+        attr: {
+          title: statusBox.tooltip ? statusBox.tooltip : statusBox.boxLabel,
+        },
+        style: {
+          cursor:
+            statusBox.clickCallback || statusBox.doubleClickCallback
+              ? "pointer"
+              : "default",
+        },
+      });
+      jQueryElement.addClass(
+        "dataFactory-statusCalendar-statusBox dataFactory-statusCalendar-label grow no-shrink col"
+      );
+      var dblClickTimeout = 400;
+      var isDblClick = false;
+      var numberOfClicks = 0;
+      var singleClickHandler = null;
+      if (statusBox.clickCallback) {
+        singleClickHandler = function () {
+          numberOfClicks++;
+          setTimeout(function () {
+            if (!isDblClick) {
+              statusBox.clickCallback(statusBox);
+            }
+            numberOfClicks--;
+            if (numberOfClicks === 0) {
+              isDblClick = false;
+            }
+          }, dblClickTimeout);
+        };
+        jQueryElement.on("click", singleClickHandler);
+      }
+      var doubleClickHandler = null;
+      if (statusBox.doubleClickCallback) {
+        doubleClickHandler = function () {
+          isDblClick = true;
+          statusBox.doubleClickCallback(statusBox);
+        };
+        jQueryElement.on("dblclick", doubleClickHandler);
+      }
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+        if (singleClickHandler) {
+          jQueryElement.off("click", singleClickHandler);
+        }
+        if (doubleClickHandler) {
+          jQueryElement.off("dblclick", doubleClickHandler);
+        }
+      });
+      return { controlsDescendantBindings: true };
+    };
+    StatusBoxKnockoutBinding.className = "statusBox";
+    return StatusBoxKnockoutBinding;
+  })();
+  exports.StatusBoxKnockoutBinding = StatusBoxKnockoutBinding;
+});
+//# sourceMappingURL=StatusCalendarKnockoutBinding.js.map

package/bootstrapper/TelemetryKnockoutBinding.js

@@ -0,0 +1,68 @@
+define([
+  "require",
+  "exports",
+  "../scripts/Framework/Util/Log",
+  "../_generated/Framework",
+  "../scripts/AppContext",
+], function (require, exports, Log, Framework, AppContext) {
+  "use strict";
+  var Telemetry = Framework.Telemetry;
+  var logger = Log.getLogger({
+    loggerName: "TelemetryKnockoutBinding",
+  });
+  var EventConfigs;
+  (function (EventConfigs) {
+    EventConfigs.click = {
+      event: "click",
+      handleEvent: function (data, event, areaId) {
+        Telemetry.instance.logEvent(
+          new Telemetry.Event(
+            AppContext.AppContext.getInstance().factoryId(),
+            areaId,
+            Telemetry.Action.click,
+            Object.create(null)
+          )
+        );
+      },
+    };
+  })((EventConfigs = exports.EventConfigs || (exports.EventConfigs = {})));
+  var TelemetryKnockoutBindingHandler = (function () {
+    function TelemetryKnockoutBindingHandler() {}
+    TelemetryKnockoutBindingHandler.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var value = ko.utils.unwrapObservable(valueAccessor());
+      if (!value.areaId || !value.configs) {
+        logger.logError("Supplying invalid value accessor.");
+        return;
+      }
+      for (var index in value.configs) {
+        var config = EventConfigs[value.configs[index]];
+        var binding = {};
+        binding[config.event] = Framework.Util.curry(
+          function (config, data, event) {
+            var flag = TelemetryKnockoutBindingHandler.processedForADFTelemetry;
+            if (!event.originalEvent[flag]) {
+              config.handleEvent(data, event, value.areaId);
+              event.originalEvent[flag] = true;
+            }
+          },
+          null,
+          config
+        );
+        ko.applyBindingsToNode(element, { event: binding });
+      }
+      return { controlsDescendantBindings: false };
+    };
+    TelemetryKnockoutBindingHandler.className = "telemetry";
+    TelemetryKnockoutBindingHandler.processedForADFTelemetry =
+      "processedForADFTelemetry";
+    return TelemetryKnockoutBindingHandler;
+  })();
+  exports.TelemetryKnockoutBindingHandler = TelemetryKnockoutBindingHandler;
+});
+//# sourceMappingURL=TelemetryKnockoutBinding.js.map

package/bootstrapper/WinJSButtonKnockoutBinding.js

@@ -0,0 +1,72 @@
+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/Framework"], function (
+  require,
+  exports,
+  Framework
+) {
+  "use strict";
+  var WinJSButtonBindingHandler = (function (_super) {
+    __extends(WinJSButtonBindingHandler, _super);
+    function WinJSButtonBindingHandler() {
+      var _this = this;
+      _super.apply(this, arguments);
+      this.init = function (
+        element,
+        valueAccessor,
+        allBindingsAccessor,
+        viewModel,
+        bindingContext
+      ) {
+        ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+          _this._lifetimeManager.dispose();
+        });
+        return { controlsDescendantBindings: true };
+      };
+      this.update = function (
+        element,
+        valueAccessor,
+        allBindingsAccessor,
+        viewModel,
+        bindingContext
+      ) {
+        var buttonElement = $(element)
+          .html("<button class='koMainButton'></button>")
+          .children()[0];
+        var options = ko.unwrap(valueAccessor().options);
+        _this._lifetimeManager.dispose();
+        _this._lifetimeManager =
+          new Framework.Disposable.DisposableLifetimeManager();
+        var button = new Framework.Command.Button(
+          _this._lifetimeManager,
+          options
+        ).appBarCommand(buttonElement);
+        if (valueAccessor().menu) {
+          var menu = ko.unwrap(valueAccessor().menu);
+          if (menu) {
+            menu.addDropdownButton(button);
+          }
+        }
+        $(buttonElement).removeClass($(buttonElement).attr("data-buttonClass"));
+        if (valueAccessor().buttonClass) {
+          $(buttonElement).addClass(ko.unwrap(valueAccessor().buttonClass));
+          $(buttonElement).attr(
+            "data-buttonClass",
+            valueAccessor().buttonClass
+          );
+        }
+      };
+    }
+    return WinJSButtonBindingHandler;
+  })(Framework.Disposable.RootDisposable);
+  exports.WinJSButtonBindingHandler = WinJSButtonBindingHandler;
+});
+//# sourceMappingURL=WinJSButtonKnockoutBinding.js.map

package/bootstrapper/WinJSKnockoutBindings.js

@@ -0,0 +1,49 @@
+define(["require", "exports", "../_generated/Framework"], function (
+  require,
+  exports,
+  Framework
+) {
+  "use strict";
+  var WinJSPivotKnockoutBinding = (function () {
+    function WinJSPivotKnockoutBinding() {}
+    WinJSPivotKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var value = valueAccessor();
+      var lifetimeManager =
+        new Framework.Disposable.DisposableLifetimeManager();
+      if (value.pivotItems) {
+        value.pivotItems.forEach(function (pivotItem) {
+          var pivotItemNode = document.createElement("div");
+          pivotItemNode.innerHTML = pivotItem.template;
+          element.appendChild(pivotItemNode);
+          var pivotItemControl = new WinJS.UI.PivotItem(
+            pivotItemNode,
+            pivotItem.options
+          );
+          lifetimeManager.registerForDispose(pivotItemControl);
+          if (pivotItem.viewModel) {
+            ko.applyBindings(pivotItem.viewModel, pivotItemNode);
+            if (pivotItem.viewModel["dispose"]) {
+              lifetimeManager.registerForDispose(pivotItem.viewModel);
+            }
+          }
+        });
+      }
+      var winControl = new WinJS.UI.Pivot(element, valueAccessor().options);
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+        winControl.dispose();
+        lifetimeManager.dispose();
+      });
+      return { controlsDescendantBindings: true };
+    };
+    WinJSPivotKnockoutBinding.className = "WinJSPivot";
+    return WinJSPivotKnockoutBinding;
+  })();
+  exports.WinJSPivotKnockoutBinding = WinJSPivotKnockoutBinding;
+});
+//# sourceMappingURL=WinJSKnockoutBindings.js.map