@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/Util/Util.js

@@ -0,0 +1,332 @@
+define(["require", "exports", "./Log"], function (require, exports, Log) {
+  "use strict";
+  var logger = Log.getLogger({ loggerName: "Util" });
+  function objectToObservables(obj) {
+    if (ko.isObservable(obj)) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      for (var i = 0; i < obj.length; i++) {
+        obj[i] = objectToObservables(obj[i])();
+      }
+      return ko.observableArray(obj);
+    }
+    if (obj instanceof Object) {
+      for (var prop in obj) {
+        if (obj.hasOwnProperty(prop)) {
+          obj[prop] = objectToObservables(obj[prop]);
+        }
+      }
+      return ko.observable(obj);
+    }
+    return ko.observable(obj);
+  }
+  exports.objectToObservables = objectToObservables;
+  function mergeIntoObservableObject(observableObjectTarget, objectToMerge) {
+    var unwrapped = ko.unwrap(observableObjectTarget);
+    var _loop_1 = function (prop) {
+      if (unwrapped[prop] && ko.isObservable(unwrapped[prop])) {
+        if (Array.isArray(objectToMerge[prop])) {
+          var arr_1 = [];
+          objectToMerge[prop].forEach(function (e) {
+            arr_1.push(objectToObservables(e));
+          });
+          unwrapped[prop](arr_1);
+        } else if (objectToMerge[prop] instanceof Object) {
+          mergeIntoObservableObject(unwrapped[prop], objectToMerge[prop]);
+        } else {
+          unwrapped[prop](objectToMerge[prop]);
+        }
+      } else {
+        unwrapped[prop] = objectToObservables(objectToMerge[prop]);
+      }
+    };
+    for (var prop in objectToMerge) {
+      _loop_1(prop);
+    }
+    for (var prop in unwrapped) {
+      if (objectToMerge[prop] === undefined) {
+        delete unwrapped[prop];
+      }
+    }
+  }
+  exports.mergeIntoObservableObject = mergeIntoObservableObject;
+  function mergeObservableObjects(target, source) {
+    var unwrappedTarget = ko.toJS(target);
+    var unwrappedSource = ko.toJS(source);
+    recursiveExtend(unwrappedTarget, unwrappedSource);
+    return objectToObservables(unwrappedTarget)();
+  }
+  exports.mergeObservableObjects = mergeObservableObjects;
+  function recursiveExtend(target, source) {
+    $.extend(true, target, source);
+  }
+  exports.recursiveExtend = recursiveExtend;
+  function koPropertyHasValue(property) {
+    if (property) {
+      var value = property();
+      return value instanceof Object
+        ? !$.isEmptyObject(value)
+        : propertyHasValue(value);
+    }
+    return false;
+  }
+  exports.koPropertyHasValue = koPropertyHasValue;
+  function propertyHasValue(property) {
+    return !(property === undefined || property === null || property === "");
+  }
+  exports.propertyHasValue = propertyHasValue;
+  function curry(method, scope) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var previousArgs = args;
+    return function () {
+      var _args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        _args[_i - 0] = arguments[_i];
+      }
+      return method.apply(scope, previousArgs.concat(_args));
+    };
+  }
+  exports.curry = curry;
+  function ignoreDependencies(callback, context) {
+    var ignore = ko.computed(
+      { read: callback, deferEvaluation: true },
+      context
+    );
+    try {
+      ignore();
+    } finally {
+      ignore.dispose();
+    }
+  }
+  exports.ignoreDependencies = ignoreDependencies;
+  function subscribeAndCall(observable, lambda, context) {
+    var subscription = context
+      ? observable.subscribe(lambda, context)
+      : observable.subscribe(lambda);
+    if (context) {
+      lambda.call(context, observable());
+    } else {
+      lambda(observable());
+    }
+    return subscription;
+  }
+  exports.subscribeAndCall = subscribeAndCall;
+  function copySelectedText(value) {
+    if (value === void 0) {
+      value = "";
+    }
+    var succeeded = false;
+    try {
+      if (window.clipboardData) {
+        succeeded = window.clipboardData.setData("Text", value);
+      } else {
+        succeeded = document.execCommand("copy");
+      }
+    } catch (err) {
+      logger.logDebug("User declined to give keyboard access", err);
+    }
+    return succeeded;
+  }
+  exports.copySelectedText = copySelectedText;
+  var DefaultDict = (function () {
+    function DefaultDict(generator) {
+      this._map = {};
+      this.generator = generator;
+    }
+    DefaultDict.prototype.get = function (key, defaultValue) {
+      var val = this._map[key];
+      if (val === undefined) {
+        val = defaultValue === undefined ? this.generator() : defaultValue;
+        this._map[key] = val;
+        return val;
+      } else {
+        return val;
+      }
+    };
+    DefaultDict.prototype.set = function (key, value) {
+      this._map[key] = value;
+    };
+    DefaultDict.prototype.keys = function () {
+      return Object.keys(this._map);
+    };
+    DefaultDict.prototype.dispose = function () {
+      for (var key in Object.keys(this._map)) {
+        var val = this._map[key];
+        if (val["dispose"]) {
+          val["dispose"]();
+        }
+      }
+    };
+    return DefaultDict;
+  })();
+  exports.DefaultDict = DefaultDict;
+  function andFilter(first, second) {
+    first = first || null;
+    second = second || null;
+    if (!second) {
+      return first;
+    }
+    if (!first) {
+      return second;
+    }
+    return "({0} and {1})".format(first, second);
+  }
+  exports.andFilter = andFilter;
+  function hashCode(str) {
+    var hashCode = 0,
+      prime = 18446744073709551557;
+    var strLength = str.length;
+    for (var i = 0; i < strLength; i++) {
+      var char = str.charCodeAt(i);
+      hashCode = (hashCode * 128 + char) % prime;
+    }
+    return hashCode.toString();
+  }
+  exports.hashCode = hashCode;
+  function getAzureError(reason) {
+    var result = {
+      message: null,
+      code: null,
+    };
+    if (
+      reason &&
+      reason.status &&
+      reason.status < 500 &&
+      reason.status >= 400 &&
+      (reason.responseText || reason.responseJSON)
+    ) {
+      var json = reason.responseJSON;
+      if (!json) {
+        try {
+          json = JSON.parse(reason.responseText);
+        } catch (e) {
+          json = reason.responseText;
+          return {
+            code: "",
+            message: json,
+          };
+        }
+      }
+      if (json.error) {
+        result.message = json.error.message || "";
+        result.code = json.error.code || "";
+      } else {
+        result.message = json.message || "";
+        result.code = json.code || "";
+      }
+      return result;
+    } else {
+      return null;
+    }
+  }
+  exports.getAzureError = getAzureError;
+  function callIfKoHasValue(koVal, toCall) {
+    if (koPropertyHasValue(koVal)) {
+      toCall(koVal());
+    }
+  }
+  exports.callIfKoHasValue = callIfKoHasValue;
+  function stringArrayToStringMap(array) {
+    var stringMap = {};
+    array.forEach(function (key) {
+      stringMap[key] = true;
+    });
+    return stringMap;
+  }
+  exports.stringArrayToStringMap = stringArrayToStringMap;
+  function stringMapToStringArray(stringMap) {
+    var keys = [];
+    for (var key in stringMap) {
+      keys.push(key);
+    }
+    return keys;
+  }
+  exports.stringMapToStringArray = stringMapToStringArray;
+  function stringMapToValueArray(stringMap) {
+    var values = [];
+    for (var key in stringMap) {
+      values.push(stringMap[key]);
+    }
+    return values;
+  }
+  exports.stringMapToValueArray = stringMapToValueArray;
+  function shallowEqualityCheck(firstArray, secondArray) {
+    if (firstArray.length !== secondArray.length) {
+      return false;
+    }
+    for (var i = 0; i < firstArray.length; i++) {
+      if (firstArray[i] !== secondArray[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  exports.shallowEqualityCheck = shallowEqualityCheck;
+  function escapeHtml(input) {
+    return input
+      .replace(/&/g, "&amp;")
+      .replace(/</g, "&lt;")
+      .replace(/>/g, "&gt;")
+      .replace(/"/g, "&quot;")
+      .replace(/'/g, "&#x27;")
+      .replace(/\//g, "&#x2F;");
+  }
+  exports.escapeHtml = escapeHtml;
+  exports.entityNameRegex = /^([a-z]|[0-9]|_)([^.+?\/<>*%&:\\]){0,259}$/i;
+  function first(array, callback) {
+    var retVal = null;
+    array.some(function (val) {
+      if (callback(val)) {
+        retVal = val;
+        return true;
+      } else {
+        return false;
+      }
+    });
+    return retVal;
+  }
+  exports.first = first;
+  function tryParseJson(valToTry) {
+    try {
+      return JSON.parse(valToTry);
+    } catch (e) {
+      return undefined;
+    }
+  }
+  exports.tryParseJson = tryParseJson;
+  function formatDataSize(size, precision) {
+    if (precision === void 0) {
+      precision = 3;
+    }
+    var units = [
+      ClientResources.unitBytesFull,
+      ClientResources.unitKilobytesShort,
+      ClientResources.unitMegabytesShort,
+      ClientResources.unitGigabytesShort,
+      ClientResources.unitTerabytesShort,
+      ClientResources.unitPetabytesShort,
+    ];
+    if (size < 0) {
+      throw new Error("formatDataSize: Data size cannot be less than zero.");
+    }
+    var prefixDivisor = 1;
+    var sizeInPrefix;
+    for (var i = 0; i < units.length; i++) {
+      if (size < 1024 * prefixDivisor || i === units.length - 1) {
+        sizeInPrefix = size / prefixDivisor;
+        if (i === 0 || i === units.length - 1) {
+          return units[i].format(Math.round(sizeInPrefix));
+        } else {
+          return units[i].format(sizeInPrefix.toPrecision(precision));
+        }
+      }
+      prefixDivisor *= 1024;
+    }
+  }
+  exports.formatDataSize = formatDataSize;
+});
+//# sourceMappingURL=Util.js.map

package/scripts/Framework/Views/HoverFlyout.js

@@ -0,0 +1,92 @@
+define(["require", "exports", "Hulljs", "../Util/Log"], function (
+  require,
+  exports,
+  Hulljs,
+  Log
+) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "HoverFlyout",
+  });
+  exports.ACTION_FOR_SHOW = "mouseenter";
+  exports.FLYOUT_SHOW_DELAY_MS = 200;
+  var flyoutClickeaterSelector = ".win-flyoutmenuclickeater";
+  var afterFlyoutShows, beforeFlyoutHides;
+  function setupFlyoutAutohide(flyout, anchor) {
+    var clickEaterMouseMoveListener;
+    var clickEaterElement = $(flyoutClickeaterSelector)[0];
+    var boundedConvexPolygon = null;
+    afterFlyoutShows = function () {
+      flyout.addEventListener("beforehide", beforeFlyoutHides);
+      var verticesToCover = getRectVertices(
+        flyout.element.getBoundingClientRect()
+      );
+      verticesToCover = verticesToCover.concat(
+        getRectVertices(anchor.getBoundingClientRect())
+      );
+      boundedConvexPolygon = Hulljs(verticesToCover, Infinity, [".x", ".y"]);
+      clickEaterElement.addEventListener(
+        "mousemove",
+        clickEaterMouseMoveListener
+      );
+    };
+    flyout.addEventListener("aftershow", afterFlyoutShows);
+    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();
+      }
+    };
+  }
+  exports.setupFlyoutAutohide = setupFlyoutAutohide;
+  function removeListenersForElement(element) {
+    element.removeEventListener("aftershow", afterFlyoutShows);
+    element.removeEventListener("beforehide", beforeFlyoutHides);
+  }
+  exports.removeListenersForElement = removeListenersForElement;
+  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 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 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);
+  }
+});
+//# sourceMappingURL=HoverFlyout.js.map

package/scripts/Handlers/ErrorHandler.js

@@ -0,0 +1,176 @@
+define(["require", "exports", "../Framework/Util/Log"], function (
+  require,
+  exports,
+  Log
+) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "ErrorHandler",
+  });
+  var ErrorHandler = (function () {
+    function ErrorHandler(appContext) {
+      this._permissionDenied = false;
+      this._appContext = appContext;
+    }
+    ErrorHandler.prototype.makeResourceFailedHandler = function (
+      resource,
+      url,
+      deferred
+    ) {
+      var _this = this;
+      return function (error) {
+        var title = null,
+          html = null,
+          handler = null;
+        url = url || error.requestUrl || "No url specified in handler!";
+        var isUserError = false;
+        if (error.responseJSON) {
+          var code = error.responseJSON.code || error.responseJSON.error.code;
+          if (code) {
+            switch (code) {
+              case "InvalidSubscriptionId":
+              case "SubscriptionNotFound":
+                title = ClientResources.subscriptionNotFound;
+                html =
+                  ClientResources.subscriptionNotFoundErrorMessageText.format(
+                    _this._appContext.splitFactoryId().subscriptionId
+                  );
+                handler = function (result) {
+                  window.location.reload();
+                };
+                break;
+              case "AuthenticationFailed":
+                if (_this._permissionDenied) {
+                  return;
+                } else {
+                  _this._permissionDenied = true;
+                  title = ClientResources.permissionDenied;
+                  html =
+                    ClientResources.resourcePermissionFaliedMessageText.format(
+                      _this._appContext.splitFactoryId().dataFactoryName
+                    );
+                  break;
+                }
+              case "ResourceNotFound":
+                title = ClientResources.resourceNotFound;
+                html = ClientResources.resourceNotFoundMessageText.format(
+                  resource,
+                  _this._appContext.splitFactoryId().dataFactoryName
+                );
+                break;
+              case "TableSliceOutOfRange":
+                title = ClientResources.tableSliceOutOfRange;
+                html =
+                  error.responseJSON.message ||
+                  error.responseJSON.error.message;
+                break;
+              case "AuthorizationFailed":
+                title = ClientResources.authorizationFailed;
+                html = html =
+                  error.responseJSON.message ||
+                  error.responseJSON.error.message;
+                break;
+              default:
+                title = ClientResources.errorOccurredTitle;
+                html =
+                  error.responseJSON.message ||
+                  error.responseJSON.error.message ||
+                  ClientResources.resourceUnknownErrorMessageText.format(
+                    resource,
+                    _this._appContext.splitFactoryId().dataFactoryName
+                  );
+                logger.logError("Unhandled backend error code: " + code);
+            }
+            if (isUserError) {
+              logger.logInfo(
+                "User error (code: {0}, url: {1}): {2}".format(
+                  error.status,
+                  url,
+                  error.response
+                )
+              );
+            } else {
+              logger.logError(
+                "ADF backend error (code: {0}, url: {1}): {2}".format(
+                  error.status,
+                  url,
+                  error.response
+                )
+              );
+            }
+          }
+        }
+        if (!title) {
+          switch (error.status) {
+            case 401:
+            case 403:
+              if (_this._permissionDenied) {
+                return;
+              } else {
+                _this._permissionDenied = true;
+                title = ClientResources.permissionDenied;
+                html =
+                  ClientResources.resourcePermissionFaliedMessageText.format(
+                    _this._appContext.splitFactoryId().dataFactoryName
+                  );
+                break;
+              }
+            case 404:
+              title = ClientResources.resourceNotFound;
+              html = ClientResources.resourceNotFoundMessageText.format(
+                resource,
+                _this._appContext.splitFactoryId().dataFactoryName
+              );
+              break;
+            default:
+              title = ClientResources.unknownError;
+              html = ClientResources.resourceUnknownErrorMessageText.format(
+                resource,
+                _this._appContext.splitFactoryId().dataFactoryName
+              );
+              break;
+          }
+        }
+        if (!handler) {
+          handler = function (result) {};
+        }
+        if (isUserError) {
+          logger.logInfo(
+            'Resource error shown to user: {title: "{0}", message: "{1}", url: {2}}'.format(
+              title,
+              html,
+              url
+            )
+          );
+        } else {
+          logger.logError(
+            'Resource error shown to user: {title: "{0}", message: "{1}", url: {2}}'.format(
+              title,
+              html,
+              url
+            )
+          );
+        }
+        html = html.replace(/\n/g, "<br/>");
+        error.clientsideErrorMessage = html;
+        _this._appContext.dialogHandler.addRequest(
+          {
+            title: title,
+            innerHTML: html,
+            dismissalHandler: handler,
+            primaryCommandText: ClientResources.ok,
+          },
+          true
+        );
+        if (!deferred) {
+          throw error;
+        }
+        deferred.reject(error);
+        return deferred.promise;
+      };
+    };
+    return ErrorHandler;
+  })();
+  exports.ErrorHandler = ErrorHandler;
+});
+//# sourceMappingURL=ErrorHandler.js.map

package/scripts/Handlers/MessageHandler.js

@@ -0,0 +1,115 @@
+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"], function (require, exports) {
+  "use strict";
+  var MessageHandler = (function () {
+    function MessageHandler() {
+      this.state = null;
+      this.subscribers = {};
+    }
+    MessageHandler.prototype.pushState = function (
+      publisherName,
+      newState,
+      listeners
+    ) {
+      if (listeners === void 0) {
+        listeners = null;
+      }
+      this.state = newState;
+      if (listeners === null) {
+        listeners = Object.keys(this.subscribers);
+      }
+      this.notifySubscribers(publisherName, listeners);
+    };
+    MessageHandler.prototype.register = function (newSubscriber) {
+      var subscriptions = [];
+      if (!(newSubscriber.name in this.subscribers)) {
+        this.subscribers[newSubscriber.name] = subscriptions;
+      } else {
+        subscriptions = this.subscribers[newSubscriber.name];
+      }
+      subscriptions.push(newSubscriber);
+    };
+    MessageHandler.prototype.unregister = function (oldSubscriber) {
+      if (!(oldSubscriber.name in this.subscribers)) {
+        return;
+      }
+      var index = this.subscribers[oldSubscriber.name].indexOf(oldSubscriber);
+      if (index !== -1) {
+        this.subscribers[oldSubscriber.name].splice(index, 1);
+      }
+    };
+    MessageHandler.prototype.getState = function () {
+      return this.state;
+    };
+    MessageHandler.prototype.notifySubscribers = function (
+      publisherName,
+      subscriberNames
+    ) {
+      var _this = this;
+      subscriberNames.forEach(function (name) {
+        if (name === publisherName) {
+          return;
+        }
+        _this.subscribers[name].forEach(function (subscriber) {
+          subscriber.callback(_this.state, publisherName);
+        });
+      });
+    };
+    return MessageHandler;
+  })();
+  exports.MessageHandler = MessageHandler;
+  var DefaultMessageHandler = (function (_super) {
+    __extends(DefaultMessageHandler, _super);
+    function DefaultMessageHandler(defaultState, isEmpty) {
+      _super.call(this);
+      this.isEmpty = isEmpty;
+      this.setDefaultState(defaultState);
+    }
+    DefaultMessageHandler.prototype.pushState = function (
+      publisherName,
+      newState,
+      listeners
+    ) {
+      if (listeners === void 0) {
+        listeners = null;
+      }
+      if (this.isEmpty(newState)) {
+        newState = this.defaultState;
+      }
+      _super.prototype.pushState.call(this, publisherName, newState, listeners);
+    };
+    DefaultMessageHandler.prototype.setDefaultState = function (state) {
+      this.defaultState = state;
+      if (this.isEmpty(this.state)) {
+        this.state = state;
+      }
+    };
+    return DefaultMessageHandler;
+  })(MessageHandler);
+  var SelectionHandler = (function (_super) {
+    __extends(SelectionHandler, _super);
+    function SelectionHandler() {
+      _super.apply(this, arguments);
+    }
+    return SelectionHandler;
+  })(DefaultMessageHandler);
+  exports.SelectionHandler = SelectionHandler;
+  var ActivityRunUpdateHandler = (function (_super) {
+    __extends(ActivityRunUpdateHandler, _super);
+    function ActivityRunUpdateHandler() {
+      _super.apply(this, arguments);
+    }
+    return ActivityRunUpdateHandler;
+  })(MessageHandler);
+  exports.ActivityRunUpdateHandler = ActivityRunUpdateHandler;
+});
+//# sourceMappingURL=MessageHandler.js.map