autculpa 1.0.0

package/packages/arcgis-rest-portal/src/orgs/notification.ts

@@ -0,0 +1,148 @@
+import {
+  request,
+  IRequestOptions,
+  ArcGISRequestError
+} from "@esri/arcgis-rest-request";
+import { getPortalUrl } from "../util/get-portal-url.js";
+import { chunk } from "../util/array.js";
+
+export interface ICreateOrgNotificationOptions extends IRequestOptions {
+  /**
+   * Subject of the notification. This only applies to email and builtin notifications. For push notifications, subject/title is provided as a part of the message payload.
+   */
+  subject?: string;
+  /**
+   * Message to be sent. For builtin and email notifications this is a string. For push notifications, this will be JSON.
+   */
+  message: string | object;
+  /**
+   * Array of usernames of the users in the group to whom the message should be sent. If not provided, the message will be sent to all users in the group if the user is an admin. Only group admins will be able to send notifications to a list of users. Group users will be able to send notifications to only one user at a time.
+   */
+  users?: string[];
+  /**
+   * The channel through which the notification is to be delivered. Supported values are email or builtin. Email will be sent when the email option is chosen. If the builtin option is chosen, a notification will be added to the notifications list that the user can see when logged into the home app.
+   */
+  notificationChannelType?: string;
+
+  /**
+   * How many emails should be sent at a time. Defaults to the max possible (25)
+   */
+  batchSize?: number;
+}
+
+export interface ICreateOrgNotificationResult {
+  /**
+   * Whether the operation was successful
+   */
+  success: boolean;
+  /**
+   * An array of request errors
+   */
+  errors?: ArcGISRequestError[];
+}
+
+/**
+ * Send a notification to members of the requesting user's org.
+ * Operation success will be indicated by a flag on the return
+ * object. If there are any errors, they will be placed in an
+ * errors array on the return object
+ *
+ * ```js
+ * const authentication: IAuthenticationManager; // Typically passed into to the function
+ * //
+ * const options: IInviteGroupUsersOptions = {
+ *  id: 'group_id',
+ *  users: ['larry', 'curly', 'moe'],
+ *  notificationChannelType: 'email',
+ *  expiration: 20160,
+ *  authentication
+ * }
+ * //
+ * const result = await createOrgNotification(options);
+ * //
+ * const if_success_result_looks_like = {
+ *  success: true
+ * }
+ * //
+ * const if_failure_result_looks_like = {
+ *  success: false,
+ *  errors: [ArcGISRequestError]
+ * }
+ * ```
+ * @param {ICreateOrgNotificationOptions} options
+ *
+ * @returns {ICreateOrgNotificationResult}
+ */
+export function createOrgNotification(options: ICreateOrgNotificationOptions) {
+  const url = `${getPortalUrl(options)}/portals/self/createNotification`;
+  const batches = _generateBatchRequests(options);
+  const promises = batches.map((batch) => _sendSafeRequest(url, batch));
+
+  return Promise.all(promises).then(_combineResults);
+}
+
+/**
+ * @private
+ */
+function _generateBatchRequests(
+  options: ICreateOrgNotificationOptions
+): IRequestOptions[] {
+  const userBatches: string[][] = chunk<string>(
+    options.users,
+    options.batchSize || 25
+  );
+  return userBatches.map((users) => _generateRequestOptions(users, options));
+}
+
+/**
+ * @private
+ */
+function _generateRequestOptions(
+  users: string[],
+  baseOptions: ICreateOrgNotificationOptions
+): IRequestOptions {
+  const requestOptions: ICreateOrgNotificationOptions = Object.assign(
+    {},
+    baseOptions
+  );
+
+  requestOptions.params = {
+    ...requestOptions.params,
+    users,
+    subject: baseOptions.subject,
+    message: baseOptions.message,
+    notificationChannelType: requestOptions.notificationChannelType
+  };
+
+  return requestOptions;
+}
+
+/**
+ * @private
+ */
+function _sendSafeRequest(
+  url: string,
+  requestOptions: IRequestOptions
+): Promise<ICreateOrgNotificationResult> {
+  return request(url, requestOptions).catch((error) => ({ errors: [error] }));
+}
+
+/**
+ * @private
+ */
+function _combineResults(
+  responses: ICreateOrgNotificationResult[]
+): ICreateOrgNotificationResult {
+  const success = responses.every((res) => res.success);
+  const errors: ArcGISRequestError[] = responses.reduce(
+    (collection, res) => collection.concat(res.errors || []),
+    []
+  );
+  const combined: ICreateOrgNotificationResult = { success };
+
+  if (errors.length > 0) {
+    combined.errors = errors;
+  }
+
+  return combined;
+}

package/packages/arcgis-rest-portal/src/services/get-unique-service-name.ts

@@ -0,0 +1,35 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { isServiceNameAvailable } from "./is-service-name-available.js";
+
+/**
+ * Given a starting name, return a service name that is unique within
+ * the current users organization
+ *
+ * @export
+ * @param {string} name
+ * @param {ArcGISIdentityManager} session
+ * @param {number} step
+ * @return {*}  {Promise<string>}
+ */
+export function getUniqueServiceName(
+  name: string,
+  type: string,
+  session: ArcGISIdentityManager,
+  step: number
+): Promise<string> {
+  let nameToCheck = name;
+  if (step) {
+    nameToCheck = `${name}_${step}`;
+  }
+  return isServiceNameAvailable(nameToCheck, type, session).then((response) => {
+    if (response.available) {
+      return nameToCheck;
+    } else {
+      step = step + 1;
+      return getUniqueServiceName(name, type, session, step);
+    }
+  });
+}

package/packages/arcgis-rest-portal/src/services/is-service-name-available.ts

@@ -0,0 +1,29 @@
+/* Copyright (c) 2018-2020 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request, ArcGISIdentityManager } from "@esri/arcgis-rest-request";
+import { IServiceNameAvailable } from "../helpers.js";
+
+/**
+ * Determine if a specific service name is available in the current user's organization
+ *
+ * @export
+ * @param {string} name
+ * @param {ArcGISIdentityManager} session
+ * @return {*}  {Promise<IServiceNameAvailable>}
+ */
+export function isServiceNameAvailable(
+  name: string,
+  type: string,
+  session: ArcGISIdentityManager
+): Promise<IServiceNameAvailable> {
+  const url = `${session.portal}/portals/self/isServiceNameAvailable`;
+  return request(url, {
+    params: {
+      name,
+      type
+    },
+    httpMethod: "GET",
+    authentication: session
+  });
+}

package/packages/arcgis-rest-portal/src/sharing/access.ts

@@ -0,0 +1,84 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { request } from "@esri/arcgis-rest-request";
+
+import {
+  ISharingOptions,
+  ISharingResponse,
+  isItemOwner,
+  getSharingUrl,
+  isOrgAdmin
+} from "./helpers.js";
+
+export interface ISetAccessOptions extends ISharingOptions {
+  /**
+   * "private" indicates that the item can only be accessed by the user. "public" means accessible to anyone. An item shared to the organization has an access level of "org".
+   */
+  access: "private" | "org" | "public";
+}
+
+/**
+ * ```js
+ * import { setItemAccess } from "@esri/arcgis-rest-portal";
+ * //
+ * setItemAccess({
+ *   id: "abc123",
+ *   access: "public", // 'org' || 'private'
+ *   authentication: session
+ * })
+ * ```
+ * Change who is able to access an item.
+ *
+ * @param requestOptions - Options for the request.
+ * @returns A Promise that will resolve with the data from the response.
+ */
+export function setItemAccess(
+  requestOptions: ISetAccessOptions
+): Promise<ISharingResponse> {
+  const url = getSharingUrl(requestOptions);
+
+  if (isItemOwner(requestOptions)) {
+    // if the user owns the item, proceed
+    return updateItemAccess(url, requestOptions);
+  } else {
+    // otherwise we need to check to see if they are an organization admin
+    return isOrgAdmin(requestOptions).then((admin) => {
+      if (admin) {
+        return updateItemAccess(url, requestOptions);
+      } else {
+        // if neither, updating the sharing isnt possible
+        throw Error(
+          `This item can not be shared by ${requestOptions.authentication.username}. They are neither the item owner nor an organization admin.`
+        );
+      }
+    });
+  }
+}
+
+function updateItemAccess(
+  url: string,
+  requestOptions: ISetAccessOptions
+): Promise<any> {
+  requestOptions.params = {
+    org: false,
+    everyone: false,
+    ...requestOptions.params
+  };
+
+  // if the user wants to make the item private, it needs to be unshared from any/all groups as well
+  if (requestOptions.access === "private") {
+    requestOptions.params.groups = " ";
+  }
+  if (requestOptions.access === "org") {
+    requestOptions.params.org = true;
+  }
+  // if sharing with everyone, share with the entire organization as well.
+  if (requestOptions.access === "public") {
+    // this is how the ArcGIS Online Home app sets public access
+    // setting org = true instead of account = true will cancel out all sharing
+    requestOptions.params.account = true;
+    requestOptions.params.everyone = true;
+  }
+  return request(url, requestOptions);
+}

package/packages/arcgis-rest-portal/src/sharing/helpers.ts

@@ -0,0 +1,80 @@
+/* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+
+import { IUserRequestOptions, IGroup, IUser, GroupMembership } from "@esri/arcgis-rest-request";
+import { getPortalUrl } from "../util/get-portal-url.js";
+import { getGroup } from "../groups/get.js";
+
+export interface ISharingOptions extends IUserRequestOptions {
+  /**
+   * Unique identifier for the item.
+   */
+  id: string;
+  /**
+   * Item owner, if different from the authenticated user.
+   */
+  owner?: string;
+}
+
+export interface ISharingResponse {
+  notSharedWith?: string[];
+  notUnsharedFrom?: string[];
+  itemId: string;
+}
+
+export function getSharingUrl(requestOptions: ISharingOptions): string {
+  const username = requestOptions.authentication.username;
+  const owner = requestOptions.owner || username;
+  return `${getPortalUrl(requestOptions)}/content/users/${encodeURIComponent(
+    owner
+  )}/items/${requestOptions.id}/share`;
+}
+
+export function isItemOwner(requestOptions: ISharingOptions): boolean {
+  const username = requestOptions.authentication.username;
+  const owner = requestOptions.owner || username;
+  return owner === username;
+}
+
+/**
+ * Check it the user is a full org_admin
+ * @param requestOptions
+ * @returns Promise resolving in a boolean indicating if the user is an ArcGIS Organization administrator
+ */
+export function isOrgAdmin(
+  requestOptions: IUserRequestOptions
+): Promise<boolean> {
+  const session = requestOptions.authentication;
+
+  return session.getUser(requestOptions).then((user: IUser) => {
+    return user && user.role === "org_admin" && !user.roleId;
+  });
+}
+
+/**
+ * Get the User Membership for a particular group. Use this if all you have is the groupId.
+ * If you have the group object, check the `userMembership.memberType` property instead of calling this method.
+ *
+ * @param requestOptions
+ * @returns A Promise that resolves with "owner" | "admin" | "member" | "nonmember"
+ */
+export function getUserMembership(
+  requestOptions: IGroupSharingOptions
+): Promise<GroupMembership> {
+  // fetch the group...
+  return getGroup(requestOptions.groupId, requestOptions)
+    .then((group: IGroup) => {
+      return group.userMembership.memberType;
+    })
+    .catch(() => {
+      return "none" as GroupMembership;
+    });
+}
+
+export interface IGroupSharingOptions extends ISharingOptions {
+  /**
+   * Group identifier
+   */
+  groupId: string;
+  confirmItemControl?: boolean;
+}

package/packages/arcgis-rest-portal/src/sharing/is-item-shared-with-group.ts

@@ -0,0 +1,42 @@
+import { IGroupSharingOptions } from "./helpers.js";
+import { searchItems } from "../items/search.js";
+import { ISearchOptions } from "../util/search.js";
+
+/**
+ * ```js
+ * import { isItemSharedWithGroup } from "@esri/arcgis-rest-portal";
+ * //
+ * isItemSharedWithGroup({
+ *   groupId: 'bc3,
+ *   itemId: 'f56,
+ *   authentication
+ * })
+ * .then(isShared => {})
+ * ```
+ * Find out whether or not an item is already shared with a group.
+ *
+ * @param requestOptions - Options for the request. NOTE: `rawResponse` is not supported by this operation.
+ * @returns Promise that will resolve with true/false
+ */
+export function isItemSharedWithGroup(
+  requestOptions: IGroupSharingOptions
+): Promise<boolean> {
+  const searchOpts = {
+    q: `id: ${requestOptions.id} AND group: ${requestOptions.groupId}`,
+    start: 1,
+    num: 10,
+    sortField: "title",
+    authentication: requestOptions.authentication,
+    httpMethod: "POST"
+  } as ISearchOptions;
+
+  return searchItems(searchOpts).then((searchResponse) => {
+    let result = false;
+    if (searchResponse.total > 0) {
+      result = searchResponse.results.some((itm: any) => {
+        return itm.id === requestOptions.id;
+      });
+      return result;
+    }
+  });
+}