package foundation.version;
|
|
import java.util.Date;
|
|
import foundation.action.ActionProvider;
|
import foundation.action.WorkflowDispatcher;
|
import foundation.dao.Filter;
|
import foundation.dao.OrderBy;
|
import foundation.data.entity.Entity;
|
import foundation.data.entity.EntitySet;
|
import foundation.data.meta.field.FieldsRuntime;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.EntitySaver;
|
import foundation.persist.NamedSQL;
|
import foundation.persist.SQLRunner;
|
import foundation.util.DateTimeUtil;
|
import foundation.util.ID;
|
import foundation.util.MapList;
|
import foundation.util.Util;
|
|
|
public class VersionCenter extends ActionProvider{
|
|
private VersionBucket versionBucket;
|
|
public VersionCenter() {
|
versionBucket = VersionBucket.getInstance();
|
}
|
|
@Override
|
protected void publishMethod() {
|
//1. 激活版本
|
addMethod("activateVersion");
|
|
//2. 封版
|
addMethod("lockedVersion");
|
|
//3. 历史转暂存
|
addMethod("historyToPreparatory");
|
|
}
|
|
public void exec() throws Exception {
|
String methodName = step.getActionName();
|
if("toActive".equalsIgnoreCase(methodName)) {
|
toActive();
|
}
|
else if("toHistory".equalsIgnoreCase(methodName)) {
|
toHistory();
|
}
|
else if("toPreparatory".equalsIgnoreCase(methodName)) {
|
toPreparatory();
|
}
|
}
|
|
public boolean isVersionActive(String key) {
|
int pos = key.indexOf(".");
|
|
if (pos < 0 ) {
|
return false;
|
}
|
|
String code = key.substring(0, pos);
|
String dataName = key.substring(pos + 1);
|
MapList<String, VersionMeta> metaList = versionBucket.get(code);
|
VersionMeta meta = metaList.get(dataName);
|
|
if (meta == null) {
|
return false;
|
}
|
|
return meta.isVersionActive();
|
}
|
|
public VersionIndex getIndex(String groupCode, String versionCode, String stateCode, boolean fromRequest) throws Exception {
|
VersionState versionState = VersionState.parse(stateCode);
|
VersionState nextVersion = versionState.getNextState();
|
|
MapList<String, VersionMeta> metas = versionBucket.get(groupCode);
|
VersionMeta masterMeta = versionBucket.getMasterMeta(groupCode);
|
int currntNo = masterMeta.getVersionSequence();
|
|
if (metas == null || metas.size() == 0 ) {
|
return null;
|
}
|
|
DataObject dataObject = DataObject.getInstance("sys_version_log");
|
Filter filter = new Filter("group_code", groupCode);
|
if (!Util.isEmpty(versionCode)) {
|
filter.add("version_code", versionCode);
|
}
|
if (!Util.isEmpty(stateCode)) {
|
filter.add("state_code", stateCode);
|
}
|
Entity entity = dataObject.getTableEntity(filter);
|
String logId = ID.newValue();
|
if (entity == null) {
|
//1. 获取临时版本号
|
VersionCode version = new VersionCode(masterMeta.getName(), currntNo);
|
int versionNo = version.nextStandardValue();
|
versionCode = version.getCode();
|
//2. 保存版本日志到数据库
|
entity = dataObject.createTableEntity(false);
|
entity.setId(logId);
|
entity.set("version_no", versionNo);
|
entity.set("version_code", versionCode);
|
entity.set("group_code", groupCode);
|
|
entity.set("state_code", versionState.name());
|
entity.set("state_name", versionState.getName());
|
entity.set("last_update_time", new Date());
|
|
if (nextVersion == VersionState.History) {
|
entity.set("month_valid_to", new Date());
|
entity.set("valid_to", new Date());
|
}
|
|
dataObject.insertEntity(entity);
|
}else {
|
logId = entity.getId();
|
if (VersionState.Active == versionState){
|
// 3.1 封版
|
if(fromRequest) {
|
entity.set("month_valid_to", new Date());
|
entity.set("valid_to", new Date());
|
}
|
else {
|
String monthValidTo = DateTimeUtil.addDays(Util.newDateStr(), -1);
|
entity.set("month_valid_to", monthValidTo);
|
entity.set("valid_to", monthValidTo);
|
}
|
|
entity.set("is_using", "F");
|
entity.set("state_code", nextVersion.name());
|
entity.set("state_name", nextVersion.getName());
|
dataObject.updateEntity(entity);
|
|
VersionIndex result = getIndex(groupCode, versionCode, VersionState.Preparing.name(), fromRequest);
|
}else if (VersionState.Preparing == versionState){
|
// 3.2 生效
|
String nextVersionBegin = getNextVersionBegin(groupCode);
|
String year = DateTimeUtil.getYear(nextVersionBegin);
|
String month = DateTimeUtil.getMonth(nextVersionBegin, true);
|
entity.set("year", year);
|
entity.set("season", DateTimeUtil.getSeason(nextVersionBegin));
|
entity.set("month", month);
|
entity.set("monthly", year + month);
|
|
entity.set("month_valid_from", nextVersionBegin);
|
entity.set("valid_from", nextVersionBegin);
|
entity.set("is_using", "T");
|
entity.set("state_code", nextVersion.name());
|
entity.set("state_name", nextVersion.getName());
|
dataObject.updateEntity(entity);
|
|
//4.更新版本序列号
|
int currentNo = entity.getInt("version_no");
|
masterMeta.setVersionSequence(currentNo);
|
for(VersionMeta meta: metas) {
|
meta.setVersionSequence(currentNo);
|
}
|
updateVersionSequence(groupCode, currentNo);
|
|
VersionIndex result = getIndex(groupCode, versionCode, VersionState.Preparing.name(), fromRequest);
|
}
|
}
|
|
VersionIndex result = new VersionIndex(logId, versionCode, metas, masterMeta);
|
result.load(entity);
|
|
return result;
|
}
|
|
private void updateVersionSequence(String groupCode, int currentNo) throws Exception {
|
NamedSQL namedSQL = NamedSQL.getInstance("updateVersionSequence");
|
|
namedSQL.setParam("versionSequence", currentNo);
|
namedSQL.setParam("code", groupCode);
|
|
namedSQL.execute();
|
}
|
|
public void activateVersion() throws Exception {
|
String groupCode = null;
|
if (dataReader != null) {
|
groupCode = dataReader.getString("group_code");
|
}
|
else if(context != null) {
|
groupCode = context.getParam();
|
}
|
|
VersionStep workStep = new VersionStep(groupCode, "toActive", this);
|
|
WorkflowDispatcher dispatcher = WorkflowDispatcher.getInstance();
|
dispatcher.execWorkflow(dataReader, dataWriter, workStep, context);
|
}
|
|
public void toActive() throws Exception {
|
String groupCode = null;
|
if (dataReader != null) {
|
groupCode = dataReader.getString("group_code");
|
}
|
else if(context != null) {
|
groupCode = context.getParam();
|
}
|
|
DataObject logDataObject = DataObject.getInstance("sys_version_log");
|
Filter activeFilter = new Filter("state_code", VersionState.Active.name());
|
activeFilter = activeFilter.add("monthly", Util.DataTimeToString(new Date(), Util.MONTHLYFORMAT));
|
Entity entity = logDataObject.getTableEntity(activeFilter);
|
String logId = entity.getId();
|
String versionCode = entity.getString("version_code");
|
|
logDataObject = DataObject.getInstance("sys_version_log_detail");
|
EntitySaver saver;
|
//2. 得到 code 的 next value
|
|
MapList<String, VersionMeta> metas = versionBucket.get(groupCode);
|
|
NamedSQL namedSQL = NamedSQL.getInstance("versionDataCopy");
|
|
SQLRunner.beginTrans();
|
try {
|
//3. 《预备表》搬运数据至《生效表》
|
for (VersionMeta meta : metas) {
|
//3.1 清空生效表
|
String activeTable = meta.getDataName();
|
String preparatoryTable = meta.getPreparatoryDataName();
|
Filter filter = new Filter();
|
filter.add(meta.getFilter());
|
|
DataObject dataObject = DataObject.getInstance(activeTable);
|
int operatorCount = dataObject.deleteEntity(filter);
|
logger.info("1.清空 [{}]表暂存总计 {} 条", preparatoryTable, operatorCount);
|
|
//3.1 获取表执行字段
|
DataObject preparatoryDataObject = DataObject.getInstance(preparatoryTable);
|
FieldsRuntime fromFields = preparatoryDataObject.getTableFieldMetas();
|
FieldMappingCreator mappingCreator = FieldMappingCreator.createMapping(fromFields, "PreparatoryToActive", null);
|
|
namedSQL.setTableName(activeTable);
|
namedSQL.setParam("toFieldNames", mappingCreator.getToFields());
|
namedSQL.setParam("fromFieldNames", mappingCreator.getFromFields());
|
namedSQL.setParam("fromTableName", preparatoryTable);
|
namedSQL.setFilter(meta.getFilter());
|
|
int recordCount = namedSQL.execute();
|
|
//3.2 保存生效明细日志
|
saver = logDataObject.createEntitySaver();
|
saver.set("id", ID.newValue());
|
saver.set("parent_id", logId);
|
saver.set("dataName", activeTable);
|
saver.set("dataName", meta.getDataNameType());
|
saver.set("record_count", recordCount);
|
saver.insert();
|
}
|
}catch (Exception e) {
|
logger.info("{}：《预备表》搬运数据至《生效表》失败", groupCode);
|
SQLRunner.rollback();
|
e.printStackTrace();
|
}
|
|
SQLRunner.commit();
|
|
if (dataWriter != null) {
|
dataWriter.reportOneMessage("activateVersion", "新版本" + versionCode + "已生效");
|
}
|
}
|
|
public void lockedVersion() throws Exception {
|
String groupCode = null;
|
if (dataReader != null) {
|
groupCode = dataReader.getString("group_code");
|
}
|
else if(context != null) {
|
groupCode = context.getParam();
|
}
|
|
VersionStep workStep = new VersionStep(groupCode, "toHistory", this);
|
|
WorkflowDispatcher dispatcher = WorkflowDispatcher.getInstance();
|
dispatcher.execWorkflow(dataReader, dataWriter, workStep, context);
|
}
|
|
public void toHistory() throws Exception {
|
boolean fromRequest = true;
|
String groupCode= null;
|
if (dataReader != null) {
|
groupCode = dataReader.getString("group_code");
|
fromRequest = true;
|
}
|
else if(context != null) {
|
groupCode = context.getParam();
|
fromRequest = false;
|
}
|
|
//1. 获取当前版本
|
Entity currentVersion = getCurrentVersion(groupCode);
|
String logId = currentVersion.getId();
|
String versionCode = currentVersion.getString("version_code");
|
|
//2. 《正式表》搬运数据至《历史表》
|
MapList<String, VersionMeta> metas = versionBucket.get(groupCode);
|
|
NamedSQL namedSQL = NamedSQL.getInstance("versionDataCopy");
|
DataObject logDataObject = DataObject.getInstance("sys_version_log_detail");
|
|
for (VersionMeta meta : metas) {
|
String historyTable = meta.getHistoryDataName();
|
String activeTable = meta.getDataName();
|
|
//3.1 获取表执行字段
|
DataObject activeDataObject = DataObject.getInstance(activeTable);
|
FieldsRuntime fromFields = activeDataObject.getTableFieldMetas();
|
|
FieldMappingCreator mappingCreator = FieldMappingCreator.createMapping(fromFields, "ActiveToHistory", versionCode);
|
namedSQL.setTableName(historyTable);
|
namedSQL.setParam("toFieldNames", mappingCreator.getToFields());
|
namedSQL.setParam("fromFieldNames", mappingCreator.getFromFields());
|
namedSQL.setParam("fromTableName", activeTable);
|
namedSQL.setFilter(meta.getFilter());
|
int operatorCount = namedSQL.execute();
|
logger.info("[{}]--->[{}] {} 条", activeTable, historyTable, operatorCount);
|
|
//3.2 保存历史版本明细日志
|
Filter filter = new Filter("parent_id", logId).add("dataname", activeTable);
|
Entity entity = logDataObject.getTableEntity(filter);
|
|
if (entity == null) {
|
entity = logDataObject.createTableEmptyEntity();
|
entity.setId(ID.newValue());
|
entity.set("parent_id",logId);
|
entity.set("dataname",meta.getDataName());
|
entity.set("dataname_type",meta.getDataNameType());
|
entity.set("active_record_count",operatorCount);
|
entity.set("active_record_count",operatorCount);
|
entity.set("history_record_count", operatorCount);
|
logDataObject.insertEntity(entity);
|
}
|
else {
|
entity.set("history_record_count", operatorCount);
|
logDataObject.updateEntity(entity);
|
}
|
|
}
|
|
//3. 更新版本，记录日志
|
VersionIndex index = getIndex(groupCode, null, VersionState.Active.name(), fromRequest);
|
|
if(dataWriter != null) {
|
dataWriter.reportOneMessage("lockedVersion", index.getGroupName() + "已生成版本" + versionCode);
|
}
|
else {
|
logger.info(index.getGroupName() + "已生成版本" + versionCode);
|
}
|
}
|
|
private Entity getCurrentVersion(String groupCode) throws Exception {
|
DataObject dataObject = DataObject.getInstance("sys_version_log");
|
|
Filter filter = new Filter("group_code", groupCode);
|
filter.add("state_code", VersionState.Active.name());
|
filter.add("is_using", "T");
|
|
return dataObject.getTableEntity(filter);
|
}
|
|
public void historyToPreparatory() throws Exception {
|
String groupCode = null;
|
if (dataReader != null) {
|
groupCode = dataReader.getString("group_code");
|
}
|
else if(context != null) {
|
groupCode = context.getParam();
|
}
|
|
VersionStep workStep = new VersionStep(groupCode, "toPreparatory", this);
|
|
WorkflowDispatcher dispatcher = WorkflowDispatcher.getInstance();
|
dispatcher.execWorkflow(dataReader, dataWriter, workStep, context);
|
}
|
|
public void toPreparatory() throws Exception {
|
String groupCode = dataReader.getString("group_code");
|
String version = dataReader.getString("version_code");
|
NamedSQL namedSQL = NamedSQL.getInstance("versionDataCopy");
|
DataObject dataObject;
|
|
logger.info("{}, 《版本{}》搬运至《预设表》 开始......", groupCode, version);
|
|
SQLRunner.beginTrans();
|
try {
|
MapList<String, VersionMeta> metas = versionBucket.get(groupCode);
|
for (VersionMeta meta : metas) {
|
String historyTable = meta.getHistoryDataName();
|
String preparatoryTable = meta.getPreparatoryDataName();
|
Filter filter = new Filter();
|
filter.add(meta.getFilter());
|
|
dataObject = DataObject.getInstance(preparatoryTable);
|
int operatorCount = dataObject.deleteEntity(filter);
|
logger.info("1.清空 [{}]表暂存总计 {} 条", preparatoryTable, operatorCount);
|
|
dataObject = DataObject.getInstance(historyTable);
|
FieldsRuntime fromFields = dataObject.getTableFieldMetas();
|
FieldMappingCreator mappingCreator = FieldMappingCreator.createMapping(fromFields, "HistoryToPreparatory", null);
|
|
namedSQL.setTableName(preparatoryTable);
|
namedSQL.setParam("toFieldNames", mappingCreator.getToFields());
|
namedSQL.setParam("fromFieldNames", mappingCreator.getFromFields());
|
namedSQL.setParam("fromTableName", historyTable);
|
|
filter.add("version_code", version);
|
namedSQL.setFilter(filter);
|
operatorCount = namedSQL.execute();
|
logger.info("2.[{}]--->[{}] {} 条", historyTable, preparatoryTable, operatorCount);
|
}
|
}catch (Exception e) {
|
logger.info("{}, 《版本{}》搬运至《预设表》 失败", groupCode, version);
|
SQLRunner.rollback();
|
e.printStackTrace();
|
}
|
|
SQLRunner.commit();
|
logger.info("{}搬运至《预设表》完成", groupCode);
|
}
|
|
private String getNextVersionBegin(String groupCode) throws Exception {
|
DataObject dataObject = DataObject.getInstance("sys_version_log");
|
Filter activeFilter = new Filter("group_code", groupCode).add("state_code", "!=", Util.quotedStr(VersionState.Preparing.name()));
|
EntitySet activeVersionSet = dataObject.getTableEntitySet(activeFilter, new OrderBy("valid_from desc, valid_to desc"));
|
if (activeVersionSet.size() == 0) {
|
return DateTimeUtil.addDays(Util.getDateTimeStr(new Date(), Util.NORMALFORMAT), 1);
|
}
|
|
Entity activeVersion = activeVersionSet.getEntity(0);
|
|
//1. 取当前生效版本的失效日期
|
Date date = activeVersion.getDate("valid_to");
|
if (date != null) {
|
return DateTimeUtil.addDays(Util.getDateTimeStr(date, Util.NORMALFORMAT), 1);
|
}
|
|
//2. 取当前生效版本的本月失效时间（失效大于月底）
|
date = activeVersion.getDate("month_valid_to");
|
if (date != null) {
|
return DateTimeUtil.addDays(Util.getDateTimeStr(date, Util.NORMALFORMAT), 1);
|
}
|
|
//2. 取当前生效版本的本月失生效效时间（失效大于月底）
|
date = activeVersion.getDate("month_valid_from");
|
return DateTimeUtil.addDays(Util.getDateTimeStr(date, Util.NORMALFORMAT), 1);
|
}
|
|
}
|
