Search

capabilities: { canAddAsset: true } 

const stateProps = [
  { id: 'watermarked', name: 'Watermarked' },
  { id: 'limited', name: 'Limited' },
  { id: 'archive', name: 'Archived' },
  { id: 'isPublic', name: 'Public' }
]
const getValues = item => stateProps.
  filter(prop => item[prop.id]).
  map(prop => ({ id: prop.id, name: prop.name, type: 'TEXT', value: '✓' })).
  concat(Object.entries(item).
    filter(([ key, value ]) => key.startsWith('property_') && value).
    map(([ key, value ]) => ({ id: key, name: `${key[9].toUpperCase()}${key.substring(10)}`, type: 'TEXT', value: Array.isArray(value) ? value.join(', ') : value })))

const extractAssetData = (locals, item) => {
  let name = (item.name || '').replace(/[/\\:*?"<>|]/g, '_')
  const currentExtension = (path.extname(name) || '').toLowerCase().replace('.', '')

  if (item.extension && currentExtension !== `${item.extension}`.toLowerCase()) {
    name += `.${item.extension}`
  }
  const thumbnailVideoUrl = item && item.videoPreviewURLs && item.videoPreviewURLs.length && item.videoPreviewURLs[0]
  const downloadUrl = getDownloadUrl(locals, item.id)
  const thumbnailUrl = getThumbnailUrl(downloadUrl, name, [ 'indd', 'idms' ], item.thumbnails.thul && `${item.thumbnails.thul}$NO_AUTH$`)
  const fileSize = item.fileSize
  const modified = new Date(item.dateModified).getTime()

  return {
    id: item.id,
    name,
    parentPath: '/Assets',
    fileSize,
    xSizePx: item.width,
    ySizePx: item.height,
    created: new Date(item.dateCreated).getTime(),
    modified,
    mimeType: mime.lookup(name) || 'application/octet-stream',
    version: item.version || 1,
    caption: item.description && item.description.trim() || undefined,
    copyright: item.copyright && item.copyright.trim() || undefined,
    title: item.name,
    thumbnailUrl, 
    thumbnailVideoUrl,
    downloadUrl, 
    downloadHashFileAttributes: JSON.stringify({ fileSize, modified }), 
    lowresUrl: !thumbnailVideoUrl ? getDownloadUrl(locals, item.id, '?lowres=1') : undefined,
    assetDetailsExternalUrl: getAssetDetailsExternalUrl(locals, item.id),
    conversions: getConversions(item),
    keywords: item.tags,
    states: stateProps.filter(entry => item[entry.id]).map(entry => entry.name),
    capabilities: defaultAssetCapabilities,
    values: getValues(item)
  }
}

const extractAssetsData = (locals, items, overrideCapabilities = {}, useFileName = false) => items.map((item) => {
  const expired = item.expiresAt ? new Date(item.expiresAt).getTime() < Date.now() : false
  const [ key, fallback ] = useFileName ? [ 'title', 'filename' ] : [ 'filename', 'title' ]
  const assetName = item[key] || item[fallback]

  const downloadUrl = item.downloadUrl?.concat('$NO_AUTH$') ?? getDownloadUrl(locals)
  const thumbnailUrl = item.thumbnailUrl?.concat('$NO_AUTH$')
  const extension = item.extension || mimeTypes.extension(item.filename)
  const fileSize = item.size
  const modified = new Date(item.modifiedAt).getTime()
  const readableId = getHumanReadableId(item.id.toString())
  const canDownload = !expired && (item.currentUserPermissions?.canDownload ?? true)

  const capabilities = {
    canUpdateAsset: !expired && (item.currentUserPermissions?.canEdit || false),
    canDeleteAsset: !expired && (item.currentUserPermissions?.canDelete || false)
  }

  try {
    const asset = {
      id: item.id.toString(),
      name: assetName,
      downloadUrl: canDownload ? downloadUrl : null,
      thumbnailUrl: thumbnailUrl,
      mimeType: mimeTypes.lookup(extension) || mimeTypes.lookup(assetName) || 'application/octet-stream',
      title: item.title,
      xSizePx: item.width,
      ySizePx: item.height,
      fileSize,
      created: new Date(item.createdAt).getTime(),
      modified,
      version: 1,
      values: getValues(item),
      conversions: expired ? [] : getConversions(item, extension, thumbnailUrl),
      keywords: item.tags?.map((tag) => tag.value).filter((tag) => tag),
      states: [ item.workflowTask?.status?.name, item.licenses?.map((license) => license.title), expired ? 'Expired' : '' ].flat().filter((state) => state),
      capabilities: { ...defaultAssetCapabilities, ...capabilities, ...overrideCapabilities }, 
      downloadHashFileAttributes: JSON.stringify({ fileSize, modified }),
      assetDetailsExternalUrl: readableId ? new URL(`/screen/${readableId}`, locals.adapterData.resourceEndpoint).toString() : null
    }

    return asset
  } catch {
    return undefined
  }
}).filter((item) => item)

search: async (locals, requestData) => {
  const query = requestData.query.query || ''
  const page = Number.parseInt(requestData.query.more || 0, 10)
  const size = Math.min(Number.parseInt(requestData.query.size || 50, 10), config.get('IntegrationName.maxQuerySize'))
  const activeFilters = requestData.query.filters || []

  try {
    const result = await getAssets(locals, null, query, page, size, activeFilters)
    return sendResult(null, result)
  } catch (err) {
    return sendError(err, 400)
  }
}

// getAssets builds the full result object:
const getAssets = async (locals, collection, search, page, size, activeFilters = []) => {
  const capabilities = Object.assign({}, defaultFolderCapabilities, {
    canAddAsset: true,
    canDeleteFolder: collection !== ''
  })
  const result = { folders: [], assets: [], filters: [], capabilities, totalAssetsCount: 0 }

  const query = {
    limit: size,
    page: page + 1,
    count: true,
    total: true,
    orderBy: 'dateCreated desc'
  }

  const assets = await callApi(locals, 'GET', '/api/v4/media/', query)
  result.totalAssetsCount = assets.count.total

  // Pagination: check if more assets exist
  if (page * size + assets.media.length < result.totalAssetsCount) { 
    result.more = page + 1
  }

  // Map each remote item to CI HUB Asset
  for (const item of assets.media) {
    const asset = extractAssetData(locals, item)
    result.assets.push(asset)
  }

  return result
}

search: async (locals, requestData) => {
  const { brandId } = locals.adapterData
  const isFileNameSearch = requestData.query.type === 'fileName'
  const query = (requestData.query.query || '').replace(isFileNameSearch ? /^"|"$/g : '', '')
  const activeFilters = requestData.query.filters || []
  const activeFiltersJson = parseOptions(activeFilters)
  const rFolderId = (requestData.query.parentId || '').toString()
  const folderId = folderIdStartsWith(rFolderId) ? undefined : rFolderId
  const more = parseInt((requestData.query.more || '1'), 10) || 1
  const size = Math.min(parseInt((requestData.query.size || '25'), 10), config.get('IntegrationName.maxQuerySize'))
  const result = {
    assets: [],
    folders: [],
    filters: [],
    more: undefined,
    capabilities: {},
    totalAssetsCount: 0
  }

  try {
    const searchQuery = {
      ...folderId ? { inFolder: { id: folderId } } : {},
      search: query
    }
    const assets = await callApi(locals, {
      query: queries.getSearchAssetsQuery,
      variables: { libraryId, query: searchQuery, page: more, limit: size }
    })

    result.assets = extractAssetsData(locals, assets.data.library.assets.items)
    result.more = assets.data.library.assets.hasNextPage ? more + 1 : undefined
    result.totalAssetsCount = assets.data.library.assets.total
    result.filters = getFilters(assets.data, activeFiltersJson)

    return send(result)
  } catch (error) {
    return sendError(`Error searching: ${error}`, 400)
  }
}