EDSC-3773: Refactor buildAccessMethods.js

static/src/js/util/accessMethods/buildAccessMethods.js

@@ -1,16 +1,10 @@
-import { camelCase, uniq } from 'lodash-es'
-
 import { getApplicationConfig } from '../../../../../sharedUtils/config'
 
-import { isDownloadable } from '../../../../../sharedUtils/isDownloadable'
-import { generateFormDigest } from './generateFormDigest'
-import { getVariables } from './getVariables'
-import { supportsBoundingBoxSubsetting } from './supportsBoundingBoxSubsetting'
-import { supportsConcatenation } from './supportsConcatenation'
-import { defaultConcatenation } from './defaultConcatenation'
-import { supportsShapefileSubsetting } from './supportsShapefileSubsetting'
-import { supportsTemporalSubsetting } from './supportsTemporalSubsetting'
-import { supportsVariableSubsetting } from './supportsVariableSubsetting'
+import { buildEsiEcho } from './buildAccessMethods/buildEsiEcho'
+import { buildOpendap } from './buildAccessMethods/buildOpendap'
+import { buildHarmony } from './buildAccessMethods/buildHarmony'
+import { buildSwodlr } from './buildAccessMethods/buildSwodlr'
+import { buildDownload } from './buildAccessMethods/buildDownload'
 
 /**
  * Builds the different access methods available for the provided collection
@@ -25,202 +19,61 @@ export const buildAccessMethods = (collectionMetadata, isOpenSearch) => {
     variables: collectionAssociatedVariables = {}
   } = collectionMetadata
 
-  const accessMethods = {}
   let harmonyIndex = 0
   const { items: serviceItems = null } = services
 
   const { disableOrdering, disableSwodlr } = getApplicationConfig()
 
-  if (serviceItems !== null) {
-    serviceItems.forEach((serviceItem) => {
-      let associatedVariables = collectionAssociatedVariables
-      const {
-        conceptId: serviceConceptId,
-        description,
-        orderOptions,
-        type: serviceType,
-        url,
-        longName,
-        maxItemsPerOrder,
-        name,
-        supportedReformattings,
-        variables: serviceAssociatedVariables = {}
-      } = serviceItem
-
-      // Overwrite variables if there are variables associated to the service record
-      if (serviceAssociatedVariables.items && serviceAssociatedVariables.items.length > 0) {
-        associatedVariables = serviceAssociatedVariables
-      }
-
-      // Only process service types that EDSC supports
-      const supportedServiceTypes = ['esi', 'echo orders', 'opendap', 'harmony', 'swodlr']
-      if (!supportedServiceTypes.includes(serviceType.toLowerCase())) return
-
-      const { urlValue } = url
-
-      const supportsOrderOptions = ['esi', 'echo orders']
-
-      // Only process orderOptions if the service type uses orderOptions
-      // Do not include access if orders are disabled
-      if (supportsOrderOptions.includes(serviceType.toLowerCase()) && (disableOrdering !== 'true')) {
-        const { items: orderOptionsItems } = orderOptions
-        if (orderOptionsItems === null) return
-
-        orderOptionsItems.forEach((orderOptionItem, orderOptionIndex) => {
-          const {
-            conceptId: orderOptionConceptId,
-            form,
-            name: orderOptionName
-          } = orderOptionItem
-
-          const method = {
-            type: serviceType,
-            maxItemsPerOrder,
-            url: urlValue,
-            optionDefinition: {
-              conceptId: orderOptionConceptId,
-              name: orderOptionName
-            },
-            form,
-            formDigest: generateFormDigest(form)
-          }
-
-          let methodKey = camelCase(serviceType)
-
-          // `echoOrders` needs to be singular to match existing savedAccessConfigurations
-          if (methodKey === 'echoOrders') {
-            methodKey = 'echoOrder'
-          }
-
-          accessMethods[`${methodKey}${orderOptionIndex}`] = method
-        })
-      }
-
-      if (serviceType.toLowerCase() === 'opendap') {
-        const {
-          hierarchyMappings,
-          keywordMappings,
-          variables
-        } = getVariables(associatedVariables)
-
-        const outputFormats = []
-
-        if (supportedReformattings) {
-          supportedReformattings.forEach((reformatting) => {
-            const { supportedOutputFormats } = reformatting
-
-            // Collect all supported output formats from each mapping
-            outputFormats.push(...supportedOutputFormats)
-          })
-        }
-
-        accessMethods.opendap = {
-          hierarchyMappings,
-          id: serviceConceptId,
-          isValid: true,
-          keywordMappings,
-          longName,
-          name,
-          supportedOutputFormats: uniq(outputFormats),
-          supportsVariableSubsetting: supportsVariableSubsetting(serviceItem),
-          type: serviceType,
-          variables
-        }
-      }
-
-      if (serviceType.toLowerCase() === 'harmony') {
-        const {
-          hierarchyMappings,
-          keywordMappings,
-          variables
-        } = getVariables(associatedVariables)
-        const {
-          supportedOutputProjections
-        } = serviceItem
-
-        const outputFormats = []
-
-        if (supportedReformattings) {
-          supportedReformattings.forEach((reformatting) => {
-            const { supportedOutputFormats } = reformatting
-
-            // Collect all supported output formats from each mapping
-            outputFormats.push(...supportedOutputFormats)
-          })
-        }
-
-        let outputProjections = []
-        if (supportedOutputProjections) {
-          outputProjections = supportedOutputProjections.filter((projection) => {
-            const { projectionAuthority } = projection
-
-            return projectionAuthority != null
-          }).map((projection) => {
-            const { projectionAuthority } = projection
-
-            return projectionAuthority
-          })
-        }
+  const buildMethods = {
+    esi: (serviceItem, params) => buildEsiEcho(serviceItem, params.disableOrdering),
+    'echo orders': (serviceItem, params) => buildEsiEcho(serviceItem, params.disableOrdering),
+    opendap: (serviceItem, params) => buildOpendap(serviceItem, params.associatedVariables),
+    // eslint-disable-next-line max-len
+    harmony: (serviceItem, params) => buildHarmony(serviceItem, params.associatedVariables, params.harmonyIndex),
+    swodlr: (serviceItem, params) => buildSwodlr(serviceItem, params.disableSwodlr),
+    downloads: () => buildDownload(granules, isOpenSearch)
+  }
 
-        accessMethods[`harmony${harmonyIndex}`] = {
-          description,
-          enableTemporalSubsetting: true,
-          enableSpatialSubsetting: true,
-          hierarchyMappings,
-          id: serviceConceptId,
-          isValid: true,
-          keywordMappings,
-          longName,
-          name,
-          supportedOutputFormats: uniq(outputFormats),
-          supportedOutputProjections: outputProjections,
-          supportsBoundingBoxSubsetting: supportsBoundingBoxSubsetting(serviceItem),
-          supportsShapefileSubsetting: supportsShapefileSubsetting(serviceItem),
-          supportsTemporalSubsetting: supportsTemporalSubsetting(serviceItem),
-          supportsVariableSubsetting: supportsVariableSubsetting(serviceItem),
-          supportsConcatenation: supportsConcatenation(serviceItem),
-          defaultConcatenation: defaultConcatenation(serviceItem),
-          enableConcatenateDownload: defaultConcatenation(serviceItem),
-          type: serviceType,
-          url: urlValue,
-          variables
-        }
+  const nonDownloadMethods = serviceItems !== null ? serviceItems.reduce((methods, serviceItem) => {
+    let associatedVariables = collectionAssociatedVariables
+    const {
+      type: serviceType,
+      variables: serviceAssociatedVariables = {}
+    } = serviceItem
 
-        harmonyIndex += 1
-      }
+    // Overwrite variables if there are variables associated to the service record
+    if (serviceAssociatedVariables.items && serviceAssociatedVariables.items.length > 0) {
+      associatedVariables = serviceAssociatedVariables
+    }
 
-      if (serviceType.toLowerCase() === 'swodlr' && (disableSwodlr !== 'true')) {
-        accessMethods.swodlr = {
-          id: serviceConceptId,
-          isValid: true,
-          longName,
-          name,
-          type: serviceType,
-          supportsSwodlr: true,
-          url: urlValue
-        }
-      }
-    })
-  }
+    const lowerServiceType = serviceType.toLowerCase()
 
-  // Determine if the collection should have the downloadable accessMethod
-  let onlineAccessFlag = false
+    // Only process service types that EDSC supports
+    const supportedServiceTypes = ['esi', 'echo orders', 'opendap', 'harmony', 'swodlr']
+    if (!supportedServiceTypes.includes(lowerServiceType)) return {}
 
-  if (granules) {
-    // If the collection has granules, check their online access flags to
-    // determine if this collection is downloadable
-    const { items: granuleItems } = granules
+    const params = {
+      disableOrdering,
+      harmonyIndex,
+      associatedVariables,
+      disableSwodlr
+    }
 
-    if (granuleItems) {
-      onlineAccessFlag = isDownloadable(granuleItems)
+    const updatedMethods = {
+      ...methods,
+      ...buildMethods[lowerServiceType](serviceItem, params)
     }
 
-    if (onlineAccessFlag || isOpenSearch) {
-      accessMethods.download = {
-        isValid: true,
-        type: 'download'
-      }
+    if (lowerServiceType === 'harmony') {
+      harmonyIndex += 1
     }
+
+    return updatedMethods
+  }, {}) : {}
+
+  const accessMethods = {
+    ...nonDownloadMethods,
+    ...buildMethods.downloads()
   }
 
   return accessMethods

static/src/js/util/accessMethods/buildAccessMethods/__tests__/buildDownload.test.js

@@ -0,0 +1,45 @@
+import { buildDownload } from '../buildDownload'
+
+describe('buildDownload', () => {
+  test('returns a download access method', () => {
+    const collectionMetadata = {
+      granules: {
+        items: [{
+          online_access_flag: true
+        }]
+      }
+    }
+    const isOpenSearch = false
+
+    const {
+      granules
+    } = collectionMetadata
+
+    const method = buildDownload(granules, isOpenSearch)
+
+    expect(method).toEqual({
+      download: {
+        isValid: true,
+        type: 'download'
+      }
+    })
+  })
+
+  test('returns a download access method for open search', () => {
+    const collectionMetadata = {}
+    const isOpenSearch = true
+
+    const {
+      granules = {}
+    } = collectionMetadata
+
+    const method = buildDownload(granules, isOpenSearch)
+
+    expect(method).toEqual({
+      download: {
+        isValid: true,
+        type: 'download'
+      }
+    })
+  })
+})