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

import request, { tenantRequest } from '@/utils/request'
import {
  getAssetThumb,
  getAssetDiff
} from '@/utils'
import {
  send,
  add,
  del,
  update,
  submit,
  resolve,
  reject,
  confirmAndSend,
  canDel,
  addStatus,
  addStatusScope,
  addTenant,
  addTenantAndOrg
} from './base'

export function addAsset (data) {
  return add({
    url: '/minio-data',
    method: 'POST',
    data: addTenantAndOrg(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, ...params } = query
  return tenantRequest({
    url: '/minio-data/listByPage',
    method: 'POST',
    data: addStatus({
      currentPage, pageCount,
      ...params
    })
  }).then(({ data, totalCount }) => {
    data.forEach(asset => {
      const tag = asset.tag
      asset.file = {
        type: asset.type,
        url: asset.keyName,
        thumb: getAssetThumb(asset),
        files: (asset.childrenData || []).map(({ type, keyName, size, md5 }) => {
          return { type, url: keyName, thumb: keyName, keyName, size, md5, tag }
        })
      }
      asset.diff = getAssetDiff(asset)
    })
    return { data, totalCount }
  })
}

export function getAssets (query) {
  return getAssetsByQuery(addStatusScope(query))
}

export function getAssetsWithDel (query) {
  return getAssets(query).then(({ data, totalCount }) => {
    data.forEach(asset => {
      asset.del = canDel(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, originalName }, remark) {
  return reject({
    url: '/minio-data/reject',
    method: 'POST',
    data: { keyName, remark }
  }, originalName)
}

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 updateDataset (data) {
  return update({
    url: '/media/dataset',
    method: 'PUT',
    data
  })
}

export function getFillDataset (id) {
  return request({
    url: `/media/dataset/${id}`,
    params: {
      type: 0,
      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 send({
    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 getDatasetByDevice (id) {
  return request({
    url: `/media/dataset/${id}`,
    params: {
      type: 1,
      flag: 1
    }
  })
}

export function bindDatasetToDevice (data) {
  return send({
    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 send({
    url: `/media/dataset/batchUnbindAsset/${datasetId}`,
    method: 'POST',
    data: keyNames
  })
}

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