spring_qiniu/

upload.rs

use crate::config::QiniuConfig;
use anyhow::{anyhow, Result};
use bytes::Bytes;
use qiniu_sdk::apis::credential::Credential;
pub use qiniu_sdk::upload::{AutoUploader, AutoUploaderObjectParams, UploadManager, UploadTokenSigner};
use std::fmt::Debug;
use std::path::Path;
use std::time::Duration;
use tokio::fs::metadata;

#[derive(Debug, Clone)]
pub struct QiniuUpload {
    pub config: QiniuConfig,
    pub upload_manager: UploadManager,
}

/// # 构建文件对象
/// - 文件路径: {desk}/{mine}/{name} 示例：129382362732/image/3j28d3282-82h93h23-78hd8237-h2d83d32.jpg
#[derive(Debug, Clone)]
pub struct QiniuFile {
    // 域名
    pub domain: String,
    // 存储空间 - store10001
    pub desk: String,
    // 文件类型：image / video / audio / text
    pub mine: String,
    // 文件名称: 123456.jpg
    pub name: String,
    // hash
    pub hash: String,
}

impl QiniuFile {
    pub fn url(&self) -> String {
        format!("{}/{}/{}/{}", self.domain, self.desk, self.mine, self.name)
    }
}

impl QiniuUpload {
    pub fn new(config: QiniuConfig) -> Self {
        let upload_manager = UploadManager::builder(UploadTokenSigner::new_credential_provider(
            Credential::new(&config.access_key, &config.secret_key),
            &config.bucket_name,
            Duration::from_secs(3600),
        )).build();
        QiniuUpload { config, upload_manager }
    }
    pub fn re_build(&mut self) {
        self.upload_manager = UploadManager::builder(UploadTokenSigner::new_credential_provider(
            Credential::new(&self.config.access_key, &self.config.secret_key),
            &self.config.bucket_name,
            Duration::from_secs(3600),
        )).build();
    }
    pub async fn upload_image(&self, disk: &str, file: &str) -> Result<QiniuFile> {
        let (ext, size) = &self.get_file_info(file).await?;
        if *size > self.config.image_size {
            return Err(anyhow!("图片大小超出限制: {}", self.config.image_size));
        }
        // 验证文件类型
        if !self.config.image_ext.contains(&ext.to_string()) {
            return Err(anyhow!("图片格式仅允许: {}", self.config.image_ext.join("、")).into());
        }
        self.upload_file(disk, "image", &ext, file).await
    }
    pub async fn upload_image_bytes(&self, disk: &str, ext: &str, bytes: &Bytes) -> Result<QiniuFile> {
        let size = bytes.len() as u64;
        if size > self.config.image_size {
            return Err(anyhow!("图片大小超出限制: {}", self.config.image_size).into());
        }
        // 验证文件类型
        if !self.config.image_ext.contains(&ext.to_string()) {
            return Err(anyhow!("图片格式仅允许: {}", self.config.image_ext.join("、")).into());
        }
        self.upload_render(disk, "image", &ext, bytes).await
    }
    pub async fn upload_video(&self, disk: &str, file: &str) -> Result<QiniuFile> {
        let (ext, size) = &self.get_file_info(file).await?;
        if *size > self.config.video_size {
            return Err(anyhow!("视频大小超出限制: {}", self.config.video_size).into());
        }
        // 验证文件类型
        if !self.config.video_ext.contains(&ext.to_string()) {
            return Err(anyhow!("视频格式仅允许: {}", self.config.video_ext.join("、")).into());
        }
        self.upload_file(disk, "video", &ext, file).await
    }
    pub async fn upload_video_bytes(&self, disk: &str, ext: &str, bytes: &Bytes) -> Result<QiniuFile> {
        let size = bytes.len() as u64;
        if size > self.config.video_size {
            return Err(anyhow!("视频大小超出限制: {}", self.config.video_size).into());
        }
        // 验证文件类型
        if !self.config.video_ext.contains(&ext.to_string()) {
            return Err(anyhow!("视频格式仅允许: {}", self.config.video_ext.join("、")).into());
        }
        self.upload_render(disk, "video", &ext, bytes).await
    }
    async fn upload_file(&self, disk: &str, mine: &str, ext: &str, file: &str) -> Result<QiniuFile> {
        if !disk.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
            return Err(anyhow!("无效的 disk 参数"));
        }
        if !mine.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
            return Err(anyhow!("无效的 mine 参数"));
        }
        let name = format!("{}.{}", uuid::Uuid::new_v4(), ext).replace("-", "").to_lowercase();
        let object_name = &format!("{}/{}/{}", disk, mine, name);
        let params = AutoUploaderObjectParams::builder().object_name(object_name).build();
        let uploader: AutoUploader = self.upload_manager.auto_uploader();
        uploader.async_upload_path(file, params).await.and_then(|e| {
            Ok(QiniuFile {
                domain: self.config.domain.clone(),
                desk: disk.to_string(),
                mine: mine.to_string(),
                name,
                hash: e.get("hash").unwrap().as_str().unwrap().to_string(),
            })
        }).map_err(|e| {
            anyhow!("上传失败: {}", e.to_string())
        })
    }
    async fn upload_render(&self, disk: &str, mine: &str, ext: &str, bytes: &Bytes) -> Result<QiniuFile> {
        if !disk.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
            return Err(anyhow!("无效的 disk 参数"));
        }
        if !mine.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
            return Err(anyhow!("无效的 mine 参数"));
        }
        if bytes.len() == 0 {
            return Err(anyhow!("上传的数据不能为空"));
        }
        let name = format!("{}.{}", uuid::Uuid::new_v4(), ext).replace("-", "").to_lowercase();
        let object_name = format!("{}/{}/{}", disk, mine, name);
        let params = AutoUploaderObjectParams::builder().object_name(&object_name).build();
        let uploader: AutoUploader = self.upload_manager.auto_uploader();
        let temp = format!("tmp/{}", &object_name);

        // 先存储到临时目录，再上传到云端
        let path = Path::new(&temp);
        if let Some(parent) = path.parent() {
            tokio::fs::create_dir_all(parent)
                .await
                .map_err(|err| anyhow!("临时目录创建失败: {}", err))?;
        }
        tokio::fs::write(&temp, bytes)
            .await
            .map_err(|_| anyhow!("上传文件缓存失败"))?;

        // 上传到云端
        let res = uploader.async_upload_path(&temp, params).await;

        // 删除本地缓存
        tokio::fs::remove_file(&temp)
            .await
            .map_err(|_| anyhow!("删除本地缓存文件失败"))?;

        // 返回结果
        res.and_then(|e| {
            Ok(QiniuFile {
                domain: self.config.domain.clone(),
                desk: disk.to_string(),
                mine: mine.to_string(),
                name,
                hash: e.get("hash").unwrap().as_str().unwrap().to_string(),
            })
        }).map_err(|e| {
            anyhow!("上传失败: {}", e.to_string())
        })
    }
    async fn get_file_info(&self, file: &str) -> Result<(String, u64)> {
        let path = Path::new(file);
        if !path.is_file() {
            return Err(anyhow!("文件不存在"));
        }
        let ext = path.extension().and_then(|e| e.to_str());
        if ext.is_none() {
            return Err(anyhow!("文件后缀名不存在"));
        }
        let metadata = metadata(path).await.map_err(|_| {
            anyhow!("文件类型错误")
        })?;
        let file_size = metadata.len();
        Ok((ext.unwrap().to_string(), file_size))
    }
}