package foundation.io;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.io.FileReader;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Objects;
|
|
import org.apache.commons.io.FileUtils;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.dao.DataPackage;
|
import foundation.dao.DataReader;
|
import foundation.dao.IDataLetter;
|
import foundation.dao.version.ApplyRelation;
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.data.entity.Filter;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.EntitySaver;
|
import foundation.io.define.DocAction;
|
import foundation.io.define.RecordType;
|
import foundation.io.file.BookStandardWriter;
|
import foundation.io.mapping.FieldMapping;
|
import foundation.io.object.FileItemAgent;
|
import foundation.io.object.FileRecord;
|
import foundation.io.object.IFileLetter;
|
import foundation.io.object.UploadReader;
|
import foundation.io.template.SendTemplate;
|
import foundation.persist.NamedSQL;
|
import foundation.persist.SQLRunner;
|
import foundation.server.config.Configer;
|
import foundation.token.IOnlineUser;
|
import foundation.util.ContentBuilder;
|
import foundation.util.ID;
|
import foundation.util.Util;
|
import sun.misc.BASE64Encoder;
|
|
public class FileCenter {
|
|
private static Logger logger;
|
|
static {
|
logger = LogManager.getLogger(FileCenter.class);
|
}
|
|
public static FileRecord uploadOneFile(DataReader dataReader) throws Exception {
|
return uploadOneFile(dataReader, true);
|
}
|
|
public static FileRecord uploadOneFile(DataReader dataReader, boolean saveIndex) throws Exception {
|
IOnlineUser user = dataReader.getUser();
|
FileRecord result = new FileRecord();
|
|
//1. 得到上载的文件
|
UploadReader uploadReader = new UploadReader(dataReader);
|
FileItemAgent fileItem = uploadReader.getFistFileItem();
|
RecordType recordType = RecordType.SaveToDB;
|
|
String filePath = dataReader.getString(IFileLetter.FilePath);
|
String applyName = dataReader.getString(IFileLetter.ApplyDataName);
|
String applyTypeCode = dataReader.getString(IFileLetter.ApplyTypeCode);
|
ApplyRelation relation = ApplyRelation.getInstance(applyName, applyTypeCode);
|
|
if (relation != null && relation.isVersionActive()) {
|
recordType = RecordType.ReturnNoSave;
|
}
|
|
//2. 保存到文件库
|
saveFileToRepository(user, fileItem, filePath, result);
|
|
if (fileItem == null || fileItem.isEmpty()) {
|
logger.error("can not get upload file, skip...");
|
return result;
|
}
|
|
//3. 如果不保存文件索引（到指定的DataName下面）
|
if (!saveIndex) {
|
return result;
|
}
|
|
//4. 保存文件索引表
|
saveFileIndex(dataReader, result, recordType);
|
|
//5. 更新触发上载文件的 data package
|
updateSenderDataPackage(dataReader, result, recordType);
|
|
//5. return
|
return result;
|
}
|
|
public static List<FileRecord> uploadFiles(DataReader dataReader) throws Exception {
|
String senderDataName = dataReader.getString(IDataLetter.DataName);
|
String filePath = dataReader.getString(IFileLetter.FilePath);
|
|
if (Util.isEmpty(senderDataName)) {
|
throw new Exception("can not upload file: data name is empty");
|
}
|
|
List<FileRecord> results = new ArrayList<FileRecord>();
|
|
//1. 得到上载的文件
|
UploadReader uploadReader = new UploadReader(dataReader);
|
List<FileItemAgent> fileFormList = uploadReader.getFileItemList();
|
|
String applyName = dataReader.getString(IFileLetter.ApplyDataName);
|
String applyTypeCode = dataReader.getString(IFileLetter.ApplyTypeCode);
|
ApplyRelation relation = ApplyRelation.getInstance(applyName, applyTypeCode);
|
|
RecordType recordType = RecordType.SaveToDB;
|
if (relation.isVersionActive()) {
|
recordType = RecordType.ReturnNoSave;
|
}
|
|
if (fileFormList.isEmpty()) {
|
logger.error("can not get upload file, skip...");
|
return results;
|
}
|
|
//2. 循环处理
|
IOnlineUser user = dataReader.getUser();
|
|
for (FileItemAgent fileForm: fileFormList) {
|
FileRecord result = new FileRecord();
|
result.setSenderName(senderDataName);
|
results.add(result);
|
|
//2.1 保存到文件库
|
saveFileToRepository(user, fileForm, filePath, result);
|
|
//2.2 保存文件索引表
|
saveFileIndex(dataReader, result, recordType);
|
|
//2.3 更新触发上载文件的 data package
|
updateSenderDataPackage(dataReader, result, recordType);
|
}
|
|
return results;
|
}
|
|
public static FileItemAgent getFileItem(DataReader dataReader) throws Exception {
|
UploadReader uploadReader = new UploadReader(dataReader);
|
FileItemAgent fileItem = uploadReader.getFistFileItem();
|
|
return fileItem;
|
}
|
|
public static void saveFileToRepository(IOnlineUser user, FileMetaList fileMetas, DataPackage dataPackage, FileField field, String filePath) throws Exception {
|
if (fileMetas == null) {
|
return;
|
}
|
|
boolean writeBack = false;
|
|
for (FileMeta fileMeta: fileMetas) {
|
FileRecord fileRecord = new FileRecord();
|
fileRecord.setSenderName(dataPackage.getName());
|
|
//2.1 保存到文件库
|
saveFileToRepository(user, fileMeta, fileRecord, filePath);
|
|
//2.2 保存文件索引表
|
saveFileIndex(dataPackage, fileRecord);
|
|
//2.3 更新触发上载文件的 data package(只有第一个文件会被写入)
|
if (!writeBack) {
|
updateSenderDataPackage(field, dataPackage, fileRecord);
|
writeBack = true;
|
}
|
}
|
}
|
|
public static FileRecord saveFileToRepository(IOnlineUser user, FileMeta fileMeta, DataPackage dataPackage, FileField field, String filePath) throws Exception {
|
if (fileMeta == null) {
|
return null;
|
}
|
|
FileRecord fileRecord = new FileRecord();
|
fileRecord.setSenderName(dataPackage.getName());
|
|
//2.1 保存到文件库
|
saveFileToRepository(user, fileMeta, fileRecord, filePath);
|
|
//2.2 保存文件索引表
|
saveFileIndex(dataPackage, fileRecord);
|
|
//2.3 更新触发上载文件的 data package(只有第一个文件会被写入)
|
updateSenderDataPackage(field, dataPackage, fileRecord);
|
|
return fileRecord;
|
}
|
|
public static FileRecord saveFileToRepository(IOnlineUser user, FileMeta fileMeta, String dataName, String dataId, FileField field, String filePath) throws Exception {
|
if (fileMeta == null) {
|
return null;
|
}
|
|
FileRecord fileRecord = new FileRecord();
|
fileRecord.setSenderName(dataName);
|
|
//2.1 保存到文件库
|
saveFileToRepository(user, fileMeta, fileRecord, filePath);
|
|
//2.2 保存文件索引表
|
saveFileIndex(dataName, dataId, field, fileRecord);
|
|
return fileRecord;
|
}
|
|
public static FileRecord getFile(String dataName, String senderField, String senderId) throws Exception {
|
FileRecord result = new FileRecord();
|
|
DataObject fileIndexObject = getFileIndexDataObject(dataName);
|
Filter filter = new Filter();
|
filter.add("sender_field_file_id", senderField);
|
filter.add("sender_id", senderId);
|
|
Entity entity = fileIndexObject.getTableEntity(filter);
|
|
if (entity == null) {
|
return result;
|
}
|
|
//2. write result
|
result.load(entity);
|
return result;
|
}
|
|
public static FileRecord getFile(String dataName, String fileId) throws Exception {
|
FileRecord result = new FileRecord();
|
|
DataObject fileIndexObject = getFileIndexDataObject(dataName);
|
Entity entity = fileIndexObject.getTableEntity(fileId);
|
|
if (entity == null) {
|
return result;
|
}
|
|
//2. write result
|
result.load(entity);
|
return result;
|
}
|
|
private static void saveFileToRepository(IOnlineUser user, FileItemAgent fileForm, String filePath, FileRecord fileRecord) throws Exception {
|
String fileName = fileForm.getName();
|
|
if (Util.isEmpty(fileName)) {
|
throw new Exception("can not create upload repository file: file name is empty");
|
}
|
|
File file = FileRepository.createUploadRepositoryFile(user, fileName, filePath);
|
fileForm.setPath(file.getParentFile());
|
fileForm.write(file);
|
|
//4. result
|
fileRecord.setPath(file.getAbsolutePath());
|
fileRecord.setFileName(fileName);
|
fileRecord.setFileSize(fileForm.getSize());
|
fileRecord.setContentType(fileForm.getContentType());
|
}
|
|
private static void saveFileToRepository(IOnlineUser user, FileMeta fileMeta, FileRecord fileRecord, String filePath) throws Exception {
|
String fileName = fileMeta.getName();
|
File file = fileMeta.getFile();
|
|
if (Util.isEmpty(fileName) || !file.exists()) {
|
throw new Exception("can not create upload repository file: file name is empty or file not exists");
|
}
|
|
File target = FileRepository.createUploadRepositoryFile(user, fileName, filePath);
|
FileUtils.copyFile(file, target);
|
|
//4. result
|
fileRecord.setPath(file.getAbsolutePath());
|
fileRecord.setFileName(fileName);
|
fileRecord.setFileSize(fileMeta.getSize());
|
fileRecord.setContentType(fileMeta.getContentType());
|
}
|
|
private static void saveFileIndex(DataReader dataReader, FileRecord fileRecord, RecordType recordType) throws Exception {
|
//1.
|
String senderId = dataReader.getString(IDataLetter.ID);
|
String senderDataName = dataReader.getString(IDataLetter.DataName);
|
String senderFieldFileName = dataReader.getString(IFileLetter.Field_FileName);
|
String senderFieldFileId = dataReader.getString(IFileLetter.Field_FileId);
|
|
if (Util.isEmpty(senderDataName)) {
|
logger.error("can not upload file: data name is empty");
|
return;
|
}
|
|
fileRecord.setIndexId(ID.newValue());
|
fileRecord.setSenderId(senderId);
|
fileRecord.setSenderName(senderDataName);
|
fileRecord.setSenderFieldFileName(senderFieldFileName);
|
fileRecord.setSenderFieldFileId(senderFieldFileId);
|
fileRecord.createFileUrl();
|
|
//1. 保存索引
|
DataObject fileIndexObject = getFileIndexDataObject(senderDataName);
|
|
Entity entity = fileIndexObject.createTableEntity(true);
|
|
entity.set("id", fileRecord.getIndexId());
|
entity.set("sender_id", fileRecord.getSenderId());
|
entity.set("sender_data_name", fileRecord.getSenderName());
|
entity.set("sender_field_file_name", fileRecord.getSenderFieldFileName());
|
entity.set("sender_field_file_id", fileRecord.getSenderFieldFileId());
|
entity.set("file_name", fileRecord.getFileName());
|
entity.set("file_path", fileRecord.getPath(true));
|
entity.set("file_size", fileRecord.getFileSize());
|
entity.set("file_content_type", fileRecord.getContentType());
|
|
if(!recordType.isSave()) {
|
fileRecord.setFileIndexName(fileIndexObject.getTableName());
|
fileRecord.addFileEntity(entity);
|
return ;
|
}
|
|
fileIndexObject.insertEntity(entity);
|
}
|
|
public static void saveFileIndex(String senderDataName, String senderId, FileField field, FileRecord fileRecord) throws Exception {
|
//1.
|
String senderFieldFileName = field.getFileName();
|
String senderFieldFileId = field.getFileId();
|
|
if (Util.isEmpty(senderDataName)) {
|
logger.error("can not upload file: data name is empty");
|
return;
|
}
|
|
fileRecord.setIndexId(ID.newValue());
|
fileRecord.setSenderId(senderId);
|
fileRecord.setSenderName(senderDataName);
|
fileRecord.setSenderFieldFileName(senderFieldFileName);
|
fileRecord.setSenderFieldFileId(senderFieldFileId);
|
|
//1. 保存索引
|
DataObject fileIndexObject = getFileIndexDataObject(senderDataName);
|
Entity entity = fileIndexObject.createTableEntity(true);
|
|
entity.set("id", fileRecord.getIndexId());
|
entity.set("sender_id", fileRecord.getSenderId());
|
entity.set("sender_data_name", fileRecord.getSenderName());
|
entity.set("sender_field_file_name", fileRecord.getSenderFieldFileName());
|
entity.set("sender_field_file_id", fileRecord.getSenderFieldFileId());
|
entity.set("file_name", fileRecord.getFileName());
|
entity.set("file_path", fileRecord.getPath(true));
|
entity.set("file_size", fileRecord.getFileSize());
|
entity.set("file_content_type", fileRecord.getContentType());
|
|
fileIndexObject.insertEntity(entity);
|
}
|
|
public static void saveFileIndex(DataPackage dataPackage, FileRecord fileRecord) throws Exception {
|
//1.
|
String senderId = dataPackage.getMasterId();
|
String senderDataName = dataPackage.getName();
|
|
if (Util.isEmpty(senderDataName)) {
|
logger.error("can not upload file: data name is empty");
|
return;
|
}
|
|
fileRecord.setIndexId(ID.newValue());
|
fileRecord.setSenderId(senderId);
|
fileRecord.setSenderName(senderDataName);
|
|
//1. 保存索引
|
DataObject fileIndexObject = getFileIndexDataObject(senderDataName);
|
Entity entity = fileIndexObject.createTableEntity(true);
|
|
entity.set("id", fileRecord.getIndexId());
|
entity.set("sender_id", fileRecord.getSenderId());
|
entity.set("sender_data_name", fileRecord.getSenderName());
|
entity.set("sender_field_file_name", fileRecord.getSenderFieldFileName());
|
entity.set("sender_field_file_id", fileRecord.getSenderFieldFileId());
|
entity.set("file_name", fileRecord.getFileName());
|
entity.set("file_path", fileRecord.getPath(true));
|
entity.set("file_size", fileRecord.getFileSize());
|
entity.set("file_content_type", fileRecord.getContentType());
|
|
fileIndexObject.insertEntity(entity);
|
}
|
|
private static void updateSenderDataPackage(DataReader dataReader, FileRecord fileRecord, RecordType recordType) throws Exception {
|
String senderId = dataReader.getString(IDataLetter.ID);
|
String senderDataName = dataReader.getString(IDataLetter.DataName);
|
String field_fileName = dataReader.getString(IFileLetter.Field_FileName);
|
String field_fileId = dataReader.getString(IFileLetter.Field_FileId);
|
String field_fileUrl = dataReader.getString(IFileLetter.Field_FileUrl);
|
DocAction docAtion = DocAction.getDocAction(dataReader.getString(IFileLetter.DocAction));
|
|
if (Util.isEmpty(senderDataName) || (!recordType.isSave())) {
|
return;
|
}
|
|
int pos = senderDataName.indexOf(".");
|
|
if (pos > 0) {
|
senderDataName = senderDataName.substring(pos + 1);
|
}
|
|
//1. update sender data object
|
DataObject dataObject = DataObject.getInstance(senderDataName);
|
|
if (dataObject == null) {
|
logger.error("can not find dataObject: {}", senderDataName);
|
return;
|
}
|
|
fileRecord.setSenderId(senderId);
|
|
if (docAtion == DocAction.NoAction) {
|
return;
|
}
|
else if(docAtion == DocAction.Append) {
|
EntitySaver saver = dataObject.createEntitySaver(senderId);
|
Entity entity = dataObject.getTableEntity(senderId);
|
|
ContentBuilder fileBuild = new ContentBuilder(";");
|
fileBuild.append(entity.getString(field_fileId));
|
fileBuild.append(fileRecord.getIndexId());
|
saver.set(field_fileId, fileBuild.toString());
|
|
fileBuild = new ContentBuilder(";");
|
fileBuild.append(entity.getString(field_fileName));
|
fileBuild.append(fileRecord.getFileName());
|
saver.set(field_fileName, fileBuild.toString());
|
|
fileBuild = new ContentBuilder(";");
|
fileBuild.append(entity.getString(field_fileUrl));
|
fileBuild.append(fileRecord.getFileUrl());
|
saver.set(field_fileUrl, fileBuild.toString());
|
|
saver.update();
|
}
|
else {
|
EntitySaver saver = dataObject.createEntitySaver(senderId);
|
saver.set(field_fileId, fileRecord.getIndexId());
|
saver.set(field_fileName, fileRecord.getFileName());
|
saver.set(field_fileUrl, fileRecord.getFileUrl());
|
saver.update();
|
}
|
}
|
|
public static void updateSenderDataPackage(FileField field, DataPackage dataPackage, FileRecord fileRecord) throws Exception {
|
DataObject dataObject = dataPackage.getMasterDataObject();
|
|
if (dataObject == null) {
|
logger.error("update file sender data package error, can not find dataObject");
|
return;
|
}
|
|
//1.
|
String masterId = dataPackage.getMasterId();
|
fileRecord.setSenderId(masterId);
|
|
//2.
|
EntitySaver saver = dataPackage.createMasterEntitySaver();
|
saver.set(field.getFileId(), fileRecord.getIndexId());
|
saver.set(field.getFileName(), fileRecord.getFileName());
|
saver.set(field.getFileUrl(), fileRecord.getFileUrl());
|
saver.update();
|
}
|
|
private static DataObject getFileIndexDataObject(String senderDataName) throws Exception {
|
String indexTableName = senderDataName + "_file";
|
DataObject dataObject = DataObject.getInstance(indexTableName, false);
|
|
if (dataObject == null) {
|
boolean tableExists = SQLRunner.isTableExists(indexTableName);
|
|
if (!tableExists) {
|
NamedSQL namedSQL = NamedSQL.getInstance("copyTableStructure");
|
namedSQL.setParam("newTable", indexTableName);
|
namedSQL.setParam("templateTable", "sys_temple_file");
|
|
namedSQL.execute();
|
}
|
}
|
|
dataObject = DataObject.getInstance(indexTableName);
|
return dataObject;
|
}
|
|
public static FileRecord getFileRecord(FileMeta meta) {
|
FileRecord fileRecord = new FileRecord();
|
fileRecord.setPath(meta.getFile().getAbsolutePath());
|
fileRecord.setFileName(meta.getName());
|
fileRecord.setFileSize(meta.getSize());
|
fileRecord.setContentType(meta.getContentType());
|
return fileRecord;
|
}
|
|
public static FileRecord getFileRecord(File file) {
|
FileRecord fileRecord = new FileRecord();
|
fileRecord.setPath(file.getAbsolutePath());
|
fileRecord.setFileName(file.getName());
|
fileRecord.setFileSize(file.length());
|
return fileRecord;
|
}
|
|
public static File createImportTemplate(String fileName, List<FieldMapping> mappings) throws Exception {
|
//获取模板的模板
|
String templatePath = Configer.getParam("importTemplateTemplate");
|
File templateFile = new File(templatePath);
|
|
//写入字段
|
BookStandardWriter writer = new BookStandardWriter(templateFile, 2);
|
return null;
|
}
|
|
public static File createExportTemplate(String fileName, EntitySet mappings) throws Exception {
|
//获取模板
|
String templatePath = Configer.getParam("importTemplateTemplate");
|
File templateFile = new File(templatePath);
|
|
//写入字段
|
BookStandardWriter writer = new BookStandardWriter(templateFile, 2);
|
return null;
|
}
|
|
public static File createWebTemplate(String templateId, DataPackage dataPackage) throws Exception {
|
//获取模板
|
SendTemplate template = new SendTemplate("met_template", templateId);
|
String templateName = template.getFileName();
|
|
//写入字段
|
String fileUrl = FileRepository.addTimeStamp(templateName);
|
String filePath = FileRepository.urlToWebPath("temp/" + fileUrl);
|
return template.generateFillFile(filePath, dataPackage);
|
}
|
|
public static String imageToBase64(File file) {
|
byte[] data = null;
|
|
InputStream in = null;
|
try {
|
// 1. bytes
|
in = new FileInputStream(file);
|
data = new byte[in.available()];
|
in.read(data);
|
in.close();
|
|
// 2. encode
|
BASE64Encoder encoder = new BASE64Encoder();
|
return encoder.encode(Objects.requireNonNull(data));
|
} catch (IOException e) {
|
e.printStackTrace();
|
} finally {
|
try {
|
in.close();
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
|
return null;
|
}
|
|
public static String readFile(File templateFile) {
|
StringBuffer buffer = new StringBuffer();
|
BufferedReader reader = null;
|
try {
|
reader = new BufferedReader(new FileReader(templateFile));
|
String line;
|
while ((line = reader.readLine()) != null) {
|
buffer.append(line);
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
} finally {
|
try {
|
if (reader != null) {
|
reader.close();
|
}
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
}
|
|
return buffer.toString();
|
}
|
|
public static void writeFile(String fileUrl, String invationBody) throws IOException {
|
String filePath = FileRepository.urlToPath(fileUrl);
|
|
FileWriter fileWriter = new FileWriter(filePath);
|
fileWriter.write(invationBody);
|
|
fileWriter.close();
|
}
|
|
|
public static FileMeta writeFile(File file, InputStream in) throws IOException {
|
FileOutputStream out = null;
|
try {
|
out = new FileOutputStream(file);
|
byte[] buffer = new byte[1024];
|
int length ;
|
while((length = in.read(buffer))!= -1) {
|
out.write(buffer, 0, length);
|
}
|
}
|
catch (Exception e) {
|
e.printStackTrace();
|
}
|
finally {
|
out.close();
|
}
|
|
FileMeta fileMeta = new FileMeta(file.getName(), file);
|
return fileMeta;
|
}
|
}
|
