@ms-atlas-module/datastudio-datafactory 0.1.36

package/bootstrapper/CSS/Wizard.css

@@ -0,0 +1,197 @@
+.wizardContentArea {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  -webkit-box-orient: vertical;
+  -webkit-box-direction: normal;
+  -ms-flex-direction: column;
+  flex-direction: column;
+  -ms-flex-wrap: nowrap;
+  flex-wrap: nowrap;
+  -webkit-box-pack: start;
+  -ms-flex-pack: start;
+  justify-content: flex-start;
+  -ms-flex-line-pack: start;
+  align-content: flex-start;
+  -webkit-box-align: stretch;
+  -ms-flex-align: stretch;
+  align-items: stretch;
+  -ms-flex-item-align: stretch;
+  align-self: stretch;
+}
+.wizardPanel {
+  padding-top: 20px;
+  height: calc(100% - 20px);
+  bottom: 0;
+  width: 252px;
+  float: left;
+  background-color: #515151;
+  color: #abadaf;
+  font-family: "Segoe UI";
+}
+.wizardPanel .navItemSelected {
+  color: #515151;
+  background-color: white;
+}
+.wizardPanel
+  .navItemSelected
+  .navItemContainer
+  .navItemSpacer
+  .navItemText.completed {
+  color: #515151;
+}
+.wizardPanel .navItemContainer {
+  overflow: hidden;
+  height: 56px;
+  line-height: 28px;
+  font-size: 16px;
+}
+.wizardPanel .navItemContainer.completed {
+  height: 64px;
+}
+.wizardPanel .navItemContainer .navItemSpacer {
+  margin-top: 10px;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemNumber {
+  float: left;
+  border-radius: 50%;
+  border: solid 2px;
+  width: 28px;
+  height: 28px;
+  text-align: center;
+  margin-left: 22px;
+  font-size: 14px;
+  margin-bottom: -2px;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemNumber.finalItemNumber {
+  border: none;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemNumber.completed {
+  background-color: #00b294;
+  border-color: #00b294;
+  color: white;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemTextContainer {
+  float: left;
+  margin-left: 8px;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemText {
+  font-family: "Segoe UI Semibold";
+  font-size: 18px;
+  line-height: 28px;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemSubheaderText {
+  float: left;
+  font-family: "Segoe UI";
+  font-size: 12px;
+  line-height: 16px;
+}
+.wizardPanel .navItemContainer .navItemSpacer .navItemText.completed {
+  font-weight: bold;
+  color: white;
+}
+.selected .wizardPanel .navItemContainer .navItemSpacer .navItemText.completed {
+  color: violet;
+}
+.wizardPanel .pivotContainer {
+  overflow: hidden;
+  line-height: 20px;
+  height: 37px;
+  font-size: 14px;
+  font-style: normal;
+  margin: 0;
+}
+.wizardPanel .pivotContainer .pivotNumberContainer {
+  position: relative;
+}
+.wizardPanel .pivotContainer .pivotNumberContainer .pivotNumber {
+  float: left;
+  width: 20px;
+  height: 20px;
+  margin-left: 58px;
+  background-color: lightgray;
+  border-radius: 50%;
+  box-sizing: border-box;
+}
+.wizardPanel .pivotContainer .pivotNumberContainer .pivotNumber .pivotSvg {
+  width: 100%;
+  height: 100%;
+}
+.wizardPanel .pivotContainer .pivotNumberContainer .connectorLine {
+  position: absolute;
+  top: 20px;
+  left: 67px;
+  height: 17px;
+  border: solid lightgray 1px;
+}
+.wizardPanel .pivotContainer .pivotNumberContainer .connectorLine.completed {
+  border-color: #00b294;
+}
+.wizardPanel .pivotContainer .pivotNumber.completed {
+  background-color: #00b294;
+}
+.wizardPanel .pivotContainer .pivotNumber.selected {
+  border-width: 2px;
+  border-color: #00b294;
+  border-style: solid;
+  background-color: white;
+}
+.wizardPanel .pivotContainer .pivotText {
+  float: left;
+  margin-left: 8px;
+}
+.wizardPanel .toolNavItemNumber {
+  background-color: green;
+}
+.wizardContentArea {
+  height: 100%;
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+.wizardContentArea input[type="checkbox"] {
+  margin: initial;
+  width: initial;
+  height: initial;
+}
+.wizardContentArea a {
+  color: #008272 !important;
+  text-decoration: underline !important;
+}
+.wizardContentArea .wizardHeader {
+  padding-left: 40px;
+}
+.wizardContentArea .wizardContent {
+  padding-left: 40px;
+  overflow-y: auto;
+  -webkit-box-flex: 1;
+  -ms-flex: auto;
+  flex: auto;
+}
+.wizardContentArea .wizardFooter {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+  padding: 12px 0 16px 40px;
+}
+.wizardContentArea .wizardFooter .nextButton {
+  margin-left: 16px;
+}
+.wizardErrorMessage {
+  margin-left: 40px;
+  margin-bottom: 5px;
+}
+.wizardErrorMessage .errorMessageText {
+  float: left;
+  margin-top: 5px;
+  margin-left: 7px;
+}
+.loadingShield {
+  position: fixed;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  opacity: 0.4;
+  background-color: black;
+}

package/bootstrapper/CalloutBinding.js

@@ -0,0 +1,52 @@
+define([
+  "require",
+  "exports",
+  "../scripts/AppContext",
+  "../_generated/Framework",
+  "css!./CSS/Callout.css",
+], function (require, exports, AppContext, Framework) {
+  "use strict";
+  var Flyout = Framework.HoverFlyout;
+  var CalloutKnockoutBinding = (function () {
+    function CalloutKnockoutBinding() {}
+    CalloutKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var showFlyout = function () {
+        var value = ko.unwrap(valueAccessor());
+        var html = ko.utils.unwrapObservable(value.innerHtml);
+        var calloutRequest = {
+          anchor: element,
+          innerHTML: html,
+          autohide: true,
+          placement: value.placement || "auto",
+        };
+        WinJS.UI.disableAnimations();
+        if (html) {
+          AppContext.AppContext.getInstance().calloutHandler.addRequest(
+            calloutRequest
+          );
+        }
+        WinJS.UI.enableAnimations();
+      };
+      ko.utils.registerEventHandler(
+        element,
+        Flyout.ACTION_FOR_SHOW,
+        showFlyout
+      );
+      ko.utils.domNodeDisposal.addDisposeCallback(element, function () {
+        element.removeEventListener(Flyout.ACTION_FOR_SHOW, showFlyout);
+        Flyout.removeListenersForElement(element);
+      });
+      return { controlsDescendantBindings: false };
+    };
+    CalloutKnockoutBinding.className = "callout";
+    return CalloutKnockoutBinding;
+  })();
+  exports.CalloutKnockoutBinding = CalloutKnockoutBinding;
+});
+//# sourceMappingURL=CalloutBinding.js.map

package/bootstrapper/CollapsibleKnockoutBinding.js

@@ -0,0 +1,70 @@
+define(["require", "exports", "../_generated/Framework"], function (
+  require,
+  exports,
+  Framework
+) {
+  "use strict";
+  var logger = Framework.Log.getLogger({
+    loggerName: "CollapsibleKnockoutBinding",
+  });
+  var CollapsibleKnockoutBinding = (function () {
+    function CollapsibleKnockoutBinding() {}
+    CollapsibleKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var value = valueAccessor();
+      var jQueryElement = $(element);
+      var children = jQueryElement.children();
+      if (children.length !== 2) {
+        logger.logError(
+          "Expected only header and body elements for the collapsible binding. Element: " +
+            JSON.stringify(element.classList)
+        );
+        return;
+      }
+      var _a = children.toArray(),
+        header = _a[0],
+        body = _a[1];
+      var chevronElement = document.createElement("div");
+      if (value.iconFirst) {
+        header.insertBefore(chevronElement, header.firstChild);
+      } else {
+        header.appendChild(chevronElement);
+      }
+      ko.applyBindingsToNode(chevronElement, {
+        html: ko.pureComputed(function () {
+          return value.isExpanded()
+            ? Framework.Svg.collapseUp
+            : Framework.Svg.collapseDown;
+        }),
+        css: "centerYWithoutHeight adf-collapsible-icon",
+      });
+      ko.applyBindingsToNode(header, {
+        click: function () {
+          value.isExpanded(!value.isExpanded());
+        },
+        style: {
+          cursor: "pointer",
+        },
+        css: "centerYWithoutHeight",
+      });
+      ko.applyBindingsToNode(body, {
+        visible: value.isExpanded,
+      });
+      ko.applyBindingsToNode(element, {
+        css: ko.pureComputed(function () {
+          return value.isExpanded() ? "expanded" : "closed";
+        }),
+      });
+      return { controlsDescendantBindings: false };
+    };
+    CollapsibleKnockoutBinding.className = "collapsible";
+    return CollapsibleKnockoutBinding;
+  })();
+  exports.CollapsibleKnockoutBinding = CollapsibleKnockoutBinding;
+});
+//# sourceMappingURL=CollapsibleKnockoutBinding.js.map

package/bootstrapper/CopyBinding.js

@@ -0,0 +1,150 @@
+define([
+  "require",
+  "exports",
+  "../scripts/AppContext",
+  "../scripts/Framework/Util/Log",
+  "../_generated/Framework",
+  "../scripts/Framework/UI/ContextMenu",
+], function (require, exports, AppContext, Log, Framework, ContextMenu_1) {
+  "use strict";
+  var invisibleInputClass = "adf-invisibleInput";
+  var logger = Log.getLogger({
+    loggerName: "CopyBinding",
+  });
+  var CopyCommandGroup = (function () {
+    function CopyCommandGroup() {
+      this.commandGroupName = "CopyCommandGroup";
+      this.commands = [];
+      this._hostElement = null;
+    }
+    CopyCommandGroup.prototype.bindViewModels = function (hostElement) {
+      this._hostElement = hostElement;
+      $(this._hostElement).addClass(Framework.Constants.CSS.copyClass);
+    };
+    CopyCommandGroup.prototype.unbindViewModels = function () {
+      $(this._hostElement).removeClass(Framework.Constants.CSS.copyClass);
+    };
+    CopyCommandGroup.prototype.addCopyCommand = function (copyValue, label) {
+      var _this = this;
+      if (copyValue === void 0) {
+        copyValue = "";
+      }
+      if (label === void 0) {
+        label = ClientResources.copy;
+      }
+      var openPipelineElement = document.createElement("button");
+      var openPipelineCommand = new WinJS.UI.MenuCommand(openPipelineElement, {
+        type: "button",
+        label: label,
+        onclick: function (event) {
+          if (!_this._hostElement) {
+            logger.logError(
+              "Copy command not bound. Triggering event: " +
+                JSON.stringify(event)
+            );
+            return;
+          }
+          var succeeded = copyToClipboard(copyValue);
+          if (!succeeded) {
+            window.prompt(ClientResources.clipboardFallbackMessage, copyValue);
+          } else {
+            window.setTimeout(function () {
+              AppContext.AppContext.getInstance().flyoutHandler.addRequest({
+                anchor: _this._hostElement,
+                innerHTML: ClientResources.copySuccessful,
+                timeout: 1000,
+              });
+            });
+          }
+        },
+      });
+      this.commands.push(openPipelineCommand);
+    };
+    CopyCommandGroup.prototype.addCreateAlertCommand = function () {
+      var _this = this;
+      var createAlertElement = document.createElement("button");
+      var createAlertCommand = new WinJS.UI.MenuCommand(createAlertElement, {
+        type: "button",
+        label: ClientResources.createAlertText,
+        onclick: function (event) {
+          logger.logDebug("Creating alert from activity window");
+          var listeners = [Framework.DataConstants.alertExplorerViewModel];
+          AppContext.AppContext.getInstance().stringMessageHandler.pushState(
+            _this.commandGroupName,
+            "Create alert",
+            listeners
+          );
+        },
+      });
+      this.commands.push(createAlertCommand);
+    };
+    return CopyCommandGroup;
+  })();
+  exports.CopyCommandGroup = CopyCommandGroup;
+  function copyToClipboard(textToCopy) {
+    var textArea = document.createElement("textarea");
+    textArea.className = invisibleInputClass;
+    textArea.value = textToCopy;
+    document.body.appendChild(textArea);
+    textArea.select();
+    var succeeded = Framework.Util.copySelectedText(textToCopy);
+    document.body.removeChild(textArea);
+    return succeeded;
+  }
+  exports.copyToClipboard = copyToClipboard;
+  var CopyBindingHandler = (function () {
+    function CopyBindingHandler() {
+      var _this = this;
+      this.init = function (
+        element,
+        valueAccessor,
+        allBindingsAccessor,
+        viewModel,
+        bindingContext
+      ) {
+        ko.bindingHandlers["event"].init(
+          element,
+          function () {
+            return {
+              contextmenu: _this._copyHandler(
+                element,
+                ko.unwrap(valueAccessor())
+              ),
+            };
+          },
+          allBindingsAccessor,
+          viewModel,
+          bindingContext
+        );
+        return { controlsDescendantBindings: false };
+      };
+      this._copyHandler = function (element, copyValue) {
+        return function (objet, event) {
+          event.stopPropagation();
+          event.preventDefault();
+          var commandGroup = new CopyCommandGroup();
+          if (typeof copyValue === "string") {
+            commandGroup.addCopyCommand(copyValue);
+          } else {
+            copyValue.forEach(function (pair) {
+              commandGroup.addCopyCommand(pair.value, pair.label);
+            });
+          }
+          commandGroup.addCreateAlertCommand();
+          commandGroup.bindViewModels(element);
+          ContextMenu_1.ContextMenu.createContextMenu(
+            {
+              clientX: event.clientX,
+              clientY: event.clientY,
+            },
+            commandGroup
+          );
+        };
+      };
+    }
+    CopyBindingHandler.className = "copy";
+    return CopyBindingHandler;
+  })();
+  exports.CopyBindingHandler = CopyBindingHandler;
+});
+//# sourceMappingURL=CopyBinding.js.map

package/bootstrapper/FilterFlyoutKnockoutBinding.js

@@ -0,0 +1,114 @@
+define([
+  "require",
+  "exports",
+  "../scripts/AppContext",
+  "../scripts/MonitoringViewContext",
+  "../views/Edit/DateTimeFilterViewModel",
+  "../views/Edit/FilterViewModel",
+  "../_generated/Framework",
+  "../scripts/Framework/Util/Log",
+  "text!./Templates/FilterCheckboxTemplate.html",
+  "text!./Templates/FilterDateTimeTemplate.html",
+  "text!./Templates/FilterSearchTemplate.html",
+  "text!./Templates/FilterSortOnlyTemplate.html",
+], function (
+  require,
+  exports,
+  AppContext,
+  MonitoringViewContext_1,
+  DateTimeFilter,
+  Filter,
+  Framework,
+  Log
+) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "FilterFlyoutKnockoutBinding",
+  });
+  var dateTimeFilterViewModel = DateTimeFilter.DateTimeFilterViewModel;
+  var FilterFlyoutKnockoutBinding = (function () {
+    function FilterFlyoutKnockoutBinding() {}
+    FilterFlyoutKnockoutBinding.prototype.init = function (
+      element,
+      valueAccessor,
+      allBindingsAccessor,
+      viewModel,
+      bindingContext
+    ) {
+      var flyout = new WinJS.UI.Flyout(element, { placement: "auto" });
+      var appContext = AppContext.AppContext.getInstance();
+      var viewContext = appContext.getViewContext(
+        MonitoringViewContext_1.MonitoringViewContext
+      );
+      switch (viewModel.filterType) {
+        case Filter.FilterType.Search:
+          element.innerHTML = FilterFlyoutKnockoutBinding.searchTemplate.format(
+            Framework.Svg.sort_up,
+            Framework.Svg.sort_down
+          );
+          break;
+        case Filter.FilterType.Checkbox:
+          element.innerHTML =
+            FilterFlyoutKnockoutBinding.checkboxTemplate.format(
+              Framework.Svg.sort_up,
+              Framework.Svg.sort_down
+            );
+          break;
+        case Filter.FilterType.SortOnly:
+          element.innerHTML =
+            FilterFlyoutKnockoutBinding.sortOnlyTemplate.format(
+              Framework.Svg.sort_up,
+              Framework.Svg.sort_down
+            );
+          break;
+        case Filter.FilterType.DateTime:
+          var dateViewModel = viewModel;
+          switch (viewModel.column) {
+            case viewModel.extendedProperties.WindowStart:
+              element.innerHTML =
+                FilterFlyoutKnockoutBinding.dateTimeTemplate.format(
+                  Framework.Svg.sort_up,
+                  Framework.Svg.sort_down,
+                  dateTimeFilterViewModel.windowStartDateTimePickerSelector
+                );
+              dateViewModel.dateTimePickerElement = $(
+                "." + dateTimeFilterViewModel.windowStartDateTimePickerSelector
+              );
+              dateViewModel.defaultDate = viewContext.dateRange().startDate;
+              break;
+            case viewModel.extendedProperties.WindowEnd:
+              element.innerHTML =
+                FilterFlyoutKnockoutBinding.dateTimeTemplate.format(
+                  Framework.Svg.sort_up,
+                  Framework.Svg.sort_down,
+                  dateTimeFilterViewModel.windowEndDateTimePickerSelector
+                );
+              dateViewModel.dateTimePickerElement = $(
+                "." + dateTimeFilterViewModel.windowEndDateTimePickerSelector
+              );
+              dateViewModel.defaultDate = viewContext.dateRange().endDate;
+              break;
+            default:
+              logger.logError(
+                "Unrecognized column '{0}' for DateTime filter type."
+              );
+          }
+          dateViewModel.initializeView();
+          break;
+        default:
+          logger.logDebug("Unrecognized filter type: " + viewModel.filterType);
+      }
+      viewModel.flyoutControl = flyout;
+      ko.applyBindingsToDescendants(viewModel, element);
+      return { controlsDescendantBindings: true };
+    };
+    FilterFlyoutKnockoutBinding.className = "filterFlyout";
+    FilterFlyoutKnockoutBinding.checkboxTemplate = require("text!./Templates/FilterCheckboxTemplate.html");
+    FilterFlyoutKnockoutBinding.dateTimeTemplate = require("text!./Templates/FilterDateTimeTemplate.html");
+    FilterFlyoutKnockoutBinding.searchTemplate = require("text!./Templates/FilterSearchTemplate.html");
+    FilterFlyoutKnockoutBinding.sortOnlyTemplate = require("text!./Templates/FilterSortOnlyTemplate.html");
+    return FilterFlyoutKnockoutBinding;
+  })();
+  exports.FilterFlyoutKnockoutBinding = FilterFlyoutKnockoutBinding;
+});
+//# sourceMappingURL=FilterFlyoutKnockoutBinding.js.map