smsb-web-develop/src/api/asset.js

import request, {
  tenantRequest,
  downloadRequest
} from '@/utils/request.js'
import {
  State,
  Dataset
} from '@/constant.js'
import {
  getAssetThumb,
  getAssetDiff,
  parseTime
} from '@/utils'
import {
  send,
  add,
  del,
  update,
  submit,
  resolve,
  messageSend,
  confirmAndSend,
  addStatus,
  addTenant
} from './base.js'

function download ({ data, headers }, fileName) {
  const blob = new Blob([data], { type: headers['content-type'] })
  const url = window.URL.createObjectURL(blob)
  const dom = document.createElement('a')
  dom.href = url
  dom.download = decodeURI(fileName)
  dom.style.display = 'none'
  document.body.appendChild(dom)
  dom.click()
  dom.parentNode.removeChild(dom)
  window.URL.revokeObjectURL(url)
}

export function resourceExport (data) {
  return send({
    url: '/minio-data/usage/count/export',
    method: 'POST',
    data
  }, downloadRequest).then(response => {
    download(response, `资源曝光率${parseTime(new Date(), '{y}{m}{d}{h}{i}{s}')}.zip`)
  })
}

export function addAsset (data) {
  return add({
    url: '/minio-data',
    method: 'POST',
    data: addTenant(data)
  }, tenantRequest)
}

export function getAsset (keyName) {
  return send({
    url: '/minio-data/queryById',
    method: 'GET',
    params: { keyName }
  })
}

export function getAssetsByQuery (query) {
  const { pageNum: currentPage, pageSize: pageCount, typeList, type, ...params } = query
  return request({
    url: '/minio-data/listByPage',
    method: 'POST',
    data: addStatus({
      currentPage,
      pageCount,
      typeList: typeList || (type ? [type] : void 0),
      ...params
    })
  }).then(({ data, totalCount }) => {
    data.forEach(asset => {
      if (asset.status === State.DRAFT) {
        asset.draft = '解析中'
      } else if (asset.status === State.TRANSCODE_FAILURE) {
        asset.draft = '转码失败'
      } else {
        const tag = asset.tag
        asset.file = {
          type: asset.type,
          url: asset.keyName,
          thumb: getAssetThumb(asset),
          files: asset.childrenData?.length
            ? asset.childrenData.map(({ type, keyName, size, md5, sort }) => {
              // 仅会为图片
              return { tag, type, keyName, size, md5, sort }
            })
            : null
        }
      }
      asset.diff = getAssetDiff(asset)
    })
    return { data, totalCount }
  })
}

export function updateAsset (data) {
  return update({
    url: '/minio-data/update',
    method: 'POST',
    data
  })
}

export function deleteAsset ({ keyName, originalName }) {
  return del({
    url: '/minio-data/delete',
    method: 'DELETE',
    params: { keyName }
  }, originalName)
}

export function deleteAssets (keyNames) {
  return del({
    url: '/minio-data/batchDelete',
    method: 'POST',
    data: keyNames
  }, '所选资源')
}

export function getAssetUrl (keyName) {
  return `${process.env.VUE_APP_MINIO}/${keyName}`
}

const LIMIT_SIZE = 1024 * 1024
export function getThumbnailUrl (item, option) {
  let url
  if (item && typeof item === 'object') {
    const { size, keyName } = item
    if (size <= LIMIT_SIZE) {
      return getAssetUrl(keyName)
    }
    url = getAssetUrl(keyName)
    option = getImageProxyOption(option, size)
  } else {
    url = getAssetUrl(item)
    option = getImageProxyOption(option)
  }
  if (url.charAt(0) === '/') {
    url = `${process.env.VUE_APP_THUMBNAIL_ORIGIN || location.origin}${url}`
  }
  return `${process.env.VUE_APP_THUMBNAIL}/${option}/${url}`
}

function getImageProxyOption (option, size) {
  switch (option) {
    case 'size':
      return size ? `q${Math.ceil(LIMIT_SIZE * 100 / size)}` : 'q60'
    default:
      return option || 'x0.2,q30'
  }
}

export function submitAsset ({ keyName, originalName }) {
  return submit({
    url: '/minio-data/submit',
    method: 'GET',
    params: { keyName }
  }, originalName)
}

export function resolveAsset ({ keyName, originalName }) {
  return resolve({
    url: '/minio-data/reviewed',
    method: 'GET',
    params: { keyName }
  }, originalName)
}

export function rejectAsset ({ keyName }, remark) {
  return messageSend({
    url: '/minio-data/reject',
    method: 'POST',
    data: { keyName, remark }
  }, '驳回')
}

export function getAssetSubTags () {
  return tenantRequest({
    url: '/minio-data/subtag/queryList',
    method: 'GET',
    params: addTenant({})
  })
}

export function getAssetSubTagsByTenant (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/minio-data/subtag/queryListPage',
    method: 'GET',
    params: addTenant({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function addAssetSubTag (data) {
  return add({
    url: '/minio-data/subtag/add',
    method: 'POST',
    data: addTenant(data)
  }, tenantRequest)
}

export function updateAssetSubTag (data) {
  return update({
    url: '/minio-data/subtag/modify',
    method: 'PUT',
    data
  })
}

export function deleteAssetSubTag ({ id, name }) {
  return del({
    url: '/minio-data/subtag/delBatchByIds',
    method: 'POST',
    data: [id]
  }, name)
}

export function deleteAssetSubTags (ids) {
  return del({
    url: '/minio-data/subtag/delBatchByIds',
    method: 'POST',
    data: ids
  }, '所选标签')
}

export function getDatasets (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/media/dataset/pageQuery',
    method: 'GET',
    params: addTenant({
      pageIndex, pageSize,
      ...params
    })
  })
}

export function addDataset (data) {
  return add({
    url: '/media/dataset',
    method: 'POST',
    data: addTenant(data)
  }, tenantRequest)
}

export function copyDataset (data) {
  return messageSend({
    url: '/media/dataset/copy',
    method: 'POST',
    data
  }, '复制')
}

export function updateDataset (data) {
  return update({
    url: '/media/dataset',
    method: 'PUT',
    data
  })
}

export function getFillDataset (id) {
  return request({
    url: `/media/dataset/${id}`,
    params: {
      type: Dataset.FILL,
      flag: 1
    }
  })
}

export function getCommonDataset (id) {
  return request({
    url: '/media/dataset/order',
    params: {
      id,
      flag: 1
    }
  })
}

export function deleteDataset ({ id, name }) {
  return del({
    url: `/media/dataset/${id}`,
    method: 'DELETE'
  }, name)
}

export function bindAssetsToDataset (datasetId, assets) {
  return messageSend({
    url: '/media/dataset/batchBindAsset',
    method: 'POST',
    data: assets.map(item => {
      return {
        datasetId,
        ...item
      }
    })
  }, '添加')
}

export function updateDatasetAssets (datasetId, assets) {
  return update({
    url: '/media/dataset/orderBindAsset',
    method: 'POST',
    data: {
      id: datasetId,
      relationList: assets
    }
  })
}

export function getDevicesByDataset (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return request({
    url: '/media/dataset/pageQueryDevice',
    method: 'GET',
    params: {
      pageIndex, pageSize,
      ...params
    }
  })
}

export function countByDay (query) {
  return request({
    url: '/minio-data/usage/countByDay',
    method: 'GET',
    params: query
  })
}

// 查询媒资执行队列
export function listActivate (query) {
  return request({
    url: '/minio-data/mediaProcessTask/listActivate',
    method: 'GET',
    params: query
  })
}

export function mediaList (query) {
  const { pageNum: pageIndex, pageSize, ...params } = query
  return tenantRequest({
    url: '/minio-data/mediaProcessTask/pageQuery',
    method: 'GET',
    params: addTenant({
      pageIndex, pageSize,
      ...params
    })
  })
}

// 转换旧媒资
export function secondaryTransList (data) {
  return request({
    url: '/minio-data/mediaProcessTask/batchSave',
    method: 'POST',
    data
  })
}

export function treeLocation (data) {
  return request({
    url: '/minio-data/treeLocation',
    method: 'PUT',
    data
  })
}

export function getDatasetByDevice (id) {
  return request({
    url: `/media/dataset/${id}`,
    params: {
      type: 1,
      flag: 1
    }
  })
}

export function bindDatasetToDevice (data) {
  return messageSend({
    url: '/media/dataset/bindDevice',
    method: 'POST',
    data
  }, '绑定')
}

export function unbindDatasetByDevice ({ id, name }) {
  return confirmAndSend('解绑', name, {
    url: '/media/dataset/batchUnbindDevice',
    method: 'POST',
    data: [id]
  })
}

export function unbindDatasetByDevices (ids) {
  return confirmAndSend('解绑', '所选设备', {
    url: '/media/dataset/batchUnbindDevice',
    method: 'POST',
    data: ids
  })
}

export function unbindAssetsFromDataset (datasetId, keyNames) {
  return messageSend({
    url: `/media/dataset/batchUnbindAsset/${datasetId}`,
    method: 'POST',
    data: keyNames
  }, '移除')
}

export function updateDatasetAssetDuration (relationId, adDuration) {
  return update({
    url: '/media/dataset/assetChangDuration',
    method: 'POST',
    data: {
      relationId,
      adDuration
    }
  })
}