package foundation.state;
|
|
import java.lang.reflect.InvocationTargetException;
|
import java.lang.reflect.Method;
|
import java.util.Set;
|
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
|
import foundation.action.ActionContext;
|
import foundation.action.SingletonActionProvider;
|
import foundation.action.StateContext;
|
import foundation.action.WorkFlowRuntime;
|
import foundation.action.WorkStepKey;
|
import foundation.dao.DataPackage;
|
import foundation.dao.DataReader;
|
import foundation.dao.DataSource;
|
import foundation.dao.DataWriter;
|
import foundation.dao.Domain;
|
import foundation.dao.PackageItem;
|
import foundation.dao.bizlogic.DataStates;
|
import foundation.dao.bizlogic.IStateProvider;
|
import foundation.data.entity.Entity;
|
import foundation.data.object.DataObject;
|
import foundation.data.object.EntitySaver;
|
import foundation.state.approve.ApprovalResult;
|
import foundation.state.approve.ApproveOperate;
|
import foundation.state.approve.ApproveRuntime;
|
import foundation.state.approve.StepLocation;
|
import foundation.state.approve.WorkingInstance;
|
import foundation.token.IOnlineUser;
|
import foundation.util.CaseInsensitiveSet;
|
import foundation.util.Util;
|
import foundation.variant.provider.DataEvent;
|
|
|
public class StateCenter extends SingletonActionProvider implements IStateProvider {
|
|
protected static Logger logger = LogManager.getLogger(StateCenter.class);
|
protected static String StateName_Back = "审批退回";
|
protected static String StateName_Cancel = "申请人撤回";
|
private static StateCenter instance;
|
private Set<String> targetOperators;
|
|
private StateCenter() {
|
targetOperators = new CaseInsensitiveSet();
|
}
|
|
public static synchronized StateCenter getInstance() {
|
if (instance == null) {
|
instance = new StateCenter();
|
}
|
|
return instance;
|
}
|
|
public void exec(ActionContext context, String methodName) throws Exception {
|
Method method = getMethod(methodName);
|
|
if (method == null) {
|
doExec(context, methodName);
|
return;
|
}
|
|
try {
|
method.invoke(this, context);
|
}
|
catch (InvocationTargetException e) {
|
e.printStackTrace();
|
Throwable throwable = e.getTargetException();
|
|
if (throwable == null) {
|
throw e;
|
}
|
else {
|
throw (Exception) throwable;
|
}
|
}
|
}
|
|
@Override
|
protected void publishMethod() {
|
//1.1 【状态】-- 提交 状态进入到 To 位置
|
addMethod("commit");
|
|
//1.2 【状态】-- 状态回退到 From 位置
|
addMethod("stateBack");
|
|
//1.3 【状态】-- 状态进入到End位置
|
addMethod("stateEnd");
|
|
//2.1 【审批】-- 审批同意（下一步）
|
addMethod("approve");
|
|
//2.2 【审批】-- 审批同意（跳过所有审批直接成功）
|
addMethod("goEnd");
|
|
//2.3 【审批】-- 审批不同意，回退上一步
|
addMethod("goBack");
|
|
//2.4 【审批】-- 审批不同意（一票否决）
|
addMethod("goHome");
|
|
//2.5 【审批】-- 申请人撤回
|
addMethod("pullBack");
|
|
//2.6 【审批】-- 变更 状态进入到 To 位置
|
addMethod("toChange");
|
|
//2.7 【审批】-- 关闭 状态进入到 To 位置
|
addMethod("toClose");
|
|
//3.1 获取状态机信息（页面审批-通过DataName）
|
addMethod("getMachine");
|
|
//3.2 获取状态机信息（状态机设计器-通过状态机ID）
|
addMethod("getOneMachine");
|
|
//3.3 保存状态机图数据
|
addMethod("saveOneMachine");
|
|
//3.4 获取审批步骤
|
addMethod("getApproveSteps");
|
|
//4. 获取状态机操作列表
|
addMethod("getPoints");
|
|
//5. 获取状态机操作列表(通过审批流ID)
|
addMethod("getPointsByApprove");
|
}
|
|
public void doExec(ActionContext context, String operator) throws Exception {
|
runState(context, operator, null, null, null);
|
}
|
|
public void commit(ActionContext context) throws Exception {
|
runState(context, "commit", null, DataEvent.Commit, null);
|
}
|
|
public void toChange(ActionContext context) throws Exception {
|
runState(context, "toChange", null, DataEvent.toChange, null);
|
}
|
|
public void toClose(ActionContext context) throws Exception {
|
runState(context, "toClose", null, DataEvent.toClose, null);
|
}
|
|
public void stateBack(ActionContext context) throws Exception {
|
runState(context, "stateBack", null, DataEvent.StateBack, StateName_Back);
|
}
|
|
public void stateEnd(ActionContext context) throws Exception {
|
runState(context, "stateEnd", null, DataEvent.StateEnd, StateName_Back);
|
}
|
public void approve(ActionContext context) throws Exception {
|
runApprove(context, ApproveOperate.Approve);
|
}
|
|
public void goEnd(ActionContext context) throws Exception {
|
runApprove(context, ApproveOperate.GoEnd);
|
}
|
|
public void goBack(ActionContext context) throws Exception {
|
runApprove(context, ApproveOperate.GoBack);
|
}
|
|
public void goHome(ActionContext context) throws Exception {
|
runApprove(context, ApproveOperate.GoHome);
|
}
|
|
public void pullBack(ActionContext context) throws Exception {
|
runApprove(context, ApproveOperate.PullBack);
|
}
|
|
public void runState(ActionContext context, String operator, ReferObject referObject, DataEvent dataEvent, String stateName) throws Exception {
|
StateOperate operate = StateOperate.parse(operator);
|
State state = null;
|
|
try {
|
DataReader dataReader = context.getDataReader();
|
DataWriter dataWriter = context.getDataWriter();
|
|
//1. 获取直接状态对象的 State Point
|
DataPackage dataPackage = dataReader.getDataPackage();
|
StatePoint statePoint = getStatePoint(dataPackage, operator, dataWriter);
|
|
if (statePoint == null) {
|
context.terminateTask();
|
return;
|
}
|
|
//2. 改变直接状态对象的状态
|
state = doRunState(SenderType.Original, dataPackage, statePoint, operate, dataEvent, stateName);
|
context.setStateCode(dataPackage.getName(), state.getCode());
|
|
//3. 如果有Host，处理对象的状态
|
DataPackage host = dataPackage.getHost();
|
|
StatePoint hostPoint = null;
|
if (host != null) {
|
hostPoint = getStatePoint(host, operator, dataWriter);
|
|
if (hostPoint == null) {
|
context.terminateTask();
|
return;
|
}
|
|
state = doRunState(SenderType.Host, host, hostPoint, operate, dataEvent, null);
|
context.setStateCode(host.getName(), state.getCode());
|
}
|
|
//4. 处理Refer对象状态
|
StatePoint referPoint = null;
|
if (referObject == null) {
|
referObject = new ReferObject(dataReader);
|
}
|
|
if (!referObject.isEmpty()) {
|
DataPackage refer = DataPackage.getInstance(referObject.getDataName());
|
refer.setMasterId(referObject.getId());
|
refer.loadMasterFromDB();
|
|
referPoint = getStatePoint(refer, operator, dataWriter);
|
|
if (referPoint == null) {
|
context.terminateTask();
|
return;
|
}
|
|
state = doRunState(SenderType.Refer, refer, referPoint, operate, dataEvent, null);
|
context.setStateCode(refer.getName(), state.getCode());
|
}
|
|
//5. 如果直接直接状态对象配置了审批，启动审批流
|
if ((StateOperate.Commit == operate || StateOperate.toChange == operate || StateOperate.toClose == operate) && statePoint.isFireAppproveFlow()) {
|
String dataName = dataPackage.getName();
|
String masterId = dataPackage.getMasterId();
|
IOnlineUser user = dataReader.getUser();
|
|
DetailState detailState = WorkingInstance.start(dataName, masterId, statePoint, hostPoint, referPoint, referObject, user, context);
|
doRunDetailState(dataPackage, detailState);
|
}
|
|
//6. 返回直接状态对象的状态
|
String result = state.getName();
|
dataWriter.reportOneMessage("runState", "执行成功，当前状态为[" + result + "]");
|
}
|
catch (Exception e) {
|
context.terminateTask();
|
e.printStackTrace();
|
}
|
}
|
|
|
public void runApprove(ActionContext context, ApproveOperate operator) throws Exception {
|
try {
|
DataReader dataReader = context.getDataReader();
|
DataWriter dataWriter = context.getDataWriter();
|
|
//1. 获取当前审批流程
|
DataPackage dataPackage = dataReader.getDataPackage();
|
String dataName = dataPackage.getName();
|
StateMachine machine = MachineBucket.getMachineByDataName(dataName);
|
|
Domain domain = dataReader.getDomain();
|
String masterId = domain.getId();
|
Entity masterEntity = dataPackage.getMasterEntity();
|
WorkingInstance flowInstance = WorkingInstance.getInstance(machine, masterId);
|
|
if (flowInstance.isEmpty()) {
|
logger.error("approval not exists, document id is {}", masterId);
|
StateMessage message = StateMessage.getInstance(dataName, "approveFinished", "审批已结束，无法完成当前操作");
|
dataWriter.reportOneError("approve", message.getContent(dataPackage));
|
return;
|
}
|
|
//2. 获取 State Point
|
String masterPointId = flowInstance.getMasterPointId();
|
StatePoint statePoint = StateMachine.getGlobalPoint(masterPointId);
|
if (statePoint == null) {
|
context.terminateTask();
|
logger.error("approve error, state point not exists: {}", masterPointId);
|
return;
|
}
|
|
//3. 检查当前用户是否合法
|
flowInstance.gotoActiveStep();
|
|
IOnlineUser onlineUser = dataReader.getUser();
|
String creatorId = masterEntity.getString("creator_id");
|
|
if (!flowInstance.validateCurrentUser(operator, onlineUser, creatorId)) {
|
logger.error("approval user not valid, document:{} , user:{}", masterId, onlineUser.getName());
|
StateMessage message = StateMessage.getInstance(dataName, "IllegalUser", "用户没有权限审批当前节点，无法审批");
|
dataWriter.reportOneError("approve", message.getContent(dataPackage));
|
return;
|
}
|
|
StepLocation position = null;
|
ApprovalResult approvalResult = new ApprovalResult();
|
ReferObject referObject = new ReferObject(flowInstance.getMaster());
|
String remark = dataReader.getString("remark");
|
|
//4.1 审批通过
|
if (ApproveOperate.Approve == operator) {
|
approvalResult = flowInstance.runStep(statePoint, onlineUser, operator, remark);
|
position = approvalResult.getStepLoscation();
|
|
if (StepLocation.AtSuccess == position) {
|
flowInstance.close();
|
logger.info("审批动作", StateOperate.StateEnd);
|
approveRunState(context, statePoint, flowInstance, StateOperate.StateEnd, referObject, null);
|
}
|
}
|
//4.2 审批通过（进入到状态Final）
|
else if (ApproveOperate.GoEnd == operator) {
|
approvalResult = flowInstance.runStep(statePoint, onlineUser, operator, remark);
|
flowInstance.close();
|
|
approveRunState(context, statePoint, flowInstance, StateOperate.StateEnd, referObject, null);
|
}
|
//4.3 审批不通过（回退一步）
|
else if (ApproveOperate.GoBack == operator) {
|
approvalResult = flowInstance.runStep(statePoint, onlineUser, operator, remark);
|
position = approvalResult.getStepLoscation();
|
|
if (StepLocation.AtHome == position) {
|
flowInstance.close();
|
approveRunState(context, statePoint, flowInstance, StateOperate.StateFrom, referObject, StateName_Back);
|
}
|
}
|
//4.4 审批不通过（回退到状态Home）
|
else if (ApproveOperate.GoHome == operator) {
|
approvalResult = flowInstance.runStep(statePoint, onlineUser, operator, remark);
|
flowInstance.close();
|
|
approveRunState(context, statePoint, flowInstance, StateOperate.StateFrom, referObject, StateName_Back);
|
}
|
//4.5 申请人主动撤销（回退到状态Home）
|
else if (ApproveOperate.PullBack == operator) {
|
approvalResult = flowInstance.runStep(statePoint, onlineUser, operator, remark);
|
flowInstance.close();
|
|
approveRunState(context, statePoint, flowInstance, StateOperate.StateFrom, referObject, StateName_Cancel);
|
}
|
|
DetailState detailState = approvalResult.getDetailState();
|
doRunDetailState(dataPackage, detailState);
|
}
|
catch (Exception e) {
|
context.terminateTask();
|
e.printStackTrace();
|
}
|
}
|
|
public void approveRunState(ActionContext context, StatePoint statePoint, WorkingInstance flowInstance, StateOperate operate, ReferObject referObject, String stateName) throws Exception {
|
try {
|
DataReader dataReader = context.getDataReader();
|
|
if (referObject == null) {
|
referObject = new ReferObject(dataReader);
|
}
|
|
DataPackage dataPackage = dataReader.getDataPackage();
|
State state = doRunState(SenderType.Original, dataPackage, statePoint, operate, null, stateName);
|
context.setStateCode(dataPackage.getName(), state.getCode());
|
context.setStateCode(dataPackage.getName(), operate.name());
|
|
//1. 如果有Host，处理对象的状态
|
DataPackage host = dataPackage.getHost();
|
|
if (host != null) {
|
String hostPointId = flowInstance.getHostPointId();
|
statePoint = StateMachine.getGlobalPoint(hostPointId);
|
if (statePoint == null) {
|
context.terminateTask();
|
logger.error("approve error, state point not exists: {}", hostPointId);
|
return;
|
}
|
|
state = doRunState(SenderType.Host, host, statePoint, operate, null, null);
|
context.setStateCode(host.getName(), state.getCode());
|
}
|
|
//2. 处理Refer对象状态
|
if (referObject != null && !referObject.isEmpty()) {
|
String referPointId = flowInstance.getReferPointId();
|
statePoint = StateMachine.getGlobalPoint(referPointId);
|
if (statePoint == null) {
|
context.terminateTask();
|
logger.error("approve error, state point not exists: {}", referPointId);
|
return;
|
}
|
|
DataPackage refer = DataPackage.getInstance(referObject.getDataName());
|
refer.setMasterId(referObject.getId());
|
refer.loadMasterFromDB();
|
|
state = doRunState(SenderType.Refer, refer, statePoint, operate, null, stateName);
|
context.setStateCode(refer.getName(), state.getCode());
|
}
|
}
|
catch (Exception e) {
|
context.terminateTask();
|
e.printStackTrace();
|
}
|
}
|
|
private StatePoint getStatePoint(DataPackage dataPackage, String operator, DataWriter dataWriter) {
|
//1. 获取单据头
|
String dataName = dataPackage.getName();
|
Entity master = dataPackage.getMasterEntity(DataSource.DB, DataSource.Request, DataSource.File);
|
|
if (master == null) {
|
if (dataWriter != null) {
|
StateMessage message = StateMessage.getInstance(dataName, "documentNotExists", "单据数据不存在，状态机无法工作");
|
dataWriter.reportOneError("runState", message.getContent(dataPackage));
|
}
|
return null;
|
}
|
|
//2. 获取状态机
|
StateMachine machine = MachineBucket.getMachineByDataName(dataName);
|
|
if (machine == null) {
|
if (dataWriter != null) {
|
StateMessage message = StateMessage.getInstance(dataName, "MachineNotExists", "状态机不存在(" + dataName + ")");
|
dataWriter.reportOneError("runState", message.getContent(dataPackage));
|
}
|
return null;
|
}
|
|
//3. 通过状态操作获取Point
|
StateField stateField = machine.getStateField();
|
String fromStateCode = master.getString(stateField.getCode());
|
String fromStateName = master.getString(stateField.getName());
|
|
String key = StatePoint.createKey(fromStateCode, operator);
|
StatePoint point = machine.getPoint(key);
|
|
if (point != null) {
|
return point;
|
}
|
|
//4. 通过审批流操作获取Point
|
ApproveOperate approveOperate = ApproveOperate.parse(operator);
|
|
if (ApproveOperate.Unknown == approveOperate) {
|
return null;
|
}
|
|
point = machine.getPointByToState(fromStateCode);
|
|
if (point == null) {
|
if (dataWriter != null) {
|
logger.error("invalid operator {}.{} on state {}", operator, fromStateCode);
|
StateMessage message = StateMessage.getInstance(dataName, "PointNotExists", "状态（" + fromStateName + "）不支持当前操作");
|
dataWriter.reportOneError("runState", message.getContent(dataPackage));
|
}
|
return null;
|
}
|
|
return point;
|
}
|
|
private State doRunState(SenderType senderType, DataPackage dataPackage, StatePoint point, StateOperate operate, DataEvent dataEvent, String stateName) throws Exception {
|
StateMachine machine = point.getMachine();
|
StateField stateField = machine.getStateField();
|
|
State result = null;
|
|
//1. 如果是提交操作
|
if (StateOperate.Commit == operate || StateOperate.toChange == operate || StateOperate.toClose == operate) {
|
result = point.getToState();
|
}
|
//2. 如果是回退操作
|
else if (StateOperate.StateEnd == operate) {
|
result = point.getEndState();
|
}
|
//3. 如果是回退操作
|
else if (StateOperate.StateFrom == operate) {
|
result = State.stateCopy(point.getFromState());
|
|
if (SenderType.Original == senderType && (!Util.isEmpty(stateName))) {
|
result.setName(stateName);
|
}
|
}
|
|
if (result != null) {
|
updateDocumentState(stateField, result, dataPackage, dataEvent);
|
}
|
|
return result;
|
}
|
|
private void doRunDetailState(DataPackage dataPackage, DetailState step) throws Exception {
|
if (step == null) {
|
return ;
|
}
|
DataObject masterObject = dataPackage.getMasterDataObject();
|
EntitySaver saver;
|
|
//1. 设置状态
|
if (dataPackage.getMasterEntity() == null) {
|
saver = masterObject.createEntitySaver(dataPackage.getMasterId());
|
}
|
else{
|
saver = masterObject.createEntitySaver(dataPackage.getMasterEntity());
|
}
|
saver.set("state_step_code", step.getCode());
|
saver.set("state_step_name", step.getName());
|
|
//2. 更新数据库
|
saver.update();
|
}
|
|
private void updateDocumentState(StateField stateField, State toState, DataPackage dataPackage, DataEvent dataEvent) throws Exception {
|
DataObject masterObject = dataPackage.getMasterDataObject();
|
EntitySaver saver;
|
|
//1. 设置状态
|
if (dataPackage.getMasterEntity() == null) {
|
saver = masterObject.createEntitySaver(dataPackage.getMasterId());
|
}
|
else{
|
saver = masterObject.createEntitySaver(dataPackage.getMasterEntity());
|
}
|
saver.set(stateField.getCode(), toState.getCode());
|
saver.set(stateField.getName(), toState.getName());
|
|
//2. 更新数据库
|
saver.update(dataEvent);
|
}
|
|
public void getApproveSteps(ActionContext context) throws Exception {
|
DataReader dataReader = context.getDataReader();
|
Domain domain = dataReader.getDomain();
|
DataPackage dataPackage = domain.getDataPackage();
|
DataWriter dataWriter = context.getDataWriter();
|
|
//1.
|
String dataName = domain.getDataName();
|
StateMachine machine = MachineBucket.getMachineByDataName(dataName);
|
|
if (machine == null) {
|
StateMessage message = StateMessage.getInstance(dataName, "MachineNotExists", "状态机不存在(" + dataName + ")");
|
dataWriter.reportOneError("runState", message.getContent(dataPackage));
|
return;
|
}
|
|
//2. 获取Point
|
String fromStateCode = dataReader.getString("from_state");
|
String operator = dataReader.getString("operator");
|
|
String key = StatePoint.createKey(fromStateCode, operator);
|
StatePoint point = machine.getPoint(key);
|
|
if (point == null) {
|
StateMessage message = StateMessage.getInstance(dataName, "PointNotExists", "状态（" + fromStateCode + "）不支持当前操作");
|
dataWriter.reportOneError("runState", message.getContent(dataPackage));
|
return;
|
}
|
|
//3. 获取步骤
|
IOnlineUser user = dataReader.getUser();
|
ApproveRuntime steps = point.getSteps(user, context);
|
|
//4. 返回
|
dataWriter.addValue(steps);
|
}
|
|
public void getMachine(ActionContext context) throws Exception {
|
DataReader dataReader = context.getDataReader();
|
Domain domain = dataReader.getDomain();
|
DataWriter dataWriter = context.getDataWriter();
|
|
String dataName = domain.getDataName();
|
StateMachine machine = MachineBucket.getMachineByDataName(dataName);
|
|
dataWriter.addValue("machine", machine);
|
}
|
|
public void getOneMachine(ActionContext context) throws Exception {
|
DataReader dataReader = context.getDataReader();
|
Domain domain = dataReader.getDomain();
|
DataWriter dataWriter = context.getDataWriter();
|
|
String id = domain.getId();
|
StateMachine machine = MachineBucket.getMachineById(id);
|
|
dataWriter.addValue("machine", machine);
|
}
|
|
public void getPoints(ActionContext context) throws Exception {
|
DataWriter dataWriter = context.getDataWriter();
|
|
MachineBucket bucket = MachineBucket.getInstance();
|
StatePoints statePointList = new StatePoints();
|
|
for (StateMachine machine : bucket) {
|
statePointList.addAll(machine.getStatePoints());
|
}
|
|
dataWriter.addValue(statePointList);
|
}
|
|
public void getPointsByApprove(ActionContext context) throws Exception {
|
DataReader dataReader = context.getDataReader();
|
DataWriter dataWriter = context.getDataWriter();
|
|
String approveId = dataReader.getString("approve_id");
|
StatePoints bucket = StateMachineLoader.loadPointsByApproveId(approveId);
|
|
dataWriter.addValue(bucket);
|
}
|
|
@Override
|
public DataStates queryToStates(WorkFlowRuntime workflow, DataPackage dataPackage, String operator, DataWriter dataWriter) {
|
DataStates result = new DataStates();
|
|
Operate operate = new Operate(operator);
|
|
//1. 获取直接状态对象的 State
|
String dataName = dataPackage.getName();
|
StateContext stateContext = workflow.getStateContext();
|
stateContext.setState(dataName, operate.getStateOperate().name());
|
|
StatePoint statePoint = getStatePoint(dataPackage, operator, null);
|
|
if (statePoint != null) {
|
String stateCode = getTargetStateCode(statePoint, operate.getInitialOperator());
|
result.setState(dataName, stateCode);
|
}
|
|
//2. 获取 Host 对象状态
|
DataPackage host = dataPackage.getHost();
|
|
if (host == null) {
|
return result;
|
}
|
|
statePoint = getStatePoint(host, operator, null);
|
|
if (statePoint != null) {
|
String stateCode = getTargetStateCode(statePoint, operator);
|
result.setState(host.getName(), stateCode);
|
}
|
|
return result;
|
}
|
|
private String getTargetStateCode(StatePoint statePoint, String operator) {
|
StateOperate stateOperate = StateOperate.parse(operator);
|
|
if (StateOperate.Commit == stateOperate || StateOperate.toChange == stateOperate || StateOperate.toClose == stateOperate) {
|
return statePoint.getToCode();
|
}
|
else if (StateOperate.StateEnd == stateOperate) {
|
return statePoint.getEndCode();
|
}
|
else if (StateOperate.StateFrom == stateOperate) {
|
return statePoint.getFromCode();
|
}
|
|
ApproveOperate approveOperate = ApproveOperate.parse(operator);
|
|
if (ApproveOperate.Approve == approveOperate) {
|
return statePoint.getEndCode();
|
}
|
else if (ApproveOperate.GoEnd == approveOperate) {
|
return statePoint.getEndCode();
|
}
|
else if (ApproveOperate.GoHome == approveOperate) {
|
return statePoint.getFromCode();
|
}
|
else if (ApproveOperate.PullBack == approveOperate) {
|
return statePoint.getFromCode();
|
}
|
else if (ApproveOperate.GoBack == approveOperate) {
|
return statePoint.getFromCode();
|
}
|
|
return null;
|
}
|
|
@Override
|
public boolean isInFreedom(DataPackage dataPackage) throws Exception {
|
dataPackage.loadMasterFromDB();
|
|
PackageItem master = dataPackage.getMaster();
|
Entity entity = dataPackage.getMasterEntity(DataSource.DB);
|
|
if (entity == null) {
|
return true;
|
}
|
|
//1. 得到当前状态
|
String dataName = master.getName();
|
StateField stateField = MachineBucket.getStateField(dataName);
|
|
String stateCode = entity.getString(stateField.getCode());
|
|
//2. 检查是否处于自由态
|
boolean inFreedom = MachineBucket.isInFreedom(dataName, stateCode);
|
return inFreedom;
|
}
|
|
public String getName() {
|
return StateCenter.class.getSimpleName();
|
}
|
|
public void loadOneTargetOperator(String target, String operator) {
|
String key = WorkStepKey.getObjectKey(target, operator);
|
targetOperators.add(key);
|
}
|
|
public Set<String> getTargetOperators() {
|
return targetOperators;
|
}
|
|
}
|
