The front-end uses minio to transfer files and expand the code and the extension

npm install [email protected] --save

const Minio = require('minio')
 
const minioClient = new ({
  endPoint: '192.l68.0.1', //Minio server IP, you cannot add http://  port: 9000,
  accessKey: 'xxxx', //username
  secretKey: 'xxxx', //password
  useSSL: false  //https access needs to be set to true})

const stream = require('stream')
 
/**
  *
  * @export Upload file (stream stream method)
  * @param {*} backetName String Bucket Name
  * @param {*} fileObj Object file object
  * @param {*} callback function
  */
export function uploadFile (backetName, fileObj, callback) {
  (backetName, fileObj)
  if (fileObj) {
    const file = fileObj
    if (file === undefined) {
      // Not selected    } else {
      const date = new Date()
      const year = new Date().getFullYear()
      const month =
        () + 1 < 10
          ? '0' + (() + 1)
          : () + 1
      const day = () > 9 ? () : '0' + ()
      const fileName = () + 
      const fileDate = '' + year + month + day
      const mineType = 
      const fileSize = 
      ('fileName', fileName)
      // Parameters      const metadata = {
        'content-type': mineType,
        'content-length': fileSize
      }
      // Determine whether the storage bucket exists      (backetName, function (err) {
        ('Judge whether the storage bucket exists')
        if (err) {
          if ( === 'NoSuchBucket') {
            return ('bucket does not exist.')
          }
          ('1233221')
          return (err)
        }
        // Prepare to upload        const reader = new FileReader()
        (file)
         = function (e) {
          const dataurl = 
          const blob = toBlob(dataurl)
          const reader2 = new FileReader()
          (blob)
           = function (ex) {
            const bufferStream = new ()
            (())
            (
              backetName,
              `${fileDate}/${fileName}`,
              bufferStream,
              fileSize,
              metadata,
              (err) => {
                if (err == null) {
                  (
                    backetName,
                    `${fileDate}/${fileName}`,
                    24 * 60 * 60,
                    function (err1, presignedUrl) {
                      (err1)
                      if (err1) return
                      if (presignedUrl) {
                        const arr = ('?')
                        if ( === 2) {
                          callback(arr[0])
                        }
                      }
                    }
                  )
                }
              }
            )
          }
        }
      })
    }
  }
}
 
/**
  *
  * @export base64 to blob
  * @param {*} base64Data Object base64 data
  * @return {*} blob
  */
export function toBlob (base64Data) {
  let byteString = base64Data
  if ((',')[0].indexOf('base64') >= 0) {
    byteString = ((',')[1]) // base64 decoding  } else {
    byteString = unescape((',')[1])
  }
  // Get file type  const mimeString = (';')[0].split(':')[1] // mime type  const uintArr = new Uint8Array() // Create a view 
  for (let i = 0; i < ; i++) {
    uintArr[i] = (i)
  }
  const blob = new Blob([uintArr], {
    type: mimeString
  })
  return blob
}
 
// First determine whether the bucket exists. If you can ensure that the poke already exists, directly call the uploadFile methodexport function checkedAndUpload (bucketName, info, callback) {
  (bucketName, err => {
    if (err) {
      (bucketName, 'us-east-1', err1 => {
        if (err1) {
          (`${}File upload failed`)
          return
        }
        uploadFile(bucketName, info, callback)
      })
    } else {
      uploadFile(bucketName, info, callback)
    }
  })
}
 
// First determine whether the bucket existsexport function connectionStatus (bucketName, callback) {
  (bucketName, err => {
    (err)
    callback(err)
  })
}

const bucketName = 'picturebook-version'; // Replace with your bucket nameconst objectName = ; // Use file name as object name
//Create FileReader objectconst reader = new FileReader();

// Callback function triggered when reading is completed = (event) => {
	// Get file content from event object	const fileContent = ;

	// Convert ArrayBuffer to Buffer type data	const buffer = (fileContent);
	
	//Upload file content using putObject method	(bucketName, objectName, buffer, , (err, etag) => {
		if (err) {
			('Uploading file failed:', err);
		} else {
			();
			 = objectName;
			 ('File upload successfully, ETag:', etag);
		}
	});
};

// Start reading the file();

 
export function downloadFile (bucketName, fileName, callback) {
  (bucketName, fileName, (err, dataStream) => {
    callback(err, dataStream)
  })
}

<div @click="selectFile" style="cursor: pointer; width: 80px; text-align: right"
 class="ant-upload-text" > Upload </div>
<input type="file  ref="uploadInput" v-show="false" @change="changeInput()"/>

import { uploadFile } from '@/utils/minio'
 
selectFile() {
  const inputDOM = this.$
  ()
},
changeInput() {
  const file = this.$
  if () {
     = {
      name: file[0].name,
      size: file[0].size,
      type: file[0].type,
    }
    uploadFile('carbon', file[0], (e) => {
       this.$ = ''
        = {
         ...,
         url: e,
       }
    })
  }
},