@ms-atlas-module/datastudio-datafactory 0.1.36

package/views/Edit/DateTimeFilterViewModel.js

@@ -0,0 +1,211 @@
+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",
+  "../../scripts/Framework/Util/Datetime",
+  "./FilterViewModel",
+  "../../_generated/Framework",
+  "../../scripts/Framework/Util/Log",
+  "../../scripts/Framework/Util/Util",
+], function (require, exports, DateTimeUtil, Filter, Framework, Log, Util) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "DateTimeFilterViewModel",
+  });
+  var DateTimeFilterViewModel = (function (_super) {
+    __extends(DateTimeFilterViewModel, _super);
+    function DateTimeFilterViewModel(lifetimeManager, filterDetails) {
+      var _this = this;
+      _super.call(this, lifetimeManager, filterDetails);
+      this.isActiveFilter = function () {
+        return Util.koPropertyHasValue(_this._filterState);
+      };
+      this.initializeView = function () {
+        _this.dateTimePickerElement.datetimepicker({
+          minDateTime: DateTimeUtil.convertAsStringFromUTCToLocal(
+            _this.viewContext.dateRange().startDate
+          ),
+          maxDateTime: DateTimeUtil.convertAsStringFromUTCToLocal(
+            _this.viewContext.dateRange().endDate
+          ),
+          timeFormat: "hh:mm tt",
+          showOtherMonths: true,
+        });
+        _this.dateTimePickerElement.datetimepicker(
+          "setDate",
+          DateTimeUtil.convertAsStringFromUTCToLocal(_this.defaultDate)
+        );
+      };
+      this.updateViewState = function () {
+        _super.prototype.updateViewStateBase.call(_this);
+        var newMinDateTime;
+        var newMaxDateTime;
+        var globalStartDate = _this.viewContext.dateRange().startDate;
+        var globalEndDate = _this.viewContext.dateRange().endDate;
+        var windowStartFilter = _this.monitoringViewHandler
+          .getSelectedView()
+          .filter.filterState().windowStart;
+        var windowEndFilter = _this.monitoringViewHandler
+          .getSelectedView()
+          .filter.filterState().windowEnd;
+        var selectedDate = DateTimeUtil.convertAsStringFromLocalToUTC(
+          _this.dateTimePickerElement.datetimepicker("getDate")
+        );
+        switch (_this.column) {
+          case _this.extendedProperties.WindowStart:
+            newMinDateTime = globalStartDate;
+            newMaxDateTime =
+              Util.koPropertyHasValue(windowEndFilter) &&
+              windowEndFilter().getTime() < globalEndDate.getTime() &&
+              windowEndFilter().getTime() > globalStartDate.getTime()
+                ? windowEndFilter()
+                : globalEndDate;
+            _this.setDateTimeLimits(newMinDateTime, newMaxDateTime);
+            if (
+              selectedDate.getTime() < globalStartDate.getTime() ||
+              selectedDate.getTime() > globalEndDate.getTime()
+            ) {
+              windowStartFilter(null);
+              _this.dateTimePickerElement.datetimepicker(
+                "setDate",
+                DateTimeUtil.convertAsStringFromUTCToLocal(globalStartDate)
+              );
+            }
+            break;
+          case _this.extendedProperties.WindowEnd:
+            newMinDateTime =
+              Util.koPropertyHasValue(windowStartFilter) &&
+              windowStartFilter().getTime() > globalStartDate.getTime() &&
+              windowStartFilter().getTime() < globalEndDate.getTime()
+                ? windowStartFilter()
+                : globalStartDate;
+            newMaxDateTime = globalEndDate;
+            _this.setDateTimeLimits(newMinDateTime, newMaxDateTime);
+            if (
+              selectedDate.getTime() < globalStartDate.getTime() ||
+              selectedDate.getTime() > globalEndDate.getTime()
+            ) {
+              windowEndFilter(null);
+              _this.dateTimePickerElement.datetimepicker(
+                "setDate",
+                DateTimeUtil.convertAsStringFromUTCToLocal(globalEndDate)
+              );
+            }
+            break;
+          default:
+            logger.logDebug(
+              "updateViewState - column unrecognized: {0}".format(_this.column)
+            );
+        }
+      };
+      this.showFlyout = function () {
+        _this.updateViewState();
+        _super.prototype.showFlyoutBase.call(_this);
+        _this.previousDate = DateTimeUtil.convertAsStringFromLocalToUTC(
+          _this.dateTimePickerElement.datetimepicker("getDate")
+        );
+      };
+      this.okClicked = function () {
+        _this.flyoutControl.hide();
+        _this.currentDate = DateTimeUtil.convertAsStringFromLocalToUTC(
+          _this.dateTimePickerElement.datetimepicker("getDate")
+        );
+        if (
+          _this.currentDate.getTime() === _this.previousDate.getTime() &&
+          _this._filterState() &&
+          _this.currentDate.getTime() === _this._filterState().getTime()
+        ) {
+          return;
+        }
+        switch (_this.column) {
+          case _this.extendedProperties.WindowStart:
+            if (
+              _this.currentDate.getTime() !==
+              _this.viewContext.dateRange().startDate.getTime()
+            ) {
+              _this._updateFilterState(_this.currentDate);
+            }
+            break;
+          case _this.extendedProperties.WindowEnd:
+            if (
+              _this.currentDate.getTime() !==
+              _this.viewContext.dateRange().endDate.getTime()
+            ) {
+              _this._updateFilterState(_this.currentDate);
+            }
+            break;
+          default:
+            logger.logError(
+              "Unexpected column name: " +
+                _this.column +
+                " for adding to filterState."
+            );
+        }
+      };
+      this.cancelClicked = function () {
+        _this.flyoutControl.hide();
+        _this.dateTimePickerElement.datetimepicker(
+          "setDate",
+          DateTimeUtil.convertAsStringFromUTCToLocal(_this.previousDate)
+        );
+      };
+      this.monitoringViewSubscription = {
+        name: DateTimeFilterViewModel.className,
+        callback: this.updateViewState,
+      };
+      this.monitoringViewHandler.register(this.monitoringViewSubscription);
+      this._filterState = this.monitoringViewHandler
+        .getSelectedView()
+        .filter.mapDateTimeColumnToFilterState(this.column);
+    }
+    DateTimeFilterViewModel.prototype.setDateTimeLimits = function (
+      newMinDateTime,
+      newMaxDateTime
+    ) {
+      this.dateTimePickerElement.datetimepicker(
+        "option",
+        "minDateTime",
+        DateTimeUtil.convertAsStringFromUTCToLocal(newMinDateTime)
+      );
+      this.dateTimePickerElement.datepicker(
+        "option",
+        "minDate",
+        DateTimeUtil.convertAsStringFromUTCToLocal(newMinDateTime)
+      );
+      this.dateTimePickerElement.datetimepicker(
+        "option",
+        "maxDateTime",
+        DateTimeUtil.convertAsStringFromUTCToLocal(newMaxDateTime)
+      );
+      this.dateTimePickerElement.datepicker(
+        "option",
+        "maxDate",
+        DateTimeUtil.convertAsStringFromUTCToLocal(newMaxDateTime)
+      );
+    };
+    DateTimeFilterViewModel.prototype._updateFilterState = function (newDate) {
+      if (newDate) {
+        this._filterState(newDate);
+        this.monitoringViewHandler.pushNotification();
+      }
+    };
+    DateTimeFilterViewModel.className =
+      Framework.DataConstants.dateTimeFilterViewModel;
+    DateTimeFilterViewModel.windowStartDateTimePickerSelector =
+      "adf-filterFlyoutStartDateTimePicker";
+    DateTimeFilterViewModel.windowEndDateTimePickerSelector =
+      "adf-filterFlyoutEndDateTimePicker";
+    return DateTimeFilterViewModel;
+  })(Filter.FilterViewModel);
+  exports.DateTimeFilterViewModel = DateTimeFilterViewModel;
+});
+//# sourceMappingURL=DateTimeFilterViewModel.js.map

package/views/Edit/FilterViewModel.js

@@ -0,0 +1,131 @@
+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",
+  "../../scripts/Framework/Model/Contracts/ActivityWindow",
+  "../../scripts/AppContext",
+  "../../scripts/MonitoringViewContext",
+  "../../_generated/Framework",
+  "../../scripts/Framework/Util/Log",
+  "../../scripts/Handlers/MonitoringViewHandler",
+], function (
+  require,
+  exports,
+  ActivityWindowModel,
+  AppContext,
+  MonitoringViewContext_1,
+  Framework,
+  Log,
+  MonitoringViewHandler
+) {
+  "use strict";
+  (function (FilterType) {
+    FilterType[(FilterType["Search"] = 0)] = "Search";
+    FilterType[(FilterType["Checkbox"] = 1)] = "Checkbox";
+    FilterType[(FilterType["SortOnly"] = 2)] = "SortOnly";
+    FilterType[(FilterType["DateTime"] = 3)] = "DateTime";
+  })(exports.FilterType || (exports.FilterType = {}));
+  var FilterType = exports.FilterType;
+  var logger = Log.getLogger({
+    loggerName: "FilterViewModel",
+  });
+  var FilterViewModel = (function (_super) {
+    __extends(FilterViewModel, _super);
+    function FilterViewModel(lifetimeManager, filterDetails) {
+      var _this = this;
+      _super.call(this, lifetimeManager);
+      this.extendedProperties =
+        ActivityWindowModel.ServiceColumnNames.ExtendedProperties;
+      this.sortAscendingClicked = function () {
+        _this.sortClickedHandlerBase(
+          MonitoringViewHandler.MonitoringViewHandler.sortAscending
+        );
+      };
+      this.sortDescendingClicked = function () {
+        _this.sortClickedHandlerBase(
+          MonitoringViewHandler.MonitoringViewHandler.sortDescending
+        );
+      };
+      this.subscriptionName = "{0}/{1}".format(
+        FilterViewModel.className,
+        filterDetails.column
+      );
+      this.appContext = AppContext.AppContext.getInstance();
+      this.viewContext = this.appContext.getViewContext(
+        MonitoringViewContext_1.MonitoringViewContext
+      );
+      this.monitoringViewHandler = this.viewContext.monitoringViewHandler;
+      this.filterType = filterDetails.filterType;
+      this.column = filterDetails.column;
+      this.anchorElement = filterDetails.anchor;
+    }
+    FilterViewModel.prototype.showFlyoutBase = function () {
+      if (this.flyoutControl && this.anchorElement) {
+        this.flyoutControl.show(this.anchorElement);
+      }
+    };
+    FilterViewModel.prototype.updateViewStateBase = function () {
+      var selectedView = this.monitoringViewHandler.getSelectedView();
+      if (selectedView.sort.column === this.column) {
+        if (
+          selectedView.sort.order ===
+          MonitoringViewHandler.MonitoringViewHandler.sortAscending
+        ) {
+          this.flyoutControl.element
+            .querySelector("#adf-sort-asc")
+            .classList.add("adf-activeSortOrder");
+          this.flyoutControl.element
+            .querySelector("#adf-sort-desc")
+            .classList.remove("adf-activeSortOrder");
+        } else {
+          this.flyoutControl.element
+            .querySelector("#adf-sort-desc")
+            .classList.add("adf-activeSortOrder");
+          this.flyoutControl.element
+            .querySelector("#adf-sort-asc")
+            .classList.remove("adf-activeSortOrder");
+        }
+        $(this.flyoutControl.element)
+          .find("[fill]")
+          .attr("class", "adf-fill")
+          .removeAttr("fill");
+        $(this.flyoutControl.element)
+          .find("[stroke]")
+          .attr("class", "adf-stroke")
+          .removeAttr("stroke");
+      } else {
+        this.flyoutControl.element
+          .querySelector("#adf-sort-asc")
+          .classList.remove("adf-activeSortOrder");
+        this.flyoutControl.element
+          .querySelector("#adf-sort-desc")
+          .classList.remove("adf-activeSortOrder");
+      }
+    };
+    FilterViewModel.prototype.sortClickedHandlerBase = function (order) {
+      logger.logInfo(
+        "Updating view's sort to column: {0}, order: {1}".format(
+          this.column,
+          order
+        )
+      );
+      var selectedView = this.monitoringViewHandler.getSelectedView();
+      selectedView.sort.column = this.column;
+      selectedView.sort.order = order;
+      this.monitoringViewHandler.pushNotification();
+    };
+    FilterViewModel.className = "FilterViewModel";
+    return FilterViewModel;
+  })(Framework.Disposable.ChildDisposable);
+  exports.FilterViewModel = FilterViewModel;
+});
+//# sourceMappingURL=FilterViewModel.js.map

package/views/Shared/ProvisioningState.js

@@ -0,0 +1,11 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  exports.failed = "Failed";
+  exports.succedeed = "Succeeded";
+  exports.running = "Running";
+  exports.pendingCreation = "PendingCreation";
+  exports.pendingUpdate = "PendingUpdate";
+  exports.waiting = "Waiting";
+  exports.warning = "Warning";
+});
+//# sourceMappingURL=ProvisioningState.js.map