@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Services/BaseService.js

@@ -0,0 +1,232 @@
+define(["require", "exports", "node-uuid"], function (
+  require,
+  exports,
+  NodeUuid
+) {
+  "use strict";
+  var BaseService = (function () {
+    function BaseService(appContext, classLogger, moduleName) {
+      this.moduleName = null;
+      this._apiVersion = null;
+      this._appContext = null;
+      this._classLogger = null;
+      this._appContext = appContext;
+      this._classLogger = classLogger;
+      this.moduleName = moduleName;
+    }
+    BaseService.prototype.spinner = function () {
+      return this._appContext.spinner.getInstance();
+    };
+    BaseService.prototype.sendMessage = function (
+      relativeUri,
+      type,
+      queryStringParams,
+      postData
+    ) {
+      if (queryStringParams === void 0) {
+        queryStringParams = null;
+      }
+      if (postData === void 0) {
+        postData = null;
+      }
+      var options = {
+        url:
+          relativeUri +
+          (queryStringParams ? "?" + $.param(queryStringParams) : ""),
+        contentType: "application/json",
+        type: type,
+      };
+      if (postData !== null) {
+        options["data"] = JSON.stringify(postData);
+      }
+      return this.ajaxQ(options);
+    };
+    BaseService.prototype.sendFormData = function (
+      relativeUri,
+      type,
+      queryStringParams,
+      postData
+    ) {
+      if (queryStringParams === void 0) {
+        queryStringParams = null;
+      }
+      if (postData === void 0) {
+        postData = null;
+      }
+      var options = {
+        url:
+          relativeUri +
+          (queryStringParams ? "?" + $.param(queryStringParams) : ""),
+        type: type,
+        contentType: false,
+        processData: false,
+      };
+      if (postData !== null) {
+        options["data"] = postData;
+        options["data"]["noApiVersion"] = "true";
+      }
+      return this.ajaxQ(options);
+    };
+    BaseService.prototype.getResponseInfo = function (response) {
+      if (response.response) {
+        return response.response;
+      }
+      if (response.responseText) {
+        return response.responseText;
+      }
+      return "No response text: (" + JSON.stringify(response) + ")";
+    };
+    BaseService.prototype.getAppRelativeUri = function (location) {
+      return (
+        Microsoft.DataStudio.Application.ResourceConstants.AZURE_RESOURCE_URL +
+        location
+      );
+    };
+    BaseService.prototype.ajax = function (request, usingNextLink) {
+      var _this = this;
+      var spinner = this._appContext.spinner.getInstance().on();
+      var deferred = jQuery.Deferred();
+      var subscriptionId =
+        this._appContext.splitFactoryId() &&
+        this._appContext.splitFactoryId().subscriptionId;
+      Microsoft.DataStudio.Managers.AuthenticationManager.instance
+        .getAccessToken(subscriptionId)
+        .then(
+          function (token) {
+            if (!usingNextLink) {
+              request.url = _this.getAppRelativeUri(request.url);
+              if (!request.type || request.type === "GET") {
+                if (!request.data) {
+                  request.data = {};
+                }
+                if (!request.data["api-version"]) {
+                  request.data["api-version"] = _this._apiVersion;
+                }
+              } else {
+                var params = {
+                  "api-version": _this._apiVersion,
+                };
+                if (request.getData) {
+                  jQuery.extend(params, request.getData);
+                }
+                request.url += "?" + jQuery.param(params);
+              }
+            }
+            request.crossDomain = true;
+            if (!request.headers) {
+              request.headers = {};
+            }
+            jQuery.extend(request.headers, {
+              Authorization: "Bearer " + token,
+            });
+            var _a = _this.addClientIdentificationIds(request),
+              requestId = _a.requestId,
+              sessionId = _a.sessionId;
+            _this._classLogger.logInfo(
+              "Making request to {0}".format(request.url),
+              {
+                clientRequestId: requestId,
+              }
+            );
+            var moduleName = _this.moduleName
+              ? _this.moduleName()
+              : "Unspecified";
+            _this.addModuleName(request, moduleName);
+            jQuery.ajax(request).then(
+              function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i - 0] = arguments[_i];
+                }
+                spinner.off();
+                _this._classLogger.logInfo(
+                  "Completed request to {0}".format(request.url),
+                  {
+                    clientRequestId: requestId,
+                    correlationId: _this.getCorrelationId(args[2]),
+                  }
+                );
+                deferred.resolve.apply(deferred, args);
+              },
+              function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i - 0] = arguments[_i];
+                }
+                spinner.off();
+                var reason = args[0];
+                reason.requestUrl = request.url;
+                var errorMessage =
+                  "Api call failed: {0}, Reason: {1}, RequestId: {2}, SessionId: {3}".format(
+                    request.url,
+                    _this.getResponseInfo(reason),
+                    requestId,
+                    sessionId
+                  );
+                _this.logMessage(reason.status, errorMessage, {
+                  clientRequestId: requestId,
+                  correlationId: _this.getCorrelationId(args[0]),
+                });
+                deferred.reject.apply(deferred, args);
+              }
+            );
+          },
+          function (reason) {
+            spinner.off();
+            _this._classLogger.logError(reason.toString(), reason);
+            deferred.reject(reason);
+          }
+        );
+      return deferred.promise();
+    };
+    BaseService.prototype.ajaxQ = function (request, usingNextLink) {
+      if (usingNextLink === void 0) {
+        usingNextLink = false;
+      }
+      var deferred = Q.defer();
+      this.ajax(request, usingNextLink).then(
+        function (data) {
+          deferred.resolve(data);
+        },
+        function (jqXHR) {
+          deferred.reject(jqXHR);
+        }
+      );
+      return deferred.promise;
+    };
+    BaseService.prototype.getBaseUrl = function (baseUrl, baseUrlParams) {
+      return baseUrl
+        .slice()
+        .replace(/{([^}]+)}/g, function (matchedString, varName) {
+          return baseUrlParams[varName].toString();
+        });
+    };
+    BaseService.prototype.addClientIdentificationIds = function (request) {
+      var requestId = NodeUuid.v4();
+      request.headers["x-ms-client-request-id"] = requestId;
+      var sessionId =
+        Microsoft.DataStudio.Managers.AuthenticationManager.instance.getCurrentUser()
+          .sessionId;
+      request.headers["x-ms-client-session-id"] = sessionId;
+      return { requestId: requestId, sessionId: sessionId };
+    };
+    BaseService.prototype.addModuleName = function (request, moduleName) {
+      if (moduleName) {
+        request.headers["x-ms-client-module-name"] = moduleName;
+      }
+    };
+    BaseService.prototype.getCorrelationId = function (response) {
+      return response.getResponseHeader("x-ms-request-id");
+    };
+    BaseService.prototype.logMessage = function (statusCode, message, data) {
+      if (statusCode >= 500) {
+        this._classLogger.logError(message, data);
+      } else {
+        this._classLogger.logInfo(message, data);
+      }
+    };
+    return BaseService;
+  })();
+  exports.BaseService = BaseService;
+});
+//# sourceMappingURL=BaseService.js.map

package/scripts/Services/DataFactoryService.js

@@ -0,0 +1,204 @@
+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",
+  "./BaseService",
+  "../Framework/Util/Log",
+], function (require, exports, BaseService, Log) {
+  "use strict";
+  var logger = Log.getLogger({ loggerName: "DataFactoryService" });
+  var DataFactoryService = (function (_super) {
+    __extends(DataFactoryService, _super);
+    function DataFactoryService(appContext, moduleName) {
+      _super.call(this, appContext, logger, moduleName);
+      this._apiVersion = "2015-10-01";
+      this._identityUrl = "/api/Identity";
+    }
+    DataFactoryService.prototype.logTelemetry = function (data) {
+      return this.ajaxQ({
+        url: "/api/ClientTelemetry",
+        data: data,
+        type: "POST",
+        contentType: "application/json",
+      });
+    };
+    DataFactoryService.prototype.getIdentity = function () {
+      var deferred = Q.defer();
+      var userIdentity = null;
+      if (userIdentity) {
+        deferred.resolve(userIdentity);
+      } else {
+        this.ajaxQ({
+          url: this._identityUrl,
+          type: "GET",
+          contentType: "application/json",
+        }).then(
+          function (identity) {
+            if (identity.GivenName && identity.Surname) {
+              userIdentity = ClientResources.nameFormat.format(
+                identity.GivenName,
+                identity.Surname
+              );
+            } else if (identity.GivenName) {
+              userIdentity = identity.GivenName;
+            } else if (identity.Surname) {
+              userIdentity = identity.Surname;
+            } else {
+              userIdentity = ClientResources.unknownUser;
+            }
+            deferred.resolve(userIdentity);
+          },
+          function (reason) {
+            logger.logError(
+              "Failed to get user identity: {0}".format(reason.responseText)
+            );
+            deferred.reject(reason);
+          }
+        );
+      }
+      return deferred.promise;
+    };
+    DataFactoryService.prototype.getActivityScriptBlob = function (params) {
+      var deferred = Q.defer();
+      this.ajaxQ({
+        url: "/api/datapipeline/GetActivityScriptBlobInfo",
+        data: params,
+        type: "GET",
+      }).then(
+        function (result) {
+          deferred.resolve(result);
+        },
+        function (reason) {
+          logger.logError(
+            "Failed to retrieve activity script blob for params {0}. Reason {1}".format(
+              JSON.stringify(params),
+              JSON.stringify(reason)
+            )
+          );
+          deferred.reject(reason);
+        }
+      );
+      return deferred.promise;
+    };
+    DataFactoryService.prototype.getAppRelativeUri = function (location) {
+      return (
+        Microsoft.DataStudio.Application.Environment.getConstant(
+          "https://s2.datafactory.ext.azure.com",
+          ((_a = {}),
+          (_a[Microsoft.DataStudio.Application.EnvironmentType.CATFOOD] =
+            "https://s1.datafactory.ext.azure.com"),
+          (_a[Microsoft.DataStudio.Application.EnvironmentType.DOGFOOD] =
+            "https://df.datafactory.onecloud-ext.azure-test.net"),
+          _a)
+        ) + location
+      );
+      var _a;
+    };
+    DataFactoryService.prototype.ajax = function (request) {
+      var _this = this;
+      var spinner = this.spinner().on();
+      var deferred = jQuery.Deferred();
+      var splitFactory = this._appContext.splitFactoryId();
+      Microsoft.DataStudio.Managers.AuthenticationManager.instance
+        .getAccessToken(splitFactory && splitFactory.subscriptionId)
+        .then(
+          function (token) {
+            request.url = _this.getAppRelativeUri(request.url);
+            if (!request.data) {
+              request.data = {};
+            }
+            if (typeof request.data === "Object") {
+              if (
+                !request.data["apiVersion"] &&
+                !request.data["noApiVersion"]
+              ) {
+                request.data["apiVersion"] = _this._apiVersion;
+              }
+              delete request.data["noApiVersion"];
+            }
+            request.crossDomain = true;
+            if (!request.headers) {
+              request.headers = {};
+            }
+            jQuery.extend(request.headers, {
+              Authorization: "Bearer " + token,
+            });
+            var _a = _this.addClientIdentificationIds(request),
+              requestId = _a.requestId,
+              sessionId = _a.sessionId;
+            logger.logInfo("Making request to {0}".format(request.url), {
+              clientRequestId: requestId,
+            });
+            _this.addModuleName(request, _this.moduleName());
+            jQuery.ajax(request).then(
+              function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i - 0] = arguments[_i];
+                }
+                spinner.off();
+                logger.logInfo("Completed request to {0}".format(request.url), {
+                  clientRequestId: requestId,
+                  correlationId: _this.getCorrelationId(args[2]),
+                });
+                deferred.resolve.apply(deferred, args);
+              },
+              function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                  args[_i - 0] = arguments[_i];
+                }
+                spinner.off();
+                var reason = args[0];
+                reason.requestUrl = request.url;
+                var errorMessage =
+                  "Api call failed: {0}, Reason: {1}, RequestId: {2}, SessionId: {3}".format(
+                    request.url,
+                    _this.getResponseInfo(reason),
+                    requestId,
+                    sessionId
+                  );
+                _this.logMessage(reason.status, errorMessage, {
+                  clientRequestId: requestId,
+                  correlationId: _this.getCorrelationId(args[0]),
+                });
+                deferred.reject.apply(deferred, args);
+              }
+            );
+          },
+          function (reason) {
+            spinner.off();
+            logger.logError(
+              "ajax request failed: {0}".format(reason.responseText)
+            );
+            deferred.reject(reason);
+          }
+        );
+      return deferred.promise();
+    };
+    DataFactoryService.prototype.ajaxQ = function (request) {
+      var deferred = Q.defer();
+      this.ajax(request).then(
+        function (data) {
+          deferred.resolve(data);
+        },
+        function (jqXHR) {
+          deferred.reject(jqXHR);
+        }
+      );
+      return deferred.promise;
+    };
+    return DataFactoryService;
+  })(BaseService.BaseService);
+  exports.DataFactoryService = DataFactoryService;
+});
+//# sourceMappingURL=DataFactoryService.js.map

package/scripts/Services/HDInsightArmService.js

@@ -0,0 +1,59 @@
+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/Log",
+  "./BaseService",
+], function (require, exports, Log, BaseService) {
+  "use strict";
+  var logger = Log.getLogger({ loggerName: "HDInsightArmService" });
+  var JSON_CONTENT_TYPE = "application/json";
+  var HDInsightArmService = (function (_super) {
+    __extends(HDInsightArmService, _super);
+    function HDInsightArmService(appcontext) {
+      _super.call(this, appcontext, logger);
+      this._apiVersion = "2015-03-01-preview";
+      this._resourceProviderNamespace = "Microsoft.HDInsight";
+      this._baseUrl =
+        "/subscriptions/{subscriptionId}/providers/" +
+        this._resourceProviderNamespace +
+        "/";
+      this._clustersUrl = this._baseUrl + "clusters";
+    }
+    HDInsightArmService.prototype.listClusters = function (baseUrlParams) {
+      var url = this.getBaseUrl(this._clustersUrl, baseUrlParams);
+      var deferred = Q.defer();
+      this.ajaxQ({
+        url: url,
+        type: "GET",
+        contentType: JSON_CONTENT_TYPE,
+      }).then(
+        function (data) {
+          deferred.resolve(data.value);
+        },
+        function (reason) {
+          logger.logError(
+            "Failed to retrieve HDInsight clusters for params {0}. Reason: {1}.".format(
+              JSON.stringify(baseUrlParams),
+              JSON.stringify(reason)
+            )
+          );
+          deferred.reject(reason);
+        }
+      );
+      return deferred.promise;
+    };
+    return HDInsightArmService;
+  })(BaseService.BaseService);
+  exports.HDInsightArmService = HDInsightArmService;
+});
+//# sourceMappingURL=HDInsightArmService.js.map

package/scripts/ViewContext.js

@@ -0,0 +1,9 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var ViewContext = (function () {
+    function ViewContext() {}
+    return ViewContext;
+  })();
+  exports.ViewContext = ViewContext;
+});
+//# sourceMappingURL=ViewContext.js.map