feat(hub-common): add new utils for a unified download flow

packages/common/src/content/_internal/computeProps.ts

@@ -12,6 +12,7 @@ import {
   ServiceCapabilities,
 } from "../hostedServiceUtils";
 import { computeBaseProps } from "../../core/_internal/computeBaseProps";
+import { getProp } from "../../objects";
 import { IHubEditableContentEnrichments } from "../../items/_enrichments";
 
 export function computeProps(
@@ -58,7 +59,15 @@ export function computeProps(
       ServiceCapabilities.EXTRACT,
       enrichments.server
     );
+    const extractFormatsList: string = getProp(
+      enrichments,
+      "server.supportedExportFormats"
+    );
+    content.serverExtractFormats =
+      extractFormatsList && extractFormatsList.split(",");
   }
 
+  content.additionalResources = enrichments.additionalResources;
+
   return content as IHubEditableContent;
 }

packages/common/src/content/fetch.ts

@@ -251,13 +251,16 @@ export const fetchHubContent = async (
   requestOptions: IRequestOptions
 ): Promise<IHubEditableContent> => {
   // NOTE: b/c we have to support slugs we use fetchContent() to get the item
-  // by telling it to not fetch any enrichments
-  // which we then fetch as needed after we have the item
+  // by telling it to not fetch any enrichments which we then fetch as needed after we have the item
+  // EXCEPTION: We ask it to fetch the metadata enrichment so we don't have to parse xml on the client
   const options = {
     ...requestOptions,
-    enrichments: [],
+    enrichments: ["metadata"],
   } as IFetchContentOptions;
-  const { item, access } = await fetchContent(identifier, options);
+  const { item, access, additionalResources } = await fetchContent(
+    identifier,
+    options
+  );
 
   // we must normalize the underlying item type to account
   // for older items (e.g. sites that are type "Web Mapping
@@ -266,7 +269,7 @@ export const fetchHubContent = async (
   setProp("type", type, item);
 
   const model = { item };
-  const enrichments: IHubEditableContentEnrichments = {};
+  const enrichments: IHubEditableContentEnrichments = { additionalResources };
   if (isHostedFeatureServiceItem(item)) {
     enrichments.server = await getService({
       ...requestOptions,

packages/common/src/core/types/IHubEditableContent.ts

@@ -1,4 +1,5 @@
 import { IWithPermissions, IWithSlug } from "../traits/index";
+import { IHubAdditionalResource } from "./IHubAdditionalResource";
 import { IHubItemEntity, IHubItemEntityEditor } from "./IHubItemEntity";
 import { IHubSchedule } from "./IHubSchedule";
 
@@ -19,6 +20,16 @@ export interface IHubEditableContent
    * capability enabled. This is a pre-requisite for Hosted Downloads to work.
    */
   serverExtractCapability?: boolean;
+  /**
+   * If the item represents a hosted feature service with "Extract enabled", shows the formats that
+   * can be extracted from the service via the "createReplica" operation.
+   */
+  serverExtractFormats?: string[];
+  /**
+   * links to additional resources specified in the formal item metadata
+   * TODO: which items can have these? And is it only available for public items?
+   */
+  additionalResources?: IHubAdditionalResource[];
   /**
    * The schedule at which the reharvest of the item will occur
    */

packages/common/src/downloads/fetchDownloadFileUrl.ts

@@ -0,0 +1,27 @@
+import HubError from "../HubError";
+import { canUseExportImageFlow } from "./helpers/canUseExportImageFlow";
+import { canUseExportItemFlow } from "./helpers/canUseExportItemFlow";
+import { canUseHubDownloadApi } from "./helpers/canUseHubDownloadApi";
+import { fetchExportImageDownloadFileUrl } from "./helpers/file-url-fetchers/fetchExportImageDownloadFileUrl";
+import { fetchExportItemDownloadFileUrl } from "./helpers/file-url-fetchers/fetchExportItemDownloadFileUrl";
+import { fetchHubApiDownloadFileUrl } from "./helpers/file-url-fetchers/fetchHubApiDownloadFileUrl";
+import { IFetchDownloadFileUrlOptions } from "./helpers/types";
+
+export async function fetchDownloadFileUrl(
+  options: IFetchDownloadFileUrlOptions
+): Promise<string> {
+  let fetchingFn;
+  if (canUseHubDownloadApi(options.entity, options.context)) {
+    fetchingFn = fetchHubApiDownloadFileUrl;
+  } else if (canUseExportItemFlow(options.entity)) {
+    fetchingFn = fetchExportItemDownloadFileUrl;
+  } else if (canUseExportImageFlow(options.entity)) {
+    fetchingFn = fetchExportImageDownloadFileUrl;
+  } else {
+    throw new HubError(
+      "fetchDownloadFileUrl",
+      "Downloads are not supported for this item in this environment"
+    );
+  }
+  return fetchingFn(options);
+}

packages/common/src/downloads/fetchDownloadFormats.ts

@@ -0,0 +1,45 @@
+import { IHubAdditionalResource } from "../core/types/IHubAdditionalResource";
+import { canUseExportImageFlow } from "./helpers/canUseExportImageFlow";
+import { canUseExportItemFlow } from "./helpers/canUseExportItemFlow";
+import { canUseHubDownloadApi } from "./helpers/canUseHubDownloadApi";
+import { fetchExportItemFormats } from "./helpers/format-fetchers/fetchExportItemFormats";
+import { getExportImageDownloadFormats } from "./helpers/format-fetchers/getExportImageFormats";
+import { getHubDownloadApiFormats } from "./helpers/format-fetchers/getHubDownloadApiFormats";
+import {
+  IDownloadFormat,
+  IFetchDownloadFormatsOptions,
+  IStaticDownloadFormat,
+} from "./helpers/types";
+
+export async function fetchDownloadFormats(
+  options: IFetchDownloadFormatsOptions
+): Promise<IDownloadFormat[]> {
+  const { entity, context, layers } = options;
+  // fetch base formats for the item
+  let baseFormats: IDownloadFormat[] = [];
+  if (canUseHubDownloadApi(entity, context)) {
+    baseFormats = getHubDownloadApiFormats(entity);
+  } else if (canUseExportItemFlow(entity)) {
+    baseFormats = await fetchExportItemFormats(entity, context, layers);
+  } else if (canUseExportImageFlow(entity)) {
+    baseFormats = getExportImageDownloadFormats();
+  }
+
+  // add additional resource links as static formats
+  const additionalFormats = (entity.additionalResources || []).map(
+    toStaticFormat
+  );
+
+  // combine formats into single list
+  return [...baseFormats, ...additionalFormats];
+}
+
+function toStaticFormat(
+  resource: IHubAdditionalResource
+): IStaticDownloadFormat {
+  return {
+    type: "static",
+    label: resource.name,
+    url: resource.url,
+  };
+}

packages/common/src/downloads/build-existing-exports-portal-query.ts → packages/common/src/downloads/helpers/build-existing-exports-portal-query.ts

@@ -1,48 +1,11 @@
 import { SearchQueryBuilder } from "@esri/arcgis-rest-portal";
 import { ISpatialReference } from "@esri/arcgis-rest-types";
 import { btoa } from "abab";
-import { flattenArray } from "../util";
+import { flattenArray } from "../../util";
+import { PORTAL_EXPORT_TYPES } from "./types";
 
 export const WGS84_WKID = "4326";
 
-export const PORTAL_EXPORT_TYPES = {
-  csv: {
-    name: "CSV",
-    itemTypes: ["CSV", "CSV Collection"],
-    supportsProjection: true,
-  },
-  kml: {
-    name: "KML",
-    itemTypes: ["KML", "KML Collection"],
-    supportsProjection: false,
-  },
-  shapefile: {
-    name: "Shapefile",
-    itemTypes: ["Shapefile"],
-    supportsProjection: true,
-  },
-  fileGeodatabase: {
-    name: "File Geodatabase",
-    itemTypes: ["File Geodatabase"],
-    supportsProjection: true,
-  },
-  geojson: {
-    name: "GeoJson",
-    itemTypes: ["GeoJson"],
-    supportsProjection: false,
-  },
-  excel: {
-    name: "Excel",
-    itemTypes: ["Microsoft Excel"],
-    supportsProjection: true,
-  },
-  featureCollection: {
-    name: "Feature Collection",
-    itemTypes: ["Feature Collection"],
-    supportsProjection: true,
-  },
-};
-
 interface IExistingExportsPortalQueryOptions {
   layerId?: number | string;
   onlyTypes?: string[];

packages/common/src/downloads/helpers/canCreateExportItem.ts

@@ -0,0 +1,10 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubEditableContent } from "../../core/types/IHubEditableContent";
+
+export function canCreateExportItem(
+  _entity: IHubEditableContent,
+  _context: IArcGISContext
+) {
+  // TODO: port over logic from ember's download-service
+  return true;
+}

packages/common/src/downloads/helpers/canUseExportImageFlow.ts

@@ -0,0 +1,5 @@
+import { IHubEditableContent } from "../../core/types/IHubEditableContent";
+
+export function canUseExportImageFlow(entity: IHubEditableContent): boolean {
+  return entity.type === "Image Service";
+}

packages/common/src/downloads/helpers/canUseExportItemFlow.ts

@@ -0,0 +1,6 @@
+import { isHostedFeatureServiceEntity } from "../../content";
+import { IHubEditableContent } from "../../core/types/IHubEditableContent";
+
+export function canUseExportItemFlow(entity: IHubEditableContent): boolean {
+  return isHostedFeatureServiceEntity(entity);
+}

packages/common/src/downloads/helpers/canUseHubDownloadApi.ts

@@ -0,0 +1,22 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubEditableContent } from "../../core/types/IHubEditableContent";
+import { isHostedFeatureServiceEntity } from "../../content/hostedServiceUtils";
+import { isMapOrFeatureServiceEntity } from "./isMapOrFeatureServiceEntity";
+
+export function canUseHubDownloadApi(
+  entity: IHubEditableContent,
+  context: IArcGISContext
+): boolean {
+  // TODO: use permission instead.
+  const isPublicMapOrFeatureService =
+    isMapOrFeatureServiceEntity(entity) && entity.access === "public";
+  const isPrivateHostedFeatureServiceWithExtractEnabled =
+    isHostedFeatureServiceEntity(entity) &&
+    entity.serverExtractCapability &&
+    entity.access !== "public";
+  return (
+    !context.isPortal &&
+    (isPublicMapOrFeatureService ||
+      isPrivateHostedFeatureServiceWithExtractEnabled)
+  );
+}

packages/common/src/downloads/helpers/file-url-fetchers/fetchExportImageDownloadFileUrl.ts

@@ -0,0 +1,49 @@
+import { request } from "@esri/arcgis-rest-request";
+import {
+  DownloadOperationStatus,
+  IFetchDownloadFileUrlOptions,
+} from "../types";
+
+export async function fetchExportImageDownloadFileUrl(
+  options: IFetchDownloadFileUrlOptions
+): Promise<string> {
+  const { entity, format, context, geometry, progressCallback } = options;
+  progressCallback && progressCallback(DownloadOperationStatus.PENDING);
+
+  // TODO: validate layers, geometry, where, etc. I don't think all of them are applicable in every permutation
+
+  const requestOptions = { ...context.requestOptions };
+  requestOptions.httpMethod = "GET";
+  requestOptions.params = {
+    f: "image",
+    format,
+    mosaicRule:
+      '{"ascending":true,"mosaicMethod":"esriMosaicNorthwest","mosaicOperation":"MT_FIRST"}',
+  };
+
+  if (geometry) {
+    const { xmin, xmax, ymin, ymax } = geometry;
+    const { wkid } = geometry.spatialReference;
+    requestOptions.params.bbox = `${xmin},${ymin},${xmax},${ymax}`;
+    requestOptions.params.bboxSR = `${wkid}`;
+    requestOptions.params.imageSR = `${wkid}`;
+  }
+  // Note: validate where "extent" and "layer" are coming from in the old ember code,
+  // check if they are still applicable here
+  else {
+    const coords = entity.extent;
+    requestOptions.params.bbox = `${coords[0][0]},${coords[0][1]},${coords[1][0]},${coords[1][1]}`;
+    requestOptions.params.bboxSR = "4326";
+    requestOptions.params.imageSR = "4326";
+  }
+
+  // const { maxImageHeight, maxImageWidth } = this.args.model.layer || {};
+  // if (maxImageWidth && maxImageHeight) {
+  //   requestOptions.params.size = `${maxImageWidth},${maxImageHeight}`;
+  // }
+
+  const blob = await request(`${entity.url}/exportImage`, requestOptions);
+  const url = URL.createObjectURL(blob);
+  progressCallback && progressCallback(DownloadOperationStatus.COMPLETED);
+  return url;
+}