autnam 1.0.0

package/packages/arcgis-rest-portal/src/util/array.ts

@@ -0,0 +1,16 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+export function chunk<T>(array: T[], size: number) {
+  if (array.length === 0) {
+    return [];
+  }
+
+  const chunks = [];
+
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+
+  return chunks;
+}

package/packages/arcgis-rest-portal/src/util/generic-search.ts

@@ -0,0 +1,111 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  request,
+  IRequestOptions,
+  appendCustomParams,
+  IGroup,
+  IUser
+} from "@esri/arcgis-rest-request";
+import { IItem } from "../helpers.js";
+
+import { SearchQueryBuilder } from "./SearchQueryBuilder.js";
+import { getPortalUrl } from "../util/get-portal-url.js";
+import {
+  ISearchOptions,
+  ISearchGroupContentOptions,
+  ISearchResult
+} from "../util/search.js";
+
+export function genericSearch<T extends IItem | IGroup | IUser>(
+  search:
+    | string
+    | ISearchOptions
+    | ISearchGroupContentOptions
+    | SearchQueryBuilder,
+  searchType: "item" | "group" | "groupContent" | "user"
+): Promise<ISearchResult<T>> {
+  let options: IRequestOptions;
+  if (typeof search === "string" || search instanceof SearchQueryBuilder) {
+    options = {
+      httpMethod: "GET",
+      params: {
+        q: search
+      }
+    };
+  } else {
+    // searchUserAccess has one (knonw) valid value: "groupMember"
+    options = appendCustomParams<ISearchOptions>(
+      search,
+      [
+        "q",
+        "num",
+        "start",
+        "sortField",
+        "sortOrder",
+        "searchUserAccess",
+        "searchUserName"
+      ],
+      {
+        httpMethod: "GET"
+      }
+    );
+  }
+
+  let path;
+  switch (searchType) {
+    case "item":
+      path = "/search";
+      break;
+    case "group":
+      path = "/community/groups";
+      break;
+    case "groupContent":
+      // Need to have groupId property to do group contents search,
+      // cso filter out all but ISearchGroupContentOptions
+      if (
+        typeof search !== "string" &&
+        !(search instanceof SearchQueryBuilder) &&
+        search.groupId
+      ) {
+        path = `/content/groups/${search.groupId}/search`;
+      } else {
+        return Promise.reject(
+          new Error("you must pass a `groupId` option to `searchGroupContent`")
+        );
+      }
+      break;
+    default:
+      // "users"
+      path = "/portals/self/users/search";
+      break;
+  }
+  const url = getPortalUrl(options) + path;
+
+  // send the request
+  return request(url, options).then((r) => {
+    if (r.nextStart && r.nextStart !== -1) {
+      r.nextPage = function () {
+        let newOptions: ISearchOptions;
+
+        if (
+          typeof search === "string" ||
+          search instanceof SearchQueryBuilder
+        ) {
+          newOptions = {
+            q: search,
+            start: r.nextStart
+          };
+        } else {
+          newOptions = search;
+          newOptions.start = r.nextStart;
+        }
+
+        return genericSearch<T>(newOptions, searchType);
+      };
+    }
+
+    return r;
+  });
+}

package/packages/arcgis-rest-portal/src/util/get-portal-settings.ts

@@ -0,0 +1,44 @@
+/* Copyright (c) 2017-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, IRequestOptions, IExtent } from "@esri/arcgis-rest-request";
+
+import { getPortalUrl } from "./get-portal-url.js";
+
+export interface IPortalSettings {
+  allowedRedirectUris: string[];
+  defaultExtent: IExtent;
+  helperServices: { [key: string]: any };
+  informationalBanner: { [key: string]: any };
+  [key: string]: any;
+}
+
+/**
+ * ```js
+ * import { getPortalSettings } from "@esri/arcgis-rest-portal";
+ * //
+ * getPortalSettings()
+ * getPortalSettings("fe8")
+ * getPortalSettings(null, { portal: "https://custom.maps.arcgis.com/sharing/rest/" })
+ * ```
+ * Fetch the settings for the current portal by id. If no id is passed, portals/self/settings will be called
+ * @param id
+ * @param requestOptions
+ */
+export function getPortalSettings(
+  id?: string,
+  requestOptions?: IRequestOptions
+): Promise<IPortalSettings> {
+  // construct the search url
+  const idOrSelf = id ? id : "self";
+  const url = `${getPortalUrl(requestOptions)}/portals/${idOrSelf}/settings`;
+
+  // default to a GET request
+  const options: IRequestOptions = {
+    ...{ httpMethod: "GET" },
+    ...requestOptions
+  };
+
+  // send the request
+  return request(url, options);
+}

package/packages/arcgis-rest-portal/src/util/get-portal-url.ts

@@ -0,0 +1,32 @@
+/* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IRequestOptions, cleanUrl } from "@esri/arcgis-rest-request";
+import { request } from "http";
+
+/**
+ * Helper that returns the appropriate portal url for a given request. `requestOptions.portal` is given
+ * precedence over `authentication.portal`. If neither `portal` nor `authentication` is present,
+ * `www.arcgis.com/sharing/rest` is returned.
+ *
+ * @param requestOptions - Request options that may have authentication manager
+ * @returns Portal url to be used in API requests
+ */
+export function getPortalUrl(requestOptions: IRequestOptions = {}): string {
+  // use portal in options if specified
+  if (requestOptions.portal) {
+    return cleanUrl(requestOptions.portal);
+  }
+
+  // if auth was passed, use that portal
+  if (
+    requestOptions.authentication &&
+    typeof requestOptions.authentication !== "string"
+  ) {
+    // the portal url is already scrubbed in the auth package
+    return requestOptions.authentication.portal;
+  }
+
+  // default to arcgis.com
+  return "https://www.arcgis.com/sharing/rest";
+}

package/packages/arcgis-rest-portal/src/util/get-portal.ts

@@ -0,0 +1,53 @@
+/* Copyright (c) 2017-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, IRequestOptions } from "@esri/arcgis-rest-request";
+
+import { getPortalUrl } from "./get-portal-url.js";
+
+export interface IPortal {
+  id: string;
+  isPortal: boolean;
+  name: string;
+  [key: string]: any;
+}
+
+/**
+ * Get the portal
+ * @param requestOptions
+ */
+export function getSelf(requestOptions?: IRequestOptions): Promise<IPortal> {
+  // just delegate to getPortal w/o an id
+  return getPortal(null, requestOptions);
+}
+
+/**
+ * ```js
+ * import { getPortal } from "@esri/arcgis-rest-request";
+ * //
+ * getPortal()
+ * getPortal("fe8")
+ * getPortal(null, { portal: "https://custom.maps.arcgis.com/sharing/rest/" })
+ * ```
+ * Fetch information about the specified portal by id. If no id is passed, portals/self will be called.
+ * Note that if you intend to request a portal by id and it is different from the portal specified by options.authentication, you must also pass options.portal.
+ * @param id
+ * @param requestOptions
+ */
+export function getPortal(
+  id?: string,
+  requestOptions?: IRequestOptions
+): Promise<IPortal> {
+  // construct the search url
+  const idOrSelf = id ? id : "self";
+  const url = `${getPortalUrl(requestOptions)}/portals/${idOrSelf}`;
+
+  // default to a GET request
+  const options: IRequestOptions = {
+    ...{ httpMethod: "GET" },
+    ...requestOptions
+  };
+
+  // send the request
+  return request(url, options);
+}

package/packages/arcgis-rest-portal/src/util/get-subscription-info.ts

@@ -0,0 +1,43 @@
+/* Copyright (c) 2017-2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, IRequestOptions } from "@esri/arcgis-rest-request";
+
+import { getPortalUrl } from "./get-portal-url.js";
+
+export interface ISubscriptionInfo {
+  id: string;
+  [key: string]: any;
+}
+
+/**
+ * ```js
+ * import { getSubscriptionInfo } from "@esri/arcgis-rest-request";
+ * //
+ * getSubscriptionInfo()
+ * getSubscriptionInfo("fe8")
+ * getSubscriptionInfo(null, { portal: "https://custom.maps.arcgis.com/sharing/rest/" })
+ * ```
+ * Fetch subscription information about the current portal by id. If no id is passed, portals/self/subscriptionInfo will be called
+ * @param id
+ * @param requestOptions
+ */
+export function getSubscriptionInfo(
+  id?: string,
+  requestOptions?: IRequestOptions
+): Promise<ISubscriptionInfo> {
+  // construct the search url
+  const idOrSelf = id ? id : "self";
+  const url = `${getPortalUrl(
+    requestOptions
+  )}/portals/${idOrSelf}/subscriptionInfo`;
+
+  // default to a GET request
+  const options: IRequestOptions = {
+    ...{ httpMethod: "GET" },
+    ...requestOptions
+  };
+
+  // send the request
+  return request(url, options);
+}

package/packages/arcgis-rest-portal/src/util/scrub-control-chars.ts

@@ -0,0 +1,13 @@
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHAR_MATCHER = /[\x00-\x1F\x7F-\x9F\xA0]/g;
+
+/**
+ * Returns a new string with all control characters removed.
+ *
+ * Doesn't remove characters from input string.
+ *
+ * @param str - the string to scrub
+ */
+export function scrubControlChars (str: string) {
+  return str.replace(CONTROL_CHAR_MATCHER, "");
+}

package/packages/arcgis-rest-portal/src/util/search.ts

@@ -0,0 +1,48 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IRequestOptions, IGroup, IUser } from "@esri/arcgis-rest-request";
+import { IItem , IPagingParams } from "../helpers.js";
+import { SearchQueryBuilder } from "./SearchQueryBuilder.js";
+
+
+export interface ISearchOptions extends IRequestOptions, IPagingParams {
+  /** The query string to search against. */
+  q: string | SearchQueryBuilder;
+
+  /** Field to sort by. */
+  sortField?: string;
+
+  /** Describes whether order returns in ascending or descending order. The default is ascending. */
+  sortOrder?: "asc" | "desc";
+  [key: string]: any;
+}
+
+export interface ISearchGroupContentOptions extends ISearchOptions {
+  groupId: string;
+}
+
+/**
+ * Results from an item or group search.
+ */
+export interface ISearchResult<T extends IItem | IGroup | IUser> {
+  query: string; // matches the api's form param
+  total: number;
+  start: number;
+  num: number;
+  nextStart: number;
+  results: T[];
+  nextPage?: () => Promise<ISearchResult<T>>;
+  /**
+   * Aggregations will only be present on item searches when [`fieldCounts`](https://developers.arcgis.com/rest/users-groups-and-items/search.htm#GUID-1C625F8A-4A12-45BB-B537-74C82315759A) are requested.
+   */
+  aggregations?: {
+    counts: Array<{
+      fieldName: string;
+      fieldValues: Array<{
+        value: any;
+        count: number;
+      }>;
+    }>;
+  };
+}

package/packages/arcgis-rest-portal/test/groups/add-users.test.ts

@@ -0,0 +1,238 @@
+/* Copyright (c) 2019 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import fetchMock from "fetch-mock";
+import {
+  addGroupUsers,
+  IAddGroupUsersOptions
+} from "../../src/groups/add-users.js";
+import { ArcGISIdentityManager, encodeParam } from "@esri/arcgis-rest-request";
+import { TOMORROW } from "../../../../scripts/test-helpers.js";
+
+function createUsernames(start: number, end: number): string[] {
+  const usernames = [];
+
+  for (let i = start; i < end; i++) {
+    usernames.push(`username${i}`);
+  }
+
+  return usernames;
+}
+
+describe("add-users", () => {
+  const MOCK_AUTH = new ArcGISIdentityManager({
+    clientId: "clientId",
+    redirectUri: "https://example-app.com/redirect-uri",
+    token: "fake-token",
+    tokenExpires: TOMORROW,
+    refreshToken: "refreshToken",
+    refreshTokenExpires: TOMORROW,
+    refreshTokenTTL: 1440,
+    username: "casey",
+    password: "123456",
+    portal: "https://myorg.maps.arcgis.com/sharing/rest"
+  });
+
+  afterEach(fetchMock.restore);
+
+  it("should send multiple requests for a long user array", (done) => {
+    const requests = [createUsernames(0, 25), createUsernames(25, 35)];
+
+    const responses = [
+      { notAdded: ["username1"] },
+      { notAdded: ["username30"] }
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(
+        encodeParam("users", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params = {
+      id: "group-id",
+      users: createUsernames(0, 35),
+      authentication: MOCK_AUTH
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.notAdded).toEqual(["username1", "username30"]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should send multiple requests for a long admin array", (done) => {
+    const requests = [createUsernames(0, 25), createUsernames(25, 35)];
+
+    const responses = [
+      { notAdded: ["username1"] },
+      { notAdded: ["username30"] }
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(
+        encodeParam("admins", requests.shift().join(","))
+      );
+
+      return responses.shift();
+    });
+
+    const params = {
+      id: "group-id",
+      admins: createUsernames(0, 35),
+      authentication: MOCK_AUTH
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(responses.length).toEqual(0);
+        expect(result.notAdded).toEqual(["username1", "username30"]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should send separate requests for users and admins", (done) => {
+    const requests = [
+      encodeParam("users", ["username1", "username2"]),
+      encodeParam("admins", ["username3"])
+    ];
+
+    fetchMock.post("*", (url, options) => {
+      expect(url).toEqual(
+        "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+      );
+      expect(options.method).toBe("POST");
+      expect(options.body).toContain(encodeParam("f", "json"));
+      expect(options.body).toContain(encodeParam("token", "fake-token"));
+      expect(options.body).toContain(requests.shift());
+
+      return { notAdded: [] };
+    });
+
+    const params = {
+      id: "group-id",
+      users: ["username1", "username2"],
+      admins: ["username3"],
+      authentication: MOCK_AUTH
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(requests.length).toEqual(0);
+        expect(result.notAdded).toEqual([]);
+        expect(result.errors).toBeUndefined();
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should return request failure", (done) => {
+    const responses = [
+      { notAdded: ["username2"] },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3100",
+          message: "error message for add-user request"
+        }
+      },
+      { notAdded: ["username30"] },
+      {
+        error: {
+          code: 400,
+          messageCode: "ORG_3200",
+          message: "error message for add-admin request"
+        }
+      }
+    ];
+
+    fetchMock.post("*", () => responses.shift());
+
+    const params = {
+      id: "group-id",
+      users: createUsernames(0, 30),
+      admins: createUsernames(30, 60),
+      authentication: MOCK_AUTH
+    };
+
+    addGroupUsers(params)
+      .then((result) => {
+        expect(responses.length).toEqual(0);
+
+        const expectedNotAdded = ["username2", "username30"];
+        expect(result.notAdded).toEqual(expectedNotAdded);
+
+        expect(result.errors.length).toEqual(2);
+
+        const errorA = result.errors[0];
+        expect(errorA.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+        );
+        expect(errorA.code).toEqual("ORG_3100");
+        expect(errorA.originalMessage).toEqual(
+          "error message for add-user request"
+        );
+
+        const errorAOptions: any = errorA.options;
+        expect(errorAOptions.users).toEqual(createUsernames(25, 30));
+        expect(errorAOptions.admins).toBeUndefined();
+
+        const errorB = result.errors[1];
+        expect(errorB.url).toEqual(
+          "https://myorg.maps.arcgis.com/sharing/rest/community/groups/group-id/addUsers"
+        );
+        expect(errorB.code).toEqual("ORG_3200");
+        expect(errorB.originalMessage).toEqual(
+          "error message for add-admin request"
+        );
+
+        const errorBOptions: any = errorB.options;
+        expect(errorBOptions.users).toBeUndefined();
+        expect(errorBOptions.admins).toEqual(createUsernames(55, 60));
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+
+  it("should not send any request for zero-length username array", (done) => {
+    const params: IAddGroupUsersOptions = {
+      id: "group-id",
+      users: [],
+      admins: [],
+      authentication: MOCK_AUTH
+    };
+    fetchMock.post("*", () => 200);
+    addGroupUsers(params)
+      .then((result) => {
+        expect(fetchMock.called()).toEqual(false);
+        expect(result.notAdded).toEqual([]);
+        expect(result.errors).toBeUndefined();
+
+        done();
+      })
+      .catch((error) => fail(error));
+  });
+});