@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Handlers/MonitoringViewHandler.js

@@ -0,0 +1,199 @@
+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",
+  "../AppContext",
+  "../Framework/Model/Contracts/ActivityWindow",
+  "../Framework/Util/Log",
+  "../Framework/Model/Filter",
+  "../Framework/Model/MonitoringView",
+  "./MessageHandler",
+  "./RoutingHandler",
+], function (
+  require,
+  exports,
+  AppContext_1,
+  ActivityWindow,
+  Log,
+  Filter,
+  View,
+  MessageHandler,
+  RoutingHandler
+) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "MonitoringViewHandler",
+  });
+  var MonitoringViewHandler = (function (_super) {
+    __extends(MonitoringViewHandler, _super);
+    function MonitoringViewHandler() {
+      var _this = this;
+      _super.call(this);
+      this.extendedProperties =
+        ActivityWindow.ServiceColumnNames.ExtendedProperties;
+      this.monitoringViews = {};
+      this._currentPipelineName = null;
+      this._handleUrlUpdate = function (parsedUrlParams) {
+        var pushNotification = false;
+        var pipelineName =
+          parsedUrlParams[RoutingHandler.urlKeywords.pipeline.value] || null;
+        if (pipelineName !== _this._currentPipelineName) {
+          pushNotification = true;
+          _this._currentPipelineName = pipelineName;
+          if (pipelineName) {
+            logger.logDebug(
+              "Updating filter because of url for pipeline: " + pipelineName
+            );
+            _this.setGlobalPipelineFilter(pipelineName);
+          } else {
+            logger.logDebug("Updating filter because of url");
+            _this.clearGlobalPipelineFilter();
+          }
+        }
+        var monitoringView =
+          parsedUrlParams[RoutingHandler.urlKeywords.view.value] ||
+          MonitoringViewHandler.systemViewNames.recent;
+        if (monitoringView !== _this.getState()) {
+          _this.pushState(MonitoringViewHandler.className, monitoringView);
+          pushNotification = false;
+        }
+        if (pushNotification) {
+          _this.pushNotification();
+        }
+      };
+      var recentFilter = new Filter.State();
+      var failedFilter = new Filter.State();
+      failedFilter
+        .filterState()
+        .windowStates([
+          View.equalityFilterTemplate.format(
+            this.extendedProperties.WindowState,
+            ActivityWindow.States.Failed.name
+          ),
+        ]);
+      var inProgressFilter = new Filter.State();
+      inProgressFilter
+        .filterState()
+        .windowStates([
+          View.equalityFilterTemplate.format(
+            this.extendedProperties.WindowState,
+            ActivityWindow.States.InProgress.name
+          ),
+        ]);
+      var recentMonitoringView = new View.MonitoringView(
+        View.MonitoringViewType.System,
+        MonitoringViewHandler.systemViewNames.recent,
+        "Recent activity windows",
+        recentFilter,
+        new View.Sort(
+          MonitoringViewHandler.sortColumnNames.WindowStart,
+          MonitoringViewHandler.sortDescending
+        )
+      );
+      var failedMonitoringView = new View.MonitoringView(
+        View.MonitoringViewType.System,
+        MonitoringViewHandler.systemViewNames.failed,
+        "Failed activity windows",
+        failedFilter,
+        new View.Sort(
+          MonitoringViewHandler.sortColumnNames.WindowStart,
+          MonitoringViewHandler.sortDescending
+        )
+      );
+      var inProgressMonitoringView = new View.MonitoringView(
+        View.MonitoringViewType.System,
+        MonitoringViewHandler.systemViewNames.inProgress,
+        "In-progress activity windows",
+        inProgressFilter,
+        new View.Sort(
+          MonitoringViewHandler.sortColumnNames.WindowStart,
+          MonitoringViewHandler.sortDescending
+        )
+      );
+      this.monitoringViews = {};
+      this.monitoringViews[MonitoringViewHandler.systemViewNames.recent] =
+        recentMonitoringView;
+      this.monitoringViews[MonitoringViewHandler.systemViewNames.failed] =
+        failedMonitoringView;
+      this.monitoringViews[MonitoringViewHandler.systemViewNames.inProgress] =
+        inProgressMonitoringView;
+      this._routingHandler =
+        AppContext_1.AppContext.getInstance().routingHandler;
+      this._handleUrlUpdate(this._routingHandler.getState());
+      this._routingHandlerSubscription = {
+        name: MonitoringViewHandler.className,
+        callback: this._handleUrlUpdate,
+      };
+      this._routingHandler.register(this._routingHandlerSubscription);
+    }
+    MonitoringViewHandler.prototype.getSelectedView = function () {
+      return this.monitoringViews[this.getState()];
+    };
+    MonitoringViewHandler.prototype.setGlobalPipelineFilter = function (
+      pipelineName
+    ) {
+      for (var monitoringViewId in this.monitoringViews) {
+        var monitoringView = this.monitoringViews[monitoringViewId];
+        if (monitoringView.type === View.MonitoringViewType.System) {
+          monitoringView.filter
+            .filterState()
+            .pipelineNames([
+              View.equalityFilterTemplate.format(
+                this.extendedProperties.PipelineName,
+                pipelineName
+              ),
+            ]);
+        }
+      }
+    };
+    MonitoringViewHandler.prototype.clearGlobalPipelineFilter = function () {
+      for (var monitoringViewId in this.monitoringViews) {
+        var monitoringView = this.monitoringViews[monitoringViewId];
+        if (monitoringView.type === View.MonitoringViewType.System) {
+          monitoringView.filter.filterState().pipelineNames([]);
+        }
+      }
+    };
+    MonitoringViewHandler.prototype.clearFilter = function () {
+      var selectedView = this.getSelectedView();
+      selectedView.filter.clear();
+      this.pushNotification();
+    };
+    MonitoringViewHandler.prototype.pushNotification = function () {
+      this.pushState(MonitoringViewHandler.className, this.getState());
+    };
+    MonitoringViewHandler.prototype.listMonitoringViews = function () {
+      var monitoringViewsArray = [];
+      for (var viewKey in this.monitoringViews) {
+        var viewValue = this.monitoringViews[viewKey];
+        monitoringViewsArray.push(viewValue);
+      }
+      return monitoringViewsArray;
+    };
+    MonitoringViewHandler.prototype.dispose = function () {
+      this._routingHandler.unregister(this._routingHandlerSubscription);
+    };
+    MonitoringViewHandler.className = "MonitoringViewHandler";
+    MonitoringViewHandler.systemViewNames = {
+      recent: "Recent",
+      failed: "Failed",
+      inProgress: "InProgress",
+    };
+    MonitoringViewHandler.sortColumnNames =
+      ActivityWindow.ServiceColumnNames.ExtendedProperties;
+    MonitoringViewHandler.sortAscending = "asc";
+    MonitoringViewHandler.sortDescending = "desc";
+    return MonitoringViewHandler;
+  })(MessageHandler.MessageHandler);
+  exports.MonitoringViewHandler = MonitoringViewHandler;
+});
+//# sourceMappingURL=MonitoringViewHandler.js.map

package/scripts/Handlers/RoutingHandler.js

@@ -0,0 +1,364 @@
+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/ResourceIdUtil",
+  "../Framework/Util/Log",
+  "../Framework/Util/Util",
+  "./MessageHandler",
+], function (require, exports, ResourceIdUtil, Log, Util, MessageHandler) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "RoutingHandler",
+  });
+  exports.urlKeywords = {
+    moduleName: {
+      order: 0,
+      label: "moduleName",
+      value: "modulename",
+    },
+    moduleView: {
+      order: 1,
+      label: "moduleView",
+      value: "moduleview",
+    },
+    subscription: {
+      order: 2,
+      label: "subscription",
+      value: "subscription",
+    },
+    resourceGroup: {
+      order: 3,
+      label: "resourceGroup",
+      value: "resourcegroup",
+    },
+    dataFactory: {
+      order: 4,
+      label: "dataFactory",
+      value: "datafactory",
+    },
+    linkedService: {
+      order: 5,
+      label: "linkedService",
+      value: "linkedservice",
+    },
+    dataset: {
+      order: 6,
+      label: "dataset",
+      value: "dataset",
+    },
+    pipeline: {
+      order: 7,
+      label: "pipeline",
+      value: "pipeline",
+    },
+    view: {
+      order: 8,
+      label: "view",
+      value: "view",
+    },
+  };
+  exports.moduleName = "datafactory";
+  var RoutingHandler = (function (_super) {
+    __extends(RoutingHandler, _super);
+    function RoutingHandler(appContext) {
+      var _this = this;
+      _super.call(this);
+      this._urlKeywordOrdering = [];
+      this._publisherName = null;
+      this._refreshId = 0;
+      this._onRouteChange = function (route) {
+        logger.logDebug("Route changed to: " + route.url);
+        var currentRefreshId = ++_this._refreshId;
+        var isExternal = false;
+        if (!_this._publisherName) {
+          isExternal = true;
+          _this.state = _this._parseRoute(
+            Microsoft.DataStudio.Application.ShellContext.CurrentRoute()
+          );
+        }
+        var publisherName = _this._publisherName || "DataStudio";
+        _this._publisherName = null;
+        if (
+          _this.state[exports.urlKeywords.subscription.value] &&
+          _this.state[exports.urlKeywords.resourceGroup.value] &&
+          _this.state[exports.urlKeywords.dataFactory.value]
+        ) {
+          _this._appContext.factoryId(
+            ResourceIdUtil.createDataFactoryIdString(
+              _this.state[exports.urlKeywords.subscription.value],
+              _this.state[exports.urlKeywords.resourceGroup.value],
+              _this.state[exports.urlKeywords.dataFactory.value]
+            )
+          );
+        } else {
+          return false;
+        }
+        var pipelineName = _this.state[exports.urlKeywords.pipeline.value];
+        if (isExternal && pipelineName) {
+          var pipelineEntityView =
+            _this._appContext.armDataFactoryCache.pipelineCacheObject.createView();
+          var splitFactoryId_1 = _this._appContext.splitFactoryId();
+          pipelineEntityView
+            .fetch({
+              subscriptionId: splitFactoryId_1.subscriptionId,
+              resourceGroupName: splitFactoryId_1.resourceGroupName,
+              factoryName: splitFactoryId_1.dataFactoryName,
+              pipelineName: pipelineName,
+            })
+            .then(
+              function (pipeline) {
+                if (_this._refreshId === currentRefreshId) {
+                  _this.state[exports.urlKeywords.pipeline.value] =
+                    pipeline.name();
+                  _this.notifySubscribers(
+                    publisherName,
+                    Object.keys(_this.subscribers)
+                  );
+                }
+              },
+              function (reason) {
+                if (_this._refreshId === currentRefreshId) {
+                  if (reason.status === 404) {
+                    _this._appContext.dialogHandler.addRequest({
+                      title: ClientResources.pipelineNotFound,
+                      innerHTML: reason.responseJSON.message,
+                      primaryCommandText: ClientResources.ok,
+                      dismissalHandler: function () {
+                        return;
+                      },
+                    });
+                    _this.state[exports.urlKeywords.pipeline.value] = null;
+                    Microsoft.DataStudio.Application.Router.navigate(
+                      _this._buildUrl(_this.state)
+                    );
+                    _this.notifySubscribers(
+                      publisherName,
+                      Object.keys(_this.subscribers)
+                    );
+                  } else {
+                    var errorMessage = null;
+                    if (reason.responseJSON && reason.responseJSON.message) {
+                      errorMessage = reason.responseJSON.message;
+                    } else {
+                      errorMessage = JSON.stringify(reason);
+                    }
+                    _this._appContext.dialogHandler.addRequest({
+                      title: ClientResources.failedToLoadPipelineView,
+                      innerHTML: errorMessage,
+                      primaryCommandText: ClientResources.ok,
+                      dismissalHandler: function () {
+                        return;
+                      },
+                    });
+                    logger.logError(
+                      "Could not get pipeline name {0} for factory {1}. Reason: {2}".format(
+                        pipelineName,
+                        JSON.stringify(splitFactoryId_1),
+                        JSON.stringify(reason)
+                      )
+                    );
+                  }
+                }
+              }
+            );
+        } else {
+          _this.notifySubscribers(
+            publisherName,
+            Object.keys(_this.subscribers)
+          );
+        }
+        return true;
+      };
+      this._lifetimeManager = appContext._lifetimeManager.createChildLifetime();
+      this._appContext = appContext;
+      for (var keyword in exports.urlKeywords) {
+        var value = exports.urlKeywords[keyword];
+        var lowerCaseKeyword = keyword.toLowerCase();
+        if (keyword !== lowerCaseKeyword) {
+          exports.urlKeywords[lowerCaseKeyword] = value;
+        }
+        this._urlKeywordOrdering[value.order] = lowerCaseKeyword;
+      }
+      var currentRoute = this._getCurrentRoute();
+      this._onRouteChange(currentRoute);
+      this._parseExposureControlStrings(currentRoute.query);
+      this._parseTenantExposureControlStrings(currentRoute.query);
+      this._lifetimeManager.registerForDispose(
+        Microsoft.DataStudio.Application.ShellContext.CurrentRoute.subscribe(
+          function (newRoute) {
+            try {
+              _this._onRouteChange(_this._getCurrentRoute());
+            } catch (e) {}
+          }
+        )
+      );
+    }
+    RoutingHandler.prototype.pushState = function (publisherName, newState) {
+      this.state = this._mergeState(newState);
+      var newUrl = this._buildUrl(this.state);
+      this._publisherName = publisherName;
+      Microsoft.DataStudio.Application.Router.navigate(
+        newUrl,
+        null,
+        ClientResources.factoryPropertiesTitle
+      );
+    };
+    RoutingHandler.prototype.pushStateExternal = function (newState) {
+      var mergedState = this._mergeState(newState);
+      var newUrl = window.location.href.replace(window.location.search, "");
+      newUrl += "?" + this._buildUrl(mergedState);
+      window.open(newUrl, "_blank");
+    };
+    RoutingHandler.prototype.dispose = function () {
+      this._lifetimeManager.dispose();
+    };
+    RoutingHandler.prototype._getCurrentRoute = function () {
+      var currentRoute = Microsoft.DataStudio.Application.Router.currentRoute();
+      if (currentRoute.module && currentRoute.arguments) {
+        return currentRoute;
+      }
+      currentRoute.module = RoutingHandler.moduleName;
+      var extensionArgs = currentRoute.extensionArgs;
+      var argsIndex = extensionArgs.indexOf("/");
+      currentRoute.view = extensionArgs.substring(0, argsIndex);
+      var queryIndex = extensionArgs.indexOf("?");
+      if (queryIndex >= 0) {
+        currentRoute.arguments = extensionArgs.substring(
+          argsIndex + 1,
+          queryIndex
+        );
+        currentRoute.query = extensionArgs.substring(queryIndex);
+      } else {
+        currentRoute.arguments = extensionArgs.substring(argsIndex + 1);
+        currentRoute.query = "";
+      }
+      currentRoute.url = [
+        currentRoute.module,
+        currentRoute.view,
+        currentRoute.arguments,
+      ].join("/");
+      return currentRoute;
+    };
+    RoutingHandler.prototype._mergeState = function (newState) {
+      var mergedState = Object.create(null);
+      jQuery.extend(mergedState, this.state, newState);
+      return mergedState;
+    };
+    RoutingHandler.prototype._parseRoute = function (route) {
+      var parsedUrl = Object.create(null);
+      parsedUrl[exports.urlKeywords.moduleName.value] = route.module;
+      parsedUrl[exports.urlKeywords.moduleView.value] = route.view;
+      var args = route.arguments.split("/").filter(function (value) {
+        return !!value;
+      });
+      var length = args.length;
+      for (var i = 0; i < length; i += 2) {
+        if (i + 1 < length) {
+          parsedUrl[args[i].toLowerCase()] = args[i + 1];
+        }
+      }
+      return parsedUrl;
+    };
+    RoutingHandler.prototype._buildUrl = function (localCaseParsedUrl) {
+      var urlString = "";
+      this._urlKeywordOrdering.forEach(function (urlKeyword) {
+        var value = localCaseParsedUrl[urlKeyword];
+        if (value) {
+          if (
+            urlKeyword === exports.urlKeywords.moduleName.value ||
+            urlKeyword === exports.urlKeywords.moduleView.value
+          ) {
+            urlString += value + "/";
+          } else {
+            urlString +=
+              exports.urlKeywords[urlKeyword].value + "/" + value + "/";
+          }
+        }
+      });
+      if (Microsoft.DataStudio.Application.Router.currentRoute().query) {
+        urlString +=
+          Microsoft.DataStudio.Application.Router.currentRoute().query;
+      }
+      return urlString;
+    };
+    RoutingHandler.prototype._parseExposureControlStrings = function (query) {
+      if (!query) {
+        return;
+      }
+      query = query.substring(1);
+      query.split("&").forEach(function (queryOption) {
+        var _a = queryOption.split("="),
+          key = _a[0],
+          value = _a[1];
+        var namespace = key.split(".");
+        if (namespace[0] === "EC") {
+          var ecObject = EC,
+            length_1 = namespace.length;
+          for (var i = 1; i < length_1; i++) {
+            var newObject = ecObject[namespace[i]];
+            if (Util.propertyHasValue(newObject)) {
+              if (newObject instanceof Object) {
+                ecObject = newObject;
+              } else if (i === length_1 - 1) {
+                var ecValue = null;
+                switch (value) {
+                  case "true":
+                    ecValue = true;
+                    break;
+                  case "false":
+                    ecValue = false;
+                    break;
+                  default:
+                    var int = parseInt(value, 0);
+                    if (isNaN(int)) {
+                      ecValue = value;
+                    } else {
+                      ecValue = int;
+                    }
+                }
+                ecObject[namespace[i]] = ecValue;
+              }
+            } else {
+              break;
+            }
+          }
+        }
+      });
+      if (EC.ADF.authoringDeveloperMode) {
+        EC.ADF.authoringPreview = true;
+      }
+    };
+    RoutingHandler.prototype._parseTenantExposureControlStrings = function (
+      query
+    ) {
+      if (!query) {
+        return;
+      }
+      var tenantId;
+      var match = query.match(/[\?&]tenantId=([^\?&\s]*)/);
+      if (match && match[1]) {
+        tenantId = match[1].toLowerCase();
+      }
+      if (
+        tenantId === "72f988bf-86f1-41af-91ab-2d7cd011db47" ||
+        tenantId === "33e01921-4d64-4f8c-a055-5bdaffd5e33d"
+      ) {
+        EC.ADF.authoringPreview = true;
+      }
+    };
+    RoutingHandler.moduleName = "datafactory";
+    return RoutingHandler;
+  })(MessageHandler.MessageHandler);
+  exports.RoutingHandler = RoutingHandler;
+});
+//# sourceMappingURL=RoutingHandler.js.map