package com.vci.web.util.file.clientutil;
|
|
import com.vci.dto.VciFileObjectDTO;
|
import com.vci.dto.VciFileShareDTO;
|
import com.vci.dto.VciFileShareHasClassifyDTO;
|
import com.vci.pagemodel.VciFileObjectVO;
|
import com.vci.pagemodel.VciFileShareResultVO;
|
import com.vci.properties.VciFileTransProperties;
|
import com.vci.provider.VciFileDownloadProvider;
|
import com.vci.provider.VciFileQueryProvider;
|
import com.vci.provider.VciFileUploadProvider;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.pagemodel.BaseModelVO;
|
import com.vci.starter.web.pagemodel.BaseResult;
|
import com.vci.starter.web.util.BeanUtilForVCI;
|
import com.vci.starter.web.util.LangBaseUtil;
|
import com.vci.starter.web.util.LocalFileUtil;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.web.util.file.VciZipUtil;
|
import net.lingala.zip4j.core.ZipFile;
|
import net.lingala.zip4j.exception.ZipException;
|
import org.apache.commons.fileupload.FileItem;
|
import org.apache.commons.fileupload.FileItemFactory;
|
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
|
import org.apache.commons.io.IOUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.web.multipart.MultipartFile;
|
import org.springframework.web.multipart.commons.CommonsMultipartFile;
|
|
import java.io.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author ludc
|
* @date 2024/7/16 14:43
|
*/
|
@Component
|
public class VciFileServerClientUtil {
|
public static final int BLOCKSIZE = 1048576;
|
@Autowired(
|
required = false
|
)
|
private VciFileUploadProvider vciFileUploadProvider;
|
@Autowired(
|
required = false
|
)
|
private VciFileDocClassifyClientUtil fileDocClassifyClientUtil;
|
@Autowired
|
private VciFileTransProperties vciFileTransProperties;
|
@Autowired(
|
required = false
|
)
|
private VciFileQueryProvider vciFileQueryProvider;
|
@Autowired(
|
required = false
|
)
|
private VciFileDownloadProvider vciFileDownloadProvider;
|
@Autowired
|
private VciZipUtil zipUtil;
|
|
public VciFileServerClientUtil() {
|
}
|
|
public String getFileExtension(String fileName) {
|
String fileExtension = "";
|
if (fileName.indexOf(".") > -1) {
|
fileExtension = fileName.substring(fileName.lastIndexOf(".") + 1);
|
}
|
|
return fileExtension;
|
}
|
|
public String getFileNameNoExtension(String fileName) {
|
String fileNameNoExtension = fileName.substring(0, fileName.lastIndexOf("."));
|
return fileNameNoExtension;
|
}
|
|
private void getFileFromFolder(File folderFile, Set<File> sourceFileSet) {
|
File[] fileArr = folderFile.listFiles();
|
File[] var4 = fileArr;
|
int var5 = fileArr.length;
|
|
for(int var6 = 0; var6 < var5; ++var6) {
|
File file = var4[var6];
|
if (file.isFile()) {
|
sourceFileSet.add(file);
|
}
|
|
if (file.isDirectory()) {
|
this.getFileFromFolder(file, sourceFileSet);
|
}
|
}
|
|
}
|
|
public String getFileDocClassifyName(String classifyId) throws VciBaseException {
|
return this.fileDocClassifyClientUtil.selectDocClassifyNameById(classifyId);
|
}
|
|
public BaseResult<VciFileObjectVO> uploadFile(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据业务类型", fileObjectDTO.getSourceFilePath(), "文件路径", fileObjectDTO.getFileDocClassify(), "文档类型编号"});
|
List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
|
Map<String, File> sourceFileMap = new HashMap();
|
String sourceFilePath = fileObjectDTO.getSourceFilePath();
|
File sourceFile = new File(sourceFilePath);
|
if (!sourceFile.exists()) {
|
throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
|
} else {
|
String _key;
|
if (StringUtils.isNotBlank(fileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(fileObjectDTO.getFileDocClassifyName())) {
|
_key = this.getFileDocClassifyName(fileObjectDTO.getFileDocClassify());
|
fileObjectDTO.setFileDocClassifyName(_key);
|
}
|
|
fileObjectDTO.setFileExtension(this.getFileExtension(sourceFile.getName()));
|
if (StringUtils.isBlank(fileObjectDTO.getName())) {
|
fileObjectDTO.setName(this.getFileNameNoExtension(sourceFile.getName()));
|
}
|
|
if (StringUtils.isBlank(fileObjectDTO.getId())) {
|
fileObjectDTO.setId(fileObjectDTO.getName());
|
}
|
|
fileObjectDTO.setFileSize(sourceFile.length());
|
vciFileObjectDTOS.add(fileObjectDTO);
|
_key = fileObjectDTO.getId() + "{##$$}" + fileObjectDTO.getName();
|
sourceFileMap.put(_key, sourceFile);
|
Map<String, VciFileObjectVO> resultMap = this.uploadFile((List)vciFileObjectDTOS, (Map)sourceFileMap);
|
BaseResult result = new BaseResult();
|
if (resultMap != null && resultMap.size() > 0) {
|
List<VciFileObjectVO> resultList = (List)resultMap.values().stream().collect(Collectors.toList());
|
result.setData(resultList);
|
result.setMsg("uploadSuccess");
|
result.setObj(resultMap.get(sourceFilePath));
|
result.setSuccess(true);
|
} else {
|
result.setMsg("uploadFail");
|
}
|
|
return result;
|
}
|
}
|
|
public Map<String, VciFileObjectVO> batchUploadFiles(List<VciFileObjectDTO> fileObjectDTOS) throws VciBaseException {
|
Iterator var2 = fileObjectDTOS.iterator();
|
|
while(var2.hasNext()) {
|
VciFileObjectDTO vciFileObjectDTO = (VciFileObjectDTO)var2.next();
|
VciBaseUtil.alertNotNull(new Object[]{vciFileObjectDTO, "文件传输对象", vciFileObjectDTO.getOwnbizOid(), "业务数据主键", vciFileObjectDTO.getOwnBtmname(), "业务数据业务类型", vciFileObjectDTO.getSourceFilePath(), "文件路径", vciFileObjectDTO.getFileDocClassify(), "文档类型编号"});
|
}
|
|
Map<String, File> sourceFileMap = new HashMap();
|
Iterator var9 = fileObjectDTOS.iterator();
|
|
while(var9.hasNext()) {
|
VciFileObjectDTO vciFileObjectDTO = (VciFileObjectDTO)var9.next();
|
String sourceFilePath = vciFileObjectDTO.getSourceFilePath();
|
File sourceFile = new File(sourceFilePath);
|
if (!sourceFile.exists()) {
|
throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
|
}
|
|
String _key;
|
if (StringUtils.isNotBlank(vciFileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(vciFileObjectDTO.getFileDocClassifyName())) {
|
_key = this.getFileDocClassifyName(vciFileObjectDTO.getFileDocClassify());
|
vciFileObjectDTO.setFileDocClassifyName(_key);
|
}
|
|
vciFileObjectDTO.setFileExtension(this.getFileExtension(sourceFile.getName()));
|
if (StringUtils.isBlank(vciFileObjectDTO.getName())) {
|
vciFileObjectDTO.setName(this.getFileNameNoExtension(sourceFile.getName()));
|
}
|
|
if (StringUtils.isBlank(vciFileObjectDTO.getId())) {
|
vciFileObjectDTO.setId(vciFileObjectDTO.getName());
|
}
|
|
vciFileObjectDTO.setFileSize(sourceFile.length());
|
_key = vciFileObjectDTO.getId() + "{##$$}" + vciFileObjectDTO.getName();
|
sourceFileMap.put(_key, sourceFile);
|
}
|
|
return this.uploadFile((List)fileObjectDTOS, (Map)sourceFileMap);
|
}
|
|
public Map<String, VciFileObjectVO> uploadFileForFolder(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件数据传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据的类型", fileObjectDTO.getDirPath(), "文件夹", fileObjectDTO.getFileDocClassify(), "文档类型"});
|
Map<String, File> sourceFileMap = new HashMap();
|
List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
|
String dirPath = fileObjectDTO.getDirPath();
|
File dirFile = new File(dirPath);
|
if (!dirFile.isDirectory()) {
|
throw new VciBaseException("isNotFolder", new String[]{dirFile.getName()});
|
} else if (!dirFile.exists()) {
|
throw new VciBaseException("folderNotExist", new String[]{dirFile.getName()});
|
} else {
|
Set<File> sourceFileSet = new HashSet();
|
this.getFileFromFolder(dirFile, sourceFileSet);
|
if (StringUtils.isNotBlank(fileObjectDTO.getFileDocClassify()) && StringUtils.isBlank(fileObjectDTO.getFileDocClassifyName())) {
|
String classifyName = this.getFileDocClassifyName(fileObjectDTO.getFileDocClassify());
|
fileObjectDTO.setFileDocClassifyName(classifyName);
|
}
|
|
Iterator var11 = sourceFileSet.iterator();
|
|
while(var11.hasNext()) {
|
File file = (File)var11.next();
|
VciFileObjectDTO tempDTO = new VciFileObjectDTO();
|
BeanUtilForVCI.convert(fileObjectDTO, tempDTO);
|
tempDTO.setFileExtension(this.getFileExtension(file.getName()));
|
tempDTO.setName(this.getFileNameNoExtension(file.getName()));
|
tempDTO.setId(this.getFileNameNoExtension(file.getName()));
|
tempDTO.setFileSize(file.length());
|
vciFileObjectDTOS.add(tempDTO);
|
String _key = tempDTO.getId() + "{##$$}" + tempDTO.getName();
|
sourceFileMap.put(_key, file);
|
}
|
|
return this.uploadFile((List)vciFileObjectDTOS, (Map)sourceFileMap);
|
}
|
}
|
|
private Map<String, VciFileObjectVO> uploadFile(List<VciFileObjectDTO> vciFileObjectDTOS, Map<String, File> sourceFileMap) throws VciBaseException {
|
VciFileObjectDTO parameterObject = new VciFileObjectDTO();
|
parameterObject.setVciFileObjectDTOList(vciFileObjectDTOS);
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileUploadProvider.initUploadFileInfo(parameterObject);
|
if (baseResult.getData() != null && baseResult.getData().size() != 0) {
|
Map<String, VciFileObjectVO> resultMap = new HashMap();
|
Iterator var6 = baseResult.getData().iterator();
|
|
while(var6.hasNext()) {
|
VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)var6.next();
|
String _key = vciFileObjectVO.getId() + "{##$$}" + vciFileObjectVO.getName();
|
File sourceFile = (File)sourceFileMap.get(_key);
|
String sourceFilePath = sourceFile.getAbsolutePath();
|
String tempFolder = sourceFile.getParent() + File.separator + VciBaseUtil.getPk();
|
File tempFolderFile = new File(tempFolder);
|
if (!tempFolderFile.exists()) {
|
tempFolderFile.mkdirs();
|
}
|
|
BaseResult tempBaseResult = null;
|
long fileSize = vciFileObjectVO.getFileSize();
|
FileInputStream in = null;
|
|
try {
|
in = new FileInputStream(sourceFile);
|
byte[] buffer = new byte[1048576];
|
|
int temp;
|
for(temp = 0; (long)temp < fileSize - 1048576L; temp += 1048576) {
|
in.read(buffer, 0, 1048576);
|
MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
|
tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, (long)temp, vciFileObjectVO.getOid());
|
if (!tempBaseResult.isSuccess()) {
|
throw new VciBaseException(tempBaseResult.getMsg());
|
}
|
}
|
|
int remainSize = (int)(fileSize - (long)temp);
|
buffer = new byte[remainSize];
|
in.read(buffer, 0, remainSize);
|
MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
|
tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, (long)temp, vciFileObjectVO.getOid());
|
if (!tempBaseResult.isSuccess()) {
|
throw new VciBaseException(tempBaseResult.getMsg());
|
}
|
|
resultMap.put(sourceFilePath, (VciFileObjectVO)tempBaseResult.getObj());
|
} catch (FileNotFoundException var30) {
|
throw new VciBaseException("fileNotFound", new String[]{sourceFile.getName()});
|
} catch (IOException var31) {
|
throw new VciBaseException("fileReadFail", new String[]{var31.getMessage()});
|
} catch (Exception var32) {
|
throw new VciBaseException("uploadFail", new String[]{var32.getMessage()});
|
} finally {
|
if (in != null) {
|
try {
|
in.close();
|
} catch (IOException var29) {
|
var29.printStackTrace();
|
}
|
}
|
|
LocalFileUtil.deleteFile(tempFolderFile);
|
}
|
}
|
|
return resultMap;
|
} else {
|
throw new VciBaseException("fileInfoInitFail");
|
}
|
}
|
|
public MultipartFile getMultipartFile(byte[] buffer, File tempFolderFile) {
|
FileItemFactory factory = new DiskFileItemFactory(10240, tempFolderFile);
|
FileItem item = factory.createItem("file", "multipart/form-data", true, VciBaseUtil.getPk());
|
OutputStream os = null;
|
|
try {
|
os = item.getOutputStream();
|
os.write(buffer);
|
os.close();
|
} catch (IOException var10) {
|
var10.printStackTrace();
|
} finally {
|
IOUtils.closeQuietly(os);
|
}
|
|
MultipartFile mfile = new CommonsMultipartFile(item);
|
return mfile;
|
}
|
|
public BaseResult<VciFileObjectVO> uploadFileByZip(String zipFilePath, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
if (StringUtils.isBlank(zipFilePath)) {
|
throw new VciBaseException("fileNull");
|
} else {
|
File zipFile = new File(zipFilePath);
|
if (!zipFile.exists()) {
|
throw new VciBaseException("fileNotFound", new String[]{zipFile.getName()});
|
} else {
|
return this.uploadFileByZip(zipFile, fileObjectDTO);
|
}
|
}
|
}
|
|
public BaseResult<VciFileObjectVO> uploadFileByZip(File zipFile, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
if (zipFile != null && zipFile.exists()) {
|
ZipFile zipFileObj = null;
|
|
try {
|
zipFileObj = new ZipFile(zipFile);
|
if (!zipFileObj.isValidZipFile()) {
|
throw new VciBaseException("zipFileError");
|
}
|
} catch (ZipException var5) {
|
throw new VciBaseException("zipFileReadError");
|
}
|
|
return this.uploadFileByZip(zipFileObj, fileObjectDTO);
|
} else {
|
throw new VciBaseException("fileNotFound", new String[]{zipFile.getName()});
|
}
|
}
|
|
public BaseResult<VciFileObjectVO> uploadFileByZip(ZipFile zipFile, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件数据传输对象", fileObjectDTO.getOwnbizOid(), "业务数据主键", fileObjectDTO.getOwnBtmname(), "业务数据的类型", fileObjectDTO.getFileDocClassify(), "文档类型"});
|
String tempFolderPath = zipFile.getFile().getParentFile() + File.separator + VciBaseUtil.getPk();
|
File tempFolder = new File(tempFolderPath);
|
if (!tempFolder.exists()) {
|
tempFolder.mkdirs();
|
}
|
|
try {
|
zipFile.setFileNameCharset(this.vciFileTransProperties.getZipCharset());
|
zipFile.extractAll(tempFolderPath);
|
} catch (ZipException var10) {
|
throw new VciBaseException("zipFileReadError");
|
}
|
|
fileObjectDTO.setDirPath(tempFolderPath);
|
BaseResult baseResult = new BaseResult();
|
Map resultMap = null;
|
|
try {
|
resultMap = this.uploadFileForFolder(fileObjectDTO);
|
} catch (Exception var9) {
|
File folderFile = new File(tempFolderPath);
|
LocalFileUtil.deleteFile(folderFile);
|
throw new VciBaseException("uploadFail");
|
}
|
|
if (resultMap != null && resultMap.size() > 0) {
|
List<VciFileObjectVO> resultList = (List)resultMap.values().stream().collect(Collectors.toList());
|
baseResult.setData(resultList);
|
baseResult.setMsg("uploadSuccess");
|
baseResult.setSuccess(true);
|
} else {
|
baseResult.setMsg("uploadFail");
|
}
|
|
File folderFile = new File(tempFolderPath);
|
LocalFileUtil.deleteFile(folderFile);
|
return baseResult;
|
}
|
|
public BaseResult<VciFileObjectVO> shareFilesToBO(String sourceBtmName, String sourceBusinessOid, String btmName, String businessOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{sourceBtmName, "原业务类型", sourceBusinessOid, "原业务数据主键", btmName, "业务类型", businessOid, "业务数据主键"});
|
return this.vciFileUploadProvider.shareFilesToBO(sourceBtmName, sourceBusinessOid, btmName, businessOid);
|
}
|
|
public BaseResult shareFilesToBO(String fileOids, String btmName, String businessOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileOids, "文件主键", btmName, "业务类型", businessOid, "业务数据主键"});
|
return this.vciFileUploadProvider.shareFilesToBO(fileOids, btmName, businessOid);
|
}
|
|
public BaseResult shareAnnexFilesToBO(String sourceBtmName, String sourceBusinessOid, String btmName, String businessOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{sourceBtmName, "原业务类型", sourceBusinessOid, "原业务数据主键", btmName, "业务类型", businessOid, "业务数据主键"});
|
return this.vciFileUploadProvider.shareAnnexFilesToBO(sourceBtmName, sourceBusinessOid, btmName, businessOid);
|
}
|
|
public BaseResult releasedFile(Collection<VciFileObjectDTO> vciFileObjectDTOS) throws VciBaseException {
|
if (vciFileObjectDTOS != null && vciFileObjectDTOS.size() > 0) {
|
List<String> fileOidList = new ArrayList();
|
Iterator var3 = vciFileObjectDTOS.iterator();
|
|
while(var3.hasNext()) {
|
VciFileObjectDTO fileObjectDTO = (VciFileObjectDTO)var3.next();
|
fileOidList.add(fileObjectDTO.getOid());
|
}
|
|
String fileOids = VciBaseUtil.list2String(fileOidList);
|
return this.vciFileQueryProvider.releasedFile(fileOids);
|
} else {
|
throw new VciBaseException("文件对象列表为空，不能生效文件！");
|
}
|
}
|
|
public BaseResult releasedFile(VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileObjectDTO, "文件传输对象"});
|
return this.vciFileQueryProvider.releasedFile(fileObjectDTO.getOid());
|
}
|
|
public BaseResult uploadFile(InputStream inputStream, VciFileObjectDTO fileObjectDTO) throws VciBaseException {
|
if (inputStream == null) {
|
throw new VciBaseException("uploadFail", new String[]{"文件流"});
|
} else {
|
List<VciFileObjectDTO> vciFileObjectDTOS = new ArrayList();
|
vciFileObjectDTOS.add(fileObjectDTO);
|
VciFileObjectDTO parameterObject = new VciFileObjectDTO();
|
parameterObject.setVciFileObjectDTOList(vciFileObjectDTOS);
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileUploadProvider.initUploadFileInfo(parameterObject);
|
if (baseResult.getData() != null && baseResult.getData().size() != 0) {
|
VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getData().iterator().next();
|
String tempFolder = LocalFileUtil.getProjectFolder() + File.separator + VciBaseUtil.getPk();
|
File tempFolderFile = new File(tempFolder);
|
if (!tempFolderFile.exists()) {
|
tempFolderFile.mkdirs();
|
}
|
|
BaseResult tempBaseResult;
|
try {
|
int fileSize = inputStream.available();
|
fileObjectDTO.setFileSize((long)fileSize);
|
byte[] buffer = new byte[1048576];
|
|
long temp;
|
for(temp = 0L; temp < (long)fileSize; temp += 1048576L) {
|
inputStream.read(buffer, 0, 1048576);
|
MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
|
tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, temp, vciFileObjectVO.getOid());
|
if (!tempBaseResult.isSuccess()) {
|
throw new VciBaseException(tempBaseResult.getMsg());
|
}
|
}
|
|
int remainSize = (int)((long)fileSize - temp);
|
buffer = new byte[remainSize];
|
inputStream.read(buffer, 0, remainSize);
|
MultipartFile multipartFile = this.getMultipartFile(buffer, tempFolderFile);
|
tempBaseResult = this.vciFileUploadProvider.uploadFileForOtherService(multipartFile, temp, vciFileObjectVO.getOid());
|
if (!tempBaseResult.isSuccess()) {
|
throw new VciBaseException(tempBaseResult.getMsg());
|
}
|
} catch (Exception var23) {
|
throw new VciBaseException("uploadFail", new String[]{var23.getMessage()});
|
} finally {
|
if (inputStream != null) {
|
try {
|
inputStream.close();
|
} catch (IOException var22) {
|
var22.printStackTrace();
|
}
|
}
|
|
LocalFileUtil.deleteFile(tempFolderFile);
|
}
|
|
return tempBaseResult;
|
} else {
|
throw new VciBaseException("fileInfoInitFail");
|
}
|
}
|
}
|
|
public void downloadFileObject(String tempFilePath, VciFileObjectVO vciFileObjectVO) throws VciBaseException {
|
FileOutputStream out = null;
|
File tempFile = new File(tempFilePath);
|
|
try {
|
File dirFile = tempFile.getParentFile();
|
if (!dirFile.exists()) {
|
dirFile.mkdirs();
|
}
|
|
if (!tempFile.exists()) {
|
tempFile.createNewFile();
|
}
|
|
long fileSize = vciFileObjectVO.getFileSize();
|
int temp = 0;
|
|
byte[] buffer;
|
for(out = new FileOutputStream(tempFile); (long)temp < fileSize; temp += buffer.length) {
|
BaseResult<byte[]> baseResult = this.vciFileDownloadProvider.sectionDownloadByFileOid(vciFileObjectVO.getOid(), (long)temp);
|
buffer = (byte[])baseResult.getObj();
|
out.write(buffer, 0, buffer.length);
|
}
|
} catch (Exception var18) {
|
if (tempFile.exists()) {
|
tempFile.delete();
|
}
|
|
File tempFolderFile = tempFile.getParentFile();
|
File[] files = tempFolderFile.listFiles();
|
if (tempFolderFile.exists() && (files == null || files.length == 0)) {
|
tempFolderFile.delete();
|
}
|
|
throw new VciBaseException("downloadFail", new String[]{var18.getMessage()});
|
} finally {
|
try {
|
if (out != null) {
|
out.close();
|
}
|
} catch (Exception var17) {
|
var17.printStackTrace();
|
}
|
|
}
|
|
}
|
|
public String downloadByFileOid(String fileOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件主键"});
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
return this.downloadByFileOid(tempFolder, fileOid);
|
}
|
|
public String downloadByFileOid(String tempFolder, String fileOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件主键", tempFolder, "下载的目录"});
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
|
VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getObj();
|
if (vciFileObjectVO == null) {
|
throw new VciBaseException("这个文件不存在");
|
} else {
|
String tempFilePath = tempFolder + File.separator + vciFileObjectVO.getOid() + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
|
this.downloadFileObject(tempFilePath, vciFileObjectVO);
|
return tempFilePath;
|
}
|
}
|
|
public Map<String, String> downloadByFileOids(Collection<String> fileOidCollection) throws VciBaseException {
|
return this.downloadByFileOids(LocalFileUtil.getDefaultTempFolder(), fileOidCollection);
|
}
|
|
public Map<String, String> downloadByFileOids(String tempFolder, Collection<String> fileOidCollection) throws VciBaseException {
|
VciBaseUtil.alertCollectionNotNull("文件的主键集合", fileOidCollection);
|
Map<String, String> fileOidPathMap = new HashMap();
|
Iterator var4 = fileOidCollection.iterator();
|
|
while(var4.hasNext()) {
|
String fileOid = (String)var4.next();
|
fileOidPathMap.put(fileOid, this.downloadByFileOid(tempFolder, fileOid));
|
}
|
|
return fileOidPathMap;
|
}
|
|
public String downloadToZipByFileOid(String fileOid) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileOid, "文件的主键"});
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
|
VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)baseResult.getObj();
|
String zipFile = tempFolder + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
|
this.downloadToZipByFileOid(zipFile, fileOid);
|
return zipFile;
|
}
|
|
public void downloadToZipByFileOid(String zipFile, String fileOid) throws VciBaseException {
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
String filePath = this.downloadByFileOid(tempFolder, fileOid);
|
File file = new File(filePath);
|
this.zipUtil.addFileToZip(file, zipFile);
|
if (file.exists()) {
|
file.delete();
|
}
|
|
File dirFile = file.getParentFile();
|
if (dirFile.exists()) {
|
dirFile.delete();
|
}
|
|
}
|
|
public String downloadToZipByFileOids(Collection<String> fileOidCollection) throws VciBaseException {
|
String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
|
this.downloadToZipByFileOids(zipFile, fileOidCollection);
|
return zipFile;
|
}
|
|
public void downloadToZipByFileOids(String zipFile, Collection<String> fileOidCollection) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{zipFile, "压缩包的路径"});
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
this.downloadByFileOids(tempFolder, fileOidCollection);
|
this.zipUtil.folderToZipFile(tempFolder, zipFile);
|
File folderFile = new File(tempFolder);
|
LocalFileUtil.deleteFile(folderFile);
|
}
|
|
public void downloadToIOByFileOid(OutputStream ops, String fileOid) throws VciBaseException {
|
this.downloadToIOByFileOid(ops, fileOid, true);
|
}
|
|
public void downloadToIOByFileOid(OutputStream ops, String fileOid, boolean closeOutSteam) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ops, "输出流", fileOid, "文件主键"});
|
BaseResult<VciFileObjectVO> returnBaseResult = this.vciFileQueryProvider.getFileObjectByOid(fileOid);
|
VciFileObjectVO vciFileObjectVO = (VciFileObjectVO)returnBaseResult.getObj();
|
|
try {
|
long fileSize = vciFileObjectVO.getFileSize();
|
|
byte[] buffer;
|
for(int temp = 0; (long)temp <= fileSize; temp += buffer.length) {
|
BaseResult<byte[]> baseResult = this.vciFileDownloadProvider.sectionDownloadByFileOid(vciFileObjectVO.getOid(), (long)temp);
|
buffer = (byte[])baseResult.getObj();
|
ops.write(buffer, temp, buffer.length);
|
}
|
} catch (Throwable var14) {
|
throw new VciBaseException("downloadFail", new String[]{LangBaseUtil.getErrorMsg(var14)}, var14);
|
} finally {
|
if (closeOutSteam) {
|
IOUtils.closeQuietly(ops);
|
}
|
|
}
|
|
}
|
|
public Map<String, String> downloadByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
return this.downloadByOwnbiz(tempFolder, ownBizOid, ownBtmName);
|
}
|
|
public Map<String, String> downloadByOwnbiz(String tempFolder, String ownBizOid, String ownBtmName) throws VciBaseException {
|
return this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, "");
|
}
|
|
public Map<String, String> downloadByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
return this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, docClassifyId);
|
}
|
|
public Map<String, String> downloadByOwnbizAndClassify(String tempFolder, String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
|
if (StringUtils.isBlank(docClassifyId)) {
|
docClassifyId = "";
|
}
|
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbizAndClassify(ownBizOid, ownBtmName, docClassifyId);
|
if (CollectionUtils.isEmpty(baseResult.getData())) {
|
throw new VciBaseException("fileInfoNotExist", new String[]{""});
|
} else {
|
Map<String, String> fileOidPathMap = new HashMap();
|
baseResult.getData().stream().forEach((vciFileObjectVO) -> {
|
String thisFilePath = tempFolder + File.separator + vciFileObjectVO.getName() + "." + vciFileObjectVO.getFileExtension();
|
this.downloadFileObject(thisFilePath, vciFileObjectVO);
|
fileOidPathMap.put(vciFileObjectVO.getOid(), thisFilePath);
|
});
|
return fileOidPathMap;
|
}
|
}
|
|
public String downloadToZipByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
|
String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
|
this.downloadToZipByOwnbiz(zipFile, ownBizOid, ownBtmName);
|
return zipFile;
|
}
|
|
public void downloadToZipByOwnbiz(String zipFile, String ownBizOid, String ownBtmName) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
this.downloadByOwnbiz(tempFolder, ownBizOid, ownBtmName);
|
this.zipUtil.folderToZipFile(tempFolder, zipFile);
|
File file = new File(tempFolder);
|
LocalFileUtil.deleteFile(file);
|
}
|
|
public String downloadToZipByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
|
String zipFile = LocalFileUtil.getDefaultTempFolder() + File.separator + VciBaseUtil.getPk() + ".zip";
|
this.downloadToZipByOwnbizAndClassify(zipFile, ownBizOid, ownBtmName, docClassifyId);
|
return zipFile;
|
}
|
|
public void downloadToZipByOwnbizAndClassify(String zipFile, String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
|
String tempFolder = LocalFileUtil.getDefaultTempFolder();
|
this.downloadByOwnbizAndClassify(tempFolder, ownBizOid, ownBtmName, docClassifyId);
|
this.zipUtil.folderToZipFile(tempFolder, zipFile);
|
File file = new File(tempFolder);
|
LocalFileUtil.deleteFile(file);
|
}
|
|
public BaseResult deleteFileByOid(String fileOids) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{fileOids, "文件主键"});
|
return this.vciFileDownloadProvider.deleteFile(fileOids);
|
}
|
|
public BaseResult deleteFileByOwnbiz(String ownBizOid, String ownBtmName) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbiz(ownBizOid, ownBtmName);
|
List<VciFileObjectVO> fileObjectVOList = (List)baseResult.getData();
|
if (fileObjectVOList != null && fileObjectVOList.size() > 0) {
|
List<String> fileOidList = new ArrayList();
|
Iterator var6 = fileObjectVOList.iterator();
|
|
while(var6.hasNext()) {
|
VciFileObjectVO fileObjectVO = (VciFileObjectVO)var6.next();
|
fileOidList.add(fileObjectVO.getOid());
|
}
|
|
String fileOids = VciBaseUtil.list2String(fileOidList);
|
return this.deleteFileByOid(fileOids);
|
} else {
|
return BaseResult.successMsg("deleteSuccess");
|
}
|
}
|
|
public BaseResult deleteFileByOwnbizAndClassify(String ownBizOid, String ownBtmName, String docClassifyId) throws VciBaseException {
|
VciBaseUtil.alertNotNull(new Object[]{ownBizOid, "业务主键", ownBtmName, "业务类型"});
|
BaseResult<VciFileObjectVO> baseResult = this.vciFileQueryProvider.listFilesByOwnbizAndClassify(ownBizOid, ownBtmName, docClassifyId);
|
List<VciFileObjectVO> fileObjectVOList = (List)baseResult.getData();
|
if (fileObjectVOList != null && fileObjectVOList.size() > 0) {
|
List<String> fileOidList = new ArrayList();
|
Iterator var7 = fileObjectVOList.iterator();
|
|
while(var7.hasNext()) {
|
VciFileObjectVO fileObjectVO = (VciFileObjectVO)var7.next();
|
fileOidList.add(fileObjectVO.getOid());
|
}
|
|
String fileOids = VciBaseUtil.list2String(fileOidList);
|
return this.deleteFileByOid(fileOids);
|
} else {
|
return BaseResult.successMsg("deleteSuccess");
|
}
|
}
|
|
public void batchDeleteFiles(Collection<VciFileObjectVO> fileObjectVOS) throws VciBaseException {
|
if (!CollectionUtils.isEmpty(fileObjectVOS)) {
|
this.batchDeleteFilesByOids((Collection)fileObjectVOS.stream().map(BaseModelVO::getOid).collect(Collectors.toList()));
|
}
|
|
}
|
|
public void batchDeleteFilesByOids(Collection<String> fileOidCollection) throws VciBaseException {
|
if (!CollectionUtils.isEmpty(fileOidCollection)) {
|
VciBaseUtil.switchCollectionForOracleIn(fileOidCollection).forEach((fileOids) -> {
|
BaseResult result = this.vciFileDownloadProvider.deleteFile((String)fileOids.stream().collect(Collectors.joining(",")));
|
if (!result.isSuccess()) {
|
throw new VciBaseException(result.getMsg(), result.getMsgObjs());
|
}
|
});
|
}
|
|
}
|
|
public VciFileObjectDTO fileObjectVO2DTO(VciFileObjectVO fileObjectVO) {
|
VciFileObjectDTO fileObjectDTO = new VciFileObjectDTO();
|
BeanUtilForVCI.convert(fileObjectVO, fileObjectDTO);
|
return fileObjectDTO;
|
}
|
|
public VciFileObjectDTO fileObjectVO2DTOForUpdate(VciFileObjectVO fileObjectVO) {
|
VciFileObjectDTO fileObjectDTO = new VciFileObjectDTO();
|
BeanUtilForVCI.convert(fileObjectVO, fileObjectDTO);
|
fileObjectDTO.setFileOid(fileObjectVO.getOid());
|
fileObjectDTO.setUpdateFileFlag(true);
|
return fileObjectDTO;
|
}
|
|
public void updateFileInfos(Collection<VciFileObjectDTO> fileObjectDTOS) {
|
if (!CollectionUtils.isEmpty(fileObjectDTOS)) {
|
VciBaseUtil.switchCollectionForOracleIn(fileObjectDTOS).stream().forEach((fileDTOs) -> {
|
BaseResult result = this.vciFileUploadProvider.updateFileInfos(fileDTOs);
|
if (!result.isSuccess()) {
|
throw new VciBaseException(result.getMsg(), result.getMsgObjs());
|
}
|
});
|
}
|
|
}
|
|
public List<VciFileShareResultVO> batchShareFile(Collection<VciFileShareDTO> shareDTOList, String fileDocClassifyId) {
|
if (!CollectionUtils.isEmpty(shareDTOList)) {
|
List<VciFileShareResultVO> resultVOList = new ArrayList();
|
VciBaseUtil.switchCollectionForOracleIn(shareDTOList).stream().forEach((dtos) -> {
|
VciFileShareHasClassifyDTO shareHasClassifyDTO = new VciFileShareHasClassifyDTO();
|
shareHasClassifyDTO.setDocClassifyId(fileDocClassifyId);
|
shareHasClassifyDTO.setShareDTOList((List)dtos.stream().collect(Collectors.toList()));
|
BaseResult<VciFileShareResultVO> result = this.vciFileUploadProvider.batchShareFile(shareHasClassifyDTO);
|
if (!result.isSuccess()) {
|
throw new VciBaseException(result.getMsg(), result.getMsgObjs());
|
} else {
|
resultVOList.addAll(result.getData());
|
}
|
});
|
return resultVOList;
|
} else {
|
return null;
|
}
|
}
|
}
|
