weaver-demo/esign_weaver_java.git

package foundation.io;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
 
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.object.DataObject;
import foundation.data.object.EntitySaver;
import foundation.io.define.RecordType;
import foundation.io.object.FileItemAgent;
import foundation.io.object.FileRecord;
import foundation.io.object.IFileLetter;
import foundation.io.object.UploadReader;
import foundation.persist.NamedSQL;
import foundation.persist.SQLRunner;
import foundation.token.IOnlineUser;
import foundation.util.ID;
import foundation.util.Util;
 
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 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, 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);
        
        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, result);
                    
            //2.2 保存文件索引表
            saveFileIndex(dataReader, result, recordType);
 
            //2.3 更新触发上载文件的 data package
            updateSenderDataPackage(dataReader, result, recordType);
        }
 
        return results;
    }
    
    public static void saveFileToRepository(IOnlineUser user, FileMetaList fileMetas, DataPackage dataPackage, FileField field) 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);
                    
            //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) throws Exception {
        if (fileMeta == null) {
            return null;
        }
        
        FileRecord fileRecord = new FileRecord();
        fileRecord.setSenderName(dataPackage.getName());
        
        //2.1 保存到文件库
        saveFileToRepository(user, fileMeta, fileRecord);
                
        //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) throws Exception {
        if (fileMeta == null) {
            return null;
        }
        
        FileRecord fileRecord = new FileRecord();
        fileRecord.setSenderName(dataName);
        
        //2.1 保存到文件库
        saveFileToRepository(user, fileMeta, fileRecord);
                
        //2.2 保存文件索引表
        saveFileIndex(dataName, dataId, field, fileRecord);
        
        return fileRecord;
    }
    
    
    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, 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);
        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) 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);
        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);
        
        //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);
    }
    
    private 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);
        
        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);
        
        EntitySaver saver = dataObject.createEntitySaver(senderId);
        saver.set(field_fileId, fileRecord.getIndexId());
        saver.set(field_fileName, fileRecord.getFileName());
        saver.update();
    }
    
    private 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.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(File file) {
        FileRecord fileRecord = new FileRecord();
        fileRecord.setPath(file.getAbsolutePath());
        fileRecord.setFileName(file.getName());
        fileRecord.setFileSize(file.length());
        return fileRecord;
    }
}