caimei-zplm-admin-api/src/main/java/com/caimei/service/data/impl/FileServiceImpl.java

package com.caimei.service.data.impl;

import com.caimei.mapper.FileMapper;
import com.caimei.model.ResponseJson;
import com.caimei.model.po.CourseFilePo;
import com.caimei.model.po.ProductImagePo;
import com.caimei.model.po.FilePo;
import com.caimei.model.vo.CourseFileListVo;
import com.caimei.model.vo.FileListVo;
import com.caimei.model.vo.WxFileListVo;
import com.caimei.service.data.FileService;
import com.caimei.utils.OSSUtils;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Date;
import java.util.List;

/**
 * Description
 *
 * @author : Aslee
 * @date : 2021/7/9
 */
@Slf4j
@Service
public class FileServiceImpl implements FileService {

    @Resource
    private FileMapper fileMapper;

    @Value("${aliyunConfig.accessKeyId}")
    private String accessKeyId;

    @Value("${aliyunConfig.accessKeySecret}")
    private String accessKeySecret;

    @Value("${aliyunConfig.bucketName}")
    private String bucketName;

    @Value("${aliyunConfig.endpoint}")
    private String endpoint;

    @Value("${spring.profiles.active}")
    private String active;

    @Override
    public ResponseJson<PageInfo<FileListVo>> getFileList(Integer listType, Integer authUserId, String fileTitle, Integer auditStatus, Integer status, Integer pageNum, Integer pageSize) {
        if (null == authUserId) {
            return ResponseJson.error("参数异常，请输入供应商用户id", null);
        }
        listType = null == listType ? 1 : listType;
        PageHelper.startPage(pageNum, pageSize);
        List<FileListVo> fileList = fileMapper.getFileList(listType, authUserId, fileTitle, auditStatus, status);
        PageInfo<FileListVo> pageData = new PageInfo<>(fileList);
        return ResponseJson.success(pageData);
    }

    @Override
    public ResponseJson saveFile(Integer fileId, Integer authUserId, String fileTitle, String fileName, String filePreviewUrl, String fileDownloadUrl) {
        if (null == fileId && null == authUserId) {
            return ResponseJson.error("参数异常，请输入供应商用户id");
        }
        if (StringUtils.isEmpty(fileTitle)) {
            return ResponseJson.error("参数异常，请输入文件标题");
        }
        if (StringUtils.isEmpty(fileName)) {
            return ResponseJson.error("参数异常，请输入文件名称");
        }
        if (null == filePreviewUrl || null == fileDownloadUrl) {
            return ResponseJson.error("参数异常，请上传文件");
        }
        /*
            组装文件数据
        */
        FilePo dataFile = new FilePo();
        dataFile.setTitle(fileTitle);
        dataFile.setPreviewUrl(filePreviewUrl);
        dataFile.setDownloadUrl(fileDownloadUrl);
        dataFile.setName(fileName);
        // 上线状态默认为“待上线”,审核状态为“待审核”
        dataFile.setStatus(2);
        dataFile.setAuditStatus(2);
        if (null != fileId) {
            /*
                更新文件
             */
            dataFile.setId(fileId);
            fileMapper.updateFileSelective(dataFile);
        } else {
            /*
                新增文件
             */
            dataFile.setAuthUserId(authUserId);
            dataFile.setCreateTime(new Date());
            fileMapper.insertFile(dataFile);
        }
        return ResponseJson.success("保存文件成功");
    }

    @Override
    public ResponseJson updateFileStatus(Integer fileId, Integer status) {
        if (null == fileId) {
            return ResponseJson.error("请输入文件id");
        }
        if (null == status) {
            return ResponseJson.error("请输入要更新的状态值");
        }
        fileMapper.updateFileStatusByFileId(fileId, status);
        if (0 == status) {
            return ResponseJson.success("下线文件成功");
        } else {
            return ResponseJson.success("上线文件成功");
        }
    }

    @Override
    public ResponseJson deleteFile(Integer fileId) {
        if (null == fileId) {
            return ResponseJson.error("参数异常，请输入文件id");
        }
        // 删除文件
        fileMapper.deleteFileByFileId(fileId);
        return ResponseJson.success("删除文件成功");
    }

    @Override
    public ResponseJson auditFile(Integer fileId, Integer auditStatus, String invalidReason, Integer auditBy) {
        if (null == fileId) {
            return ResponseJson.error("请输入文件id");
        }
        if (null == auditStatus) {
            return ResponseJson.error("请输入审核结果");
        }
        if (0 == auditStatus && StringUtils.isEmpty(invalidReason)) {
            return ResponseJson.error("请输入审核不通过的原因");
        }
        if (null == auditBy) {
            return ResponseJson.error("请输入审核人用户id");
        }
        Date auditTime = new Date();
        // 授权状态更新
        Integer status = null;
        if (0 == auditStatus) {
            // 审核不通过，下线文件
            status = 0;
        } else {
            // 审核通过，上线文件
            status = 1;
        }
        fileMapper.updateFileAuditStatus(fileId, status, auditStatus, invalidReason, auditBy, auditTime);
        return ResponseJson.success("审核文件成功");
    }

    @Override
    public ResponseJson<PageInfo<WxFileListVo>> getWxFileList(Integer authUserId, String fileTitle, Integer pageNum, Integer pageSize) {
        if (null == authUserId) {
            return ResponseJson.error("参数异常，供应商用户id不能为空", null);
        }
        PageHelper.startPage(pageNum, pageSize);
        List<WxFileListVo> fileList = fileMapper.getWxFileList(authUserId, fileTitle);
        PageInfo<WxFileListVo> pageData = new PageInfo<>(fileList);
        return ResponseJson.success(pageData);
    }

    @Override
    public void download() {
        String filePath = "/mnt/newdatadrive/data/runtime/jar-instance/zplma/atuhImage/";
        List<ProductImagePo> authImageList = fileMapper.getAuthImageData();
        authImageList.forEach(authImage->{
            try {
                String imageUrl = authImage.getCertificateImage();
                HttpURLConnection httpUrl = (HttpURLConnection) new URL(imageUrl).openConnection();
                httpUrl.connect();
                //通过输入流获取图片数据
                InputStream inStream = httpUrl.getInputStream();
                //得到图片的二进制数据，以二进制封装得到数据，具有通用性
                byte[] data = readInputStream(inStream);
                //new一个文件对象用来保存图片，默认保存当前工程根目录
                File imageFile = new File(filePath + authImage.getAuthParty() + "-" + authImage.getSnCode() + ".jpg");
                //创建输出流
                FileOutputStream outStream = new FileOutputStream(imageFile);
                //写入数据
                outStream.write(data);
                //关闭输出流
                outStream.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }


        });


    }

    private byte[] readInputStream(InputStream inStream) throws Exception{
        ByteArrayOutputStream outStream = new ByteArrayOutputStream();
        //创建一个Buffer字符串
        byte[] buffer = new byte[1024];
        //每次读取的字符串长度，如果为-1，代表全部读取完毕
        int len = 0;
        //使用一个输入流从buffer里把数据读取出来
        while( (len=inStream.read(buffer)) != -1 ){
            //用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度
            outStream.write(buffer, 0, len);
        }
        //关闭输入流
        inStream.close();
        //把outStream里的数据写入内存
        return outStream.toByteArray();
    }

    @Override
    public ResponseJson saveCourseFile(Integer fileId, String fileTitle, String fileName, String ossName, Integer fileType, String fileModule) {
        if (StringUtils.isEmpty(fileTitle)) {
            return ResponseJson.error("参数异常，请输入文件标题");
        }
        if (StringUtils.isEmpty(fileName)) {
            return ResponseJson.error("参数异常，请输入文件名称");
        }
        if (StringUtils.isEmpty(ossName)) {
            return ResponseJson.error("参数异常，请上传文件");
        }
        if (null == fileType) {
            return ResponseJson.error("参数异常，请选择文件类型");
        }
        if (null == fileModule) {
            return ResponseJson.error("参数异常，请选择所属模块");
        }
        /*
            组装文件数据
        */
        CourseFilePo courseFile = new CourseFilePo();
        courseFile.setTitle(fileTitle);
        courseFile.setOssName(ossName);
        courseFile.setName(fileName);
        courseFile.setFileType(fileType);
        courseFile.setFileModule(fileModule);
        if (null != fileId) {
            /*
                更新文件
             */
            courseFile.setId(fileId);
            fileMapper.updateCourseFile(courseFile);
        } else {
            /*
                新增文件
             */
            fileMapper.insertCourseFile(courseFile);
        }
        return ResponseJson.success("保存成功");
    }

    @Override
    public ResponseJson<PageInfo<CourseFileListVo>> getCourseFileList(Integer fileType, String fileModule, String fileTitle, Integer pageNum, Integer pageSize) {
        if (null == fileType) {
            return ResponseJson.error("参数异常，请输入文件类型", null);
        }
        PageHelper.startPage(pageNum, pageSize);
        List<CourseFileListVo> fileList = fileMapper.getCourseFileList(fileType, fileModule, fileTitle);
        fileList.forEach(file-> file.setFileUrl(OSSUtils.getOssUrl(file.getOssName())));
        PageInfo<CourseFileListVo> pageData = new PageInfo<>(fileList);
        return ResponseJson.success(pageData);
    }

    @Override
    public ResponseJson deleteCourseFile(Integer fileId) {
        if (null == fileId) {
            return ResponseJson.error("参数异常，请输入文件id");
        }
        // 删除文件
        fileMapper.deleteCourseFileByFileId(fileId);
        return ResponseJson.success("删除文件成功");
    }
}