delectusnon 1.0.0

package/packages/arcgis-rest-groups/src/search.ts

@@ -0,0 +1,64 @@
+/* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  request,
+  IRequestOptions,
+  getPortalUrl
+} from "@esri/arcgis-rest-request";
+
+import { IPagingParams, IGroup } from "@esri/arcgis-rest-common-types";
+
+export interface IGroupSearchRequest extends IPagingParams {
+  q: string;
+  sortField?: string;
+  sortOrder?: string;
+  [key: string]: any;
+}
+
+export interface IGroupSearchResult {
+  /**
+   * Matches the REST APIs form param
+   */
+  query: string;
+  total: number;
+  start: number;
+  num: number;
+  nextStart: number;
+  results: IGroup[];
+}
+
+/**
+ * Search for groups via the portal api
+ *
+ * ```js
+ * import { searchGroups } from '@esri/arcgis-rest-groups';
+ *
+ * searchgroups({q:'water'})
+ * .then((results) => {
+ *  console.log(response.results.total); // 355
+ * })
+ * ```
+ *
+ * @param searchForm - Search request
+ * @param requestOptions - Options for the request
+ * @returns A Promise that will resolve with the data from the response.
+ */
+export function searchGroups(
+  searchForm: IGroupSearchRequest,
+  requestOptions?: IRequestOptions
+): Promise<IGroupSearchResult> {
+  // construct the search url
+  const url = `${getPortalUrl(requestOptions)}/community/groups`;
+
+  // default to a GET
+  const options: IRequestOptions = {
+    ...{ httpMethod: "GET" },
+    ...requestOptions
+  };
+
+  options.params = { ...searchForm };
+
+  // send the request
+  return request(url, options);
+}

package/packages/arcgis-rest-groups/src/update.ts

@@ -0,0 +1,36 @@
+/* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import {
+  request,
+  IRequestOptions,
+  getPortalUrl
+} from "@esri/arcgis-rest-request";
+
+import { IItemUpdate } from "@esri/arcgis-rest-common-types";
+
+import { serializeGroup } from "./helpers";
+
+export interface IGroupUpdateRequestOptions extends IRequestOptions {
+  group: IItemUpdate;
+}
+
+/**
+ * Update the properties of a group - title, tags etc.
+ * @param requestOptions - Options for the request, including the group
+ * @returns A Promise that will resolve with the success/failure status of the request
+ */
+export function updateGroup(
+  requestOptions: IGroupUpdateRequestOptions
+): Promise<any> {
+  const url = `${getPortalUrl(requestOptions)}/community/groups/${
+    requestOptions.group.id
+  }/update`;
+
+  const options: IGroupUpdateRequestOptions = {
+    ...requestOptions
+  };
+  // serialize the group into something Portal will accept
+  options.params = serializeGroup(requestOptions.group);
+  return request(url, options);
+}

package/packages/arcgis-rest-groups/test/crud.test.ts

@@ -0,0 +1,104 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { createGroup } from "../src/create";
+import { updateGroup } from "../src/update";
+import { removeGroup } from "../src/remove";
+
+import { GroupEditResponse } from "./mocks/responses";
+
+import { encodeParam } from "@esri/arcgis-rest-request";
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should create a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        title: "fake group",
+        owner: "fakeUser",
+        tags: ["foo", "bar"],
+        description: "my fake group"
+      };
+      createGroup({ group: fakeGroup, ...MOCK_REQOPTS })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/createGroup"
+          );
+          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("owner", "fakeUser"));
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(encodeParam("tags", "foo, bar"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should update a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+      const fakeGroup = {
+        id: "5bc",
+        title: "fake group",
+        owner: "fakeUser",
+        tags: ["foo", "bar"],
+        description: "my fake group"
+      };
+      updateGroup({ group: fakeGroup, ...MOCK_REQOPTS })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/update"
+          );
+          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("owner", "fakeUser"));
+          // ensure the array props are serialized into strings
+          expect(options.body).toContain(encodeParam("tags", "foo, bar"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should remove a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      removeGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/delete"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-groups/test/get.test.ts

@@ -0,0 +1,101 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { getGroup, getGroupContent, getGroupUsers } from "../src/get";
+
+import {
+  GroupResponse,
+  GroupContentResponse,
+  GroupUsersResponse
+} from "./mocks/responses";
+
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("getGroup", () => {
+    it("should return a group", done => {
+      fetchMock.once("*", GroupResponse);
+      getGroup("3ef")
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups/3ef?f=json"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("getGroupContent", () => {
+    it("should return group content", done => {
+      fetchMock.once("*", GroupContentResponse);
+      getGroupContent("3ef")
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/groups/3ef?f=json&start=1&num=100"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should return group content, paged", done => {
+      fetchMock.once("*", GroupContentResponse);
+      getGroupContent("3ef", { paging: { start: 4, num: 7 } })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/content/groups/3ef?f=json&start=4&num=7"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should return group users", done => {
+      fetchMock.once("*", GroupUsersResponse);
+
+      getGroupUsers("5bc", MOCK_REQOPTS)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/users?f=json&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-groups/test/mocks/responses.ts

@@ -0,0 +1,141 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IGroupSearchResult } from "../../src/search";
+import { IGroupContentResult, IGroupUsersResult } from "../../src/get";
+
+import { IGroup } from "@esri/arcgis-rest-common-types";
+
+export const GroupSearchResponse: IGroupSearchResult = {
+  query: "* AND owner:dcadmin",
+  total: 358,
+  start: 1,
+  num: 1,
+  nextStart: 2,
+  results: [
+    {
+      id: "ef45564655144f15b5903d05a24493d9",
+      title: "0 alex test",
+      isInvitationOnly: false,
+      owner: "dcadmin",
+      description: null,
+      snippet: "alex test",
+      tags: ["7320", "test", "alex"],
+      phone: null,
+      sortField: "title",
+      sortOrder: "asc",
+      isViewOnly: false,
+      isFav: false,
+      isOpenData: true,
+      thumbnail: null,
+      created: 1427987785000,
+      modified: 1490731120000,
+      provider: null,
+      providerGroupName: null,
+      isReadOnly: false,
+      access: "public",
+      capabilities: [],
+      protected: false,
+      autoJoin: false,
+      notificationsEnabled: false
+    }
+  ]
+};
+
+export const GroupEditResponse: any = {
+  success: true,
+  id: "3efakegroupid"
+};
+
+export const GroupUsersResponse: IGroupUsersResult = {
+  owner: "vader",
+  admins: ["vader", "tarkin"],
+  users: ["luke", "leia"]
+};
+
+export const GroupResponse: IGroup = {
+  id: "ef45564655144f15b5903d05a24493d9",
+  title: "0 alex test",
+  isInvitationOnly: false,
+  owner: "dcadmin",
+  description: "",
+  snippet: "alex test",
+  tags: ["7320", "test", "alex"],
+  phone: "",
+  sortField: "title",
+  sortOrder: "asc",
+  isViewOnly: false,
+  isFav: false,
+  isOpenData: true,
+  thumbnail: null,
+  created: 1427987785000,
+  modified: 1490731120000,
+  provider: null,
+  providerGroupName: null,
+  isReadOnly: false,
+  access: "public",
+  capabilities: [],
+  userMembership: {
+    username: "dcadmin",
+    memberType: "owner",
+    applications: 0
+  },
+  collaborationInfo: {},
+  protected: false,
+  autoJoin: false,
+  notificationsEnabled: false
+};
+
+export const GroupContentResponse: IGroupContentResult = {
+  total: 36,
+  start: 1,
+  num: 1,
+  nextStart: 2,
+  items: [
+    {
+      id: "59dd250ab1a54660b11f4f3434a3e481",
+      owner: "dcadmin",
+      created: 1410610860000,
+      modified: 1498835611000,
+      guid: null,
+      name: "LivingAtlasThemes.pdf",
+      title: "LivingAtlasThemes",
+      type: "PDF",
+      typeKeywords: ["Data", "Document", "PDF"],
+      description: null,
+      tags: ["doc"],
+      snippet: null,
+      thumbnail: "thumbnail/ago_downloaded.png",
+      documentation: null,
+      extent: [],
+      categories: [],
+      spatialReference: null,
+      accessInformation: null,
+      licenseInfo: "CC0",
+      culture: "en-us",
+      properties: null,
+      url: null,
+      proxyFilter: null,
+      access: "public",
+      size: 75476,
+      appCategories: [],
+      industries: [],
+      languages: [],
+      largeThumbnail: null,
+      banner: null,
+      screenshots: [],
+      listed: false,
+      numComments: 0,
+      numRatings: 0,
+      avgRating: 0,
+      numViews: 1301,
+      groupCategories: [],
+      scoreCompleteness: 50,
+      protected: false
+    }
+  ]
+};
+
+export const GroupNotificationResponse: any = {
+  success: true
+};

package/packages/arcgis-rest-groups/test/notification.test.ts

@@ -0,0 +1,102 @@
+import { encodeParam } from "@esri/arcgis-rest-request";
+import * as fetchMock from "fetch-mock";
+
+import { createGroupNotification } from "../src/notification";
+
+import { GroupNotificationResponse } from "./mocks/responses";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("createGroupNotification", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should create an email notification", done => {
+      fetchMock.once("*", GroupNotificationResponse);
+
+      const opts = {
+        id: "3ef",
+        subject: "this is the subject",
+        message: "this is the message",
+        ...MOCK_REQOPTS
+      };
+
+      createGroupNotification(opts)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/createNotification"
+          );
+          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("subject", "this is the subject")
+          );
+          expect(options.body).toContain(
+            encodeParam("message", "this is the message")
+          );
+          expect(options.body).toContain(
+            encodeParam("notificationChannelType", "email")
+          );
+          expect(options.body).toContain(encodeParam("notifyAll", true));
+          expect(response.success).toEqual(true);
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should create an email notification for specific users", done => {
+      fetchMock.once("*", GroupNotificationResponse);
+
+      const opts = {
+        id: "3ef",
+        subject: "this is the subject",
+        message: "this is the message",
+        users: ["casey", "atthebat"],
+        ...MOCK_REQOPTS
+      };
+
+      createGroupNotification(opts)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/3ef/createNotification"
+          );
+          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("subject", "this is the subject")
+          );
+          expect(options.body).toContain(
+            encodeParam("message", "this is the message")
+          );
+          expect(options.body).toContain(
+            encodeParam("notificationChannelType", "email")
+          );
+          expect(options.body).toContain(encodeParam("notifyAll", false));
+          expect(options.body).toContain(
+            encodeParam("users", "casey,atthebat")
+          );
+          expect(response.success).toEqual(true);
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-groups/test/protect.test.ts

@@ -0,0 +1,64 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { protectGroup, unprotectGroup } from "../src/protect";
+
+import { GroupEditResponse } from "./mocks/responses";
+
+import { encodeParam } from "@esri/arcgis-rest-request";
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should protect a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      protectGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/protect"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+    it("should unprotect a group", done => {
+      fetchMock.once("*", GroupEditResponse);
+
+      unprotectGroup({ id: "5bc", ...MOCK_REQOPTS })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups/5bc/unprotect"
+          );
+          expect(options.method).toBe("POST");
+          expect(options.body).toContain(encodeParam("f", "json"));
+          expect(options.body).toContain(encodeParam("token", "fake-token"));
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});

package/packages/arcgis-rest-groups/test/search.test.ts

@@ -0,0 +1,85 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { searchGroups } from "../src/search";
+
+import { GroupSearchResponse } from "./mocks/responses";
+
+import * as fetchMock from "fetch-mock";
+
+describe("groups", () => {
+  afterEach(fetchMock.restore);
+
+  describe("searchGroups", () => {
+    it("should make a simple, unauthenticated group search request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+
+      searchGroups({ q: "water" })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups?f=json&q=water"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+
+    it("should take num, start, sortField, sortOrder and construct the request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+      searchGroups({
+        q: "water",
+        start: 4,
+        num: 7,
+        sortField: "owner",
+        sortOrder: "desc"
+      })
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://www.arcgis.com/sharing/rest/community/groups?f=json&q=water&start=4&num=7&sortField=owner&sortOrder=desc"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+
+  describe("authenticted methods", () => {
+    const MOCK_AUTH = {
+      getToken() {
+        return Promise.resolve("fake-token");
+      },
+      portal: "https://myorg.maps.arcgis.com/sharing/rest"
+    };
+    const MOCK_REQOPTS = {
+      authentication: MOCK_AUTH
+    };
+
+    it("should make a simple, authenticated group search request", done => {
+      fetchMock.once("*", GroupSearchResponse);
+
+      searchGroups({ q: "water" }, MOCK_REQOPTS)
+        .then(response => {
+          expect(fetchMock.called()).toEqual(true);
+          const [url, options]: [string, RequestInit] = fetchMock.lastCall("*");
+          expect(url).toEqual(
+            "https://myorg.maps.arcgis.com/sharing/rest/community/groups?f=json&q=water&token=fake-token"
+          );
+          expect(options.method).toBe("GET");
+          done();
+        })
+        .catch(e => {
+          fail(e);
+        });
+    });
+  });
+});