@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/UI/Toolbar.js

@@ -0,0 +1,84 @@
+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",
+  "./Command",
+  "../Shared/Constants",
+  "../Shared/Disposable",
+], function (require, exports, Command, Constants, Disposable) {
+  "use strict";
+  var ToolbarViewModelBase = (function (_super) {
+    __extends(ToolbarViewModelBase, _super);
+    function ToolbarViewModelBase(lifetimeManager, namespace) {
+      if (namespace === void 0) {
+        namespace = null;
+      }
+      _super.call(this, lifetimeManager);
+      this._dataArray = new WinJS.Binding.List();
+      if (namespace !== null) {
+        WinJS.Namespace.define(namespace, {
+          commandList: this._dataArray,
+        });
+      }
+    }
+    ToolbarViewModelBase.removeDropdownMenuFromButton = function (button) {
+      $(button.element).removeClass(Constants.CSS.dropdownMenuClass);
+    };
+    ToolbarViewModelBase.prototype.addButton = function (command) {
+      var button = new Command.Button(
+        this._lifetimeManager,
+        command
+      ).appBarCommand();
+      this._lifetimeManager.registerForDispose(button);
+      this._dataArray.push(button);
+      return button;
+    };
+    ToolbarViewModelBase.prototype.addToggleButton = function (
+      command,
+      observable
+    ) {
+      var button = new Command.Button(this._lifetimeManager, command);
+      this._lifetimeManager.registerForDispose(button);
+      button._command.buttonType("toggle");
+      var appBarCommand = button.appBarCommand();
+      button._command.onclick(function () {
+        observable(appBarCommand.selected);
+      });
+      this._dataArray.push(appBarCommand);
+      return appBarCommand;
+    };
+    ToolbarViewModelBase.prototype.addSeperator = function () {
+      var seperator = new WinJS.UI.AppBarCommand(null, { type: "separator" });
+      this._lifetimeManager.registerForDispose(seperator);
+      this._dataArray.push(seperator);
+    };
+    ToolbarViewModelBase.prototype.addMenuButton = function (
+      command,
+      menuViewModel
+    ) {
+      var menuButton = this.addButton(command);
+      $(menuViewModel.menu().element).addClass(Constants.CSS.dropdownMenuClass);
+      menuButton._command.onclick(function () {
+        var handler = function (event) {
+          $(menuButton.element).removeClass(Constants.CSS.hoveredClass);
+          menuViewModel.menu().removeEventListener("beforehide", handler);
+        };
+        menuViewModel.menu().addEventListener("beforehide", handler);
+        $(menuButton.element).addClass(Constants.CSS.hoveredClass);
+        menuViewModel.showMenu(menuButton.element);
+      });
+    };
+    return ToolbarViewModelBase;
+  })(Disposable.ChildDisposable);
+  exports.ToolbarViewModelBase = ToolbarViewModelBase;
+});
+//# sourceMappingURL=Toolbar.js.map

package/scripts/Framework/Util/Datetime.js

@@ -0,0 +1,258 @@
+define(["require", "exports", "../Shared/Constants"], function (
+  require,
+  exports,
+  Constants
+) {
+  "use strict";
+  var TimeUnit;
+  (function (TimeUnit) {
+    TimeUnit.Millisecond = "Millisecond";
+    TimeUnit.Minute = "Minute";
+    TimeUnit.Hour = "Hour";
+    TimeUnit.Day = "Day";
+    TimeUnit.Week = "Week";
+    TimeUnit.Month = "Month";
+    TimeUnit.Year = "Year";
+  })((TimeUnit = exports.TimeUnit || (exports.TimeUnit = {})));
+  exports.timeUnitToMilliseconds = {};
+  exports.timeUnitToMilliseconds[TimeUnit.Minute] = 60 * 1000;
+  exports.timeUnitToMilliseconds[TimeUnit.Hour] = 60 * 60 * 1000;
+  exports.timeUnitToMilliseconds[TimeUnit.Day] = 24 * 60 * 60 * 1000;
+  exports.timeUnitToMilliseconds[TimeUnit.Week] = 7 * 24 * 60 * 60 * 1000;
+  exports.timeUnitToMilliseconds[TimeUnit.Month] = 28 * 24 * 60 * 60 * 1000;
+  exports.timeUnitToMilliseconds[TimeUnit.Year] = 365 * 24 * 60 * 60 * 1000;
+  exports.shortTime = new Intl.DateTimeFormat(Constants.locale, {
+    hour: "2-digit",
+    hour12: true,
+    minute: "2-digit",
+    timeZone: "UTC",
+  });
+  exports.shortHour = new Intl.DateTimeFormat(Constants.locale, {
+    hour: "2-digit",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.shortDate = new Intl.DateTimeFormat(Constants.locale, {
+    weekday: "short",
+    day: "numeric",
+    month: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.shortMonth = new Intl.DateTimeFormat(Constants.locale, {
+    month: "short",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.shortMonthYear = new Intl.DateTimeFormat(Constants.locale, {
+    month: "short",
+    year: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.fullYear = new Intl.DateTimeFormat(Constants.locale, {
+    year: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.fullDay = new Intl.DateTimeFormat(Constants.locale, {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.fullDate = new Intl.DateTimeFormat(Constants.locale, {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.fullDateWithTimezone = new Intl.DateTimeFormat(Constants.locale, {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+    timeZoneName: "short",
+  });
+  exports.shortDayMonth = new Intl.DateTimeFormat(Constants.locale, {
+    day: "numeric",
+    month: "short",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.format1 = new Intl.DateTimeFormat(Constants.locale, {
+    weekday: "short",
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.narowWeekday = new Intl.DateTimeFormat(Constants.locale, {
+    weekday: "narrow",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  exports.numericHour = new Intl.DateTimeFormat(Constants.locale, {
+    hour: "numeric",
+    hour12: true,
+    timeZone: "UTC",
+  });
+  function getWeekOfTheYear(date) {
+    var weekIndex = 0;
+    var firstJan = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+    var firstSunday = firstJan;
+    while (firstSunday.getUTCDay() !== 0) {
+      weekIndex = 1;
+      firstSunday = new Date(
+        firstSunday.getTime() + exports.timeUnitToMilliseconds[TimeUnit.Day]
+      );
+    }
+    weekIndex += Math.ceil(
+      (date.getTime() - firstSunday.getTime()) /
+        exports.timeUnitToMilliseconds[TimeUnit.Week]
+    );
+    if (
+      date.getUTCDay() === 0 &&
+      date.getTime() % exports.timeUnitToMilliseconds[TimeUnit.Week] === 0
+    ) {
+      weekIndex++;
+    }
+    return weekIndex;
+  }
+  exports.getWeekOfTheYear = getWeekOfTheYear;
+  function getIso8601DateString(rawLocalDate) {
+    return moment(rawLocalDate).toISOString().slice(0, -5) + "Z";
+  }
+  exports.getIso8601DateString = getIso8601DateString;
+  function getUtcTime(rawDate) {
+    var utcTime = moment(rawDate).toISOString();
+    return moment.utc(utcTime).format("MM/DD/YYYY h:mm A [UTC]");
+  }
+  exports.getUtcTime = getUtcTime;
+  function getLocalTime(rawDate) {
+    return moment(rawDate).format("ddd, MM/D/YYYY h:mm A [local]");
+  }
+  exports.getLocalTime = getLocalTime;
+  function getTooltipDate(rawDate) {
+    return getUtcTime(rawDate) + " (" + getLocalTime(rawDate) + ")";
+  }
+  exports.getTooltipDate = getTooltipDate;
+  function getTimePair(rawDate) {
+    return { UTC: getUtcTime(rawDate), local: getLocalTime(rawDate) };
+  }
+  exports.getTimePair = getTimePair;
+  function elapsedTimeToExactString(startTime, endTime) {
+    if (!startTime || !endTime) {
+      throw new Error(
+        "elapsedTimeToExactString: Supplied startTime is '{0}' and endTime is '{1}'.".format(
+          startTime,
+          endTime
+        )
+      );
+    }
+    var milliseconds = endTime.getTime() - startTime.getTime();
+    if (milliseconds < 0) {
+      throw new Error(
+        "elapsedTimeToExactString: endTime cannot be before startTime."
+      );
+    }
+    var seconds = Math.round(milliseconds / 1000);
+    var hours = Math.floor(seconds / 3600);
+    seconds -= hours * 3600;
+    var days = Math.floor(hours / 24);
+    hours -= days * 24;
+    var minutes = Math.floor(seconds / 60);
+    seconds -= minutes * 60;
+    return (
+      (days > 0 ? days + ":" : "") +
+      (hours < 10 ? "0" + hours : hours.toString()) +
+      ":" +
+      (minutes < 10 ? "0" + minutes : minutes.toString()) +
+      ":" +
+      (seconds < 10 ? "0" + seconds : seconds.toString())
+    );
+  }
+  exports.elapsedTimeToExactString = elapsedTimeToExactString;
+  function getDateRangeObservable(initialValue) {
+    var _dateRange = ko.observable(initialValue);
+    var dateRange = ko.pureComputed({
+      read: function () {
+        return _dateRange();
+      },
+      write: function (value) {
+        if (!value.startDate || !value.endDate) {
+          return;
+        }
+        if (
+          !_dateRange() ||
+          value.startDate.getTime() !== _dateRange().startDate.getTime() ||
+          value.endDate.getTime() !== _dateRange().endDate.getTime()
+        ) {
+          _dateRange(value);
+        }
+      },
+    });
+    return dateRange;
+  }
+  exports.getDateRangeObservable = getDateRangeObservable;
+  function convertAsStringFromLocalToUTC(date) {
+    return new Date(
+      Date.UTC(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds(),
+        date.getMilliseconds()
+      )
+    );
+  }
+  exports.convertAsStringFromLocalToUTC = convertAsStringFromLocalToUTC;
+  function convertAsStringFromUTCToLocal(date) {
+    return new Date(
+      date.getUTCFullYear(),
+      date.getUTCMonth(),
+      date.getUTCDate(),
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds(),
+      date.getUTCMilliseconds()
+    );
+  }
+  exports.convertAsStringFromUTCToLocal = convertAsStringFromUTCToLocal;
+  function durationToExactString(milliseconds) {
+    if (milliseconds < 0) {
+      throw new Error(
+        "milliseconds: " +
+          milliseconds +
+          " is not a valid value to evaluate duration."
+      );
+    }
+    var seconds = Math.round(milliseconds / 1000);
+    var minutes = Math.floor(seconds / 60);
+    seconds -= minutes * 60;
+    var hours = Math.floor(minutes / 60);
+    minutes -= hours * 60;
+    var days = Math.floor(hours / 24);
+    hours -= days * 24;
+    return (
+      (days > 0 ? days + ":" : "") +
+      (hours < 10 ? "0" + hours : hours.toString()) +
+      ":" +
+      (minutes < 10 ? "0" + minutes : minutes.toString()) +
+      ":" +
+      (seconds < 10 ? "0" + seconds : seconds.toString())
+    );
+  }
+  exports.durationToExactString = durationToExactString;
+});
+//# sourceMappingURL=Datetime.js.map

package/scripts/Framework/Util/Log.js

@@ -0,0 +1,10 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var Logging = Microsoft.DataStudio.Diagnostics.Logging;
+  var loggerFactory = new Logging.LoggerFactory({ moduleName: "DataFactory" });
+  function getLogger(data) {
+    return loggerFactory.getLogger(data);
+  }
+  exports.getLogger = getLogger;
+});
+//# sourceMappingURL=Log.js.map

package/scripts/Framework/Util/ResourceIdUtil.js

@@ -0,0 +1,56 @@
+define(["require", "exports", "../Shared/DataConstants", "./Log"], function (
+  require,
+  exports,
+  DataConstants,
+  Log
+) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "ResourceIdUtil",
+  });
+  function splitResourceString(resourceId) {
+    var splitString = resourceId.split("/");
+    var id;
+    if (splitString.length !== 9) {
+      logger.logError(
+        "Split resource string utility: expected 9 segments, found: {0}, input string: {1}".format(
+          splitString.length,
+          resourceId
+        )
+      );
+    }
+    id = {
+      subscriptionId: splitString[2],
+      resourceGroupName: splitString[4],
+      dataFactoryName: splitString[8],
+    };
+    return id;
+  }
+  exports.splitResourceString = splitResourceString;
+  function createDataFactoryIdString(
+    subscriptionId,
+    resourceGroupName,
+    dataFactoryName
+  ) {
+    return "/subscriptions/{0}/resourcegroups/{1}/providers/{2}/{3}".format(
+      subscriptionId,
+      resourceGroupName,
+      DataConstants.DataFactoryResourceId,
+      dataFactoryName
+    );
+  }
+  exports.createDataFactoryIdString = createDataFactoryIdString;
+  function createDataFactoryIdString2(id) {
+    return createDataFactoryIdString(
+      id.subscriptionId,
+      id.resourceGroupName,
+      id.dataFactoryName
+    );
+  }
+  exports.createDataFactoryIdString2 = createDataFactoryIdString2;
+  function getResourceGroupId(resourceId) {
+    return resourceId.split("/").slice(0, 5).join("/");
+  }
+  exports.getResourceGroupId = getResourceGroupId;
+});
+//# sourceMappingURL=ResourceIdUtil.js.map

package/scripts/Framework/Util/Security.js

@@ -0,0 +1,73 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  function checkIfPermissionsMatchesRules(actionsToCheck, permissionRules) {
+    var parsedActionsToCheck = actionsToCheck.map(function (actionToCheck) {
+      return parseAction(actionToCheck);
+    });
+    var parsedPermissionRules = permissionRules.map(function (permissionRule) {
+      return {
+        parsedActions: permissionRule.actions
+          ? permissionRule.actions.map(function (action) {
+              return parseAction(action);
+            })
+          : null,
+        parsedNotActions: permissionRule.notActions
+          ? permissionRule.notActions.map(function (notAction) {
+              return parseAction(notAction);
+            })
+          : null,
+      };
+    });
+    var matchesAnyNotAction = parsedPermissionRules.some(function (
+      parsedPermissionRule
+    ) {
+      if (parsedPermissionRule.parsedNotActions) {
+        return parsedPermissionRule.parsedNotActions.some(function (
+          parsedNotAction
+        ) {
+          return parsedActionsToCheck.some(function (parsedActionToCheck) {
+            return checkIfActionMatchesRule(
+              parsedActionToCheck,
+              parsedNotAction
+            );
+          });
+        });
+      }
+      return false;
+    });
+    if (matchesAnyNotAction) {
+      return false;
+    }
+    return parsedPermissionRules.some(function (parsedPermissionRule) {
+      if (parsedPermissionRule.parsedActions) {
+        return parsedPermissionRule.parsedActions.some(function (parsedAction) {
+          return parsedActionsToCheck.some(function (parsedActionToCheck) {
+            return checkIfActionMatchesRule(parsedActionToCheck, parsedAction);
+          });
+        });
+      }
+      return false;
+    });
+  }
+  exports.checkIfPermissionsMatchesRules = checkIfPermissionsMatchesRules;
+  function parseAction(actionRule) {
+    actionRule = actionRule.replace("*", ".*");
+    var lastOccurenceOfSlash = actionRule.lastIndexOf("/");
+    var resourceType = actionRule.substring(0, lastOccurenceOfSlash) || ".*";
+    resourceType = resourceType.replace(/\/\.\*$/, ".*");
+    var verb = actionRule.substring(lastOccurenceOfSlash + 1) || ".*";
+    return {
+      resourceType: resourceType,
+      resourceTypeRegex: new RegExp(resourceType),
+      verb: verb,
+      verbRegex: new RegExp(verb),
+    };
+  }
+  function checkIfActionMatchesRule(permission, actionRule) {
+    return (
+      actionRule.resourceTypeRegex.test(permission.resourceType) &&
+      actionRule.verbRegex.test(permission.verb)
+    );
+  }
+});
+//# sourceMappingURL=Security.js.map