public class MyTask {
private int revision;
private String id;
private String owner;
private String assignee;
private DelegationState delegationState;
private String parentTaskId;
private String name;
private String description;
private Date createTime; // The time when the task has been created
private Date dueDate;
private int suspensionState = SuspensionState.ACTIVE.getStateCode();
private boolean isIdentityLinksInitialized = false;
private List<IdentityLinkEntity> taskIdentityLinkEntities = new ArrayList<IdentityLinkEntity>();
private String executionId;
private ExecutionEntity execution;
private String processInstanceId;
private ExecutionEntity processInstance;
private String processDefinitionId;
private TaskDefinition taskDefinition;
private String taskDefinitionKey;
private boolean isDeleted;
private String eventName;
public int getRevision() {
return revision;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void setRevision(int revision) {
this.revision = revision;
}
public String getOwner() {
return owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public String getAssignee() {
return assignee;
}
public void setAssignee(String assignee) {
this.assignee = assignee;
}
public DelegationState getDelegationState() {
return delegationState;
}
public void setDelegationState(DelegationState delegationState) {
this.delegationState = delegationState;
}
public String getParentTaskId() {
return parentTaskId;
}
public void setParentTaskId(String parentTaskId) {
this.parentTaskId = parentTaskId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getDueDate() {
return dueDate;
}
public void setDueDate(Date dueDate) {
this.dueDate = dueDate;
}
public int getSuspensionState() {
return suspensionState;
}
public void setSuspensionState(int suspensionState) {
this.suspensionState = suspensionState;
}
public boolean isIdentityLinksInitialized() {
return isIdentityLinksInitialized;
}
public void setIdentityLinksInitialized(boolean isIdentityLinksInitialized) {
this.isIdentityLinksInitialized = isIdentityLinksInitialized;
}
public List<IdentityLinkEntity> getTaskIdentityLinkEntities() {
return taskIdentityLinkEntities;
}
public void setTaskIdentityLinkEntities(List<IdentityLinkEntity> taskIdentityLinkEntities) {
this.taskIdentityLinkEntities = taskIdentityLinkEntities;
}
public String getExecutionId() {
return executionId;
}
public void setExecutionId(String executionId) {
this.executionId = executionId;
}
public ExecutionEntity getExecution() {
return execution;
}
public void setExecution(ExecutionEntity execution) {
this.execution = execution;
}
public String getProcessInstanceId() {
return processInstanceId;
}
public void setProcessInstanceId(String processInstanceId) {
this.processInstanceId = processInstanceId;
}
public ExecutionEntity getProcessInstance() {
return processInstance;
}
public void setProcessInstance(ExecutionEntity processInstance) {
this.processInstance = processInstance;
}
public String getProcessDefinitionId() {
return processDefinitionId;
}
public void setProcessDefinitionId(String processDefinitionId) {
this.processDefinitionId = processDefinitionId;
}
public TaskDefinition getTaskDefinition() {
return taskDefinition;
}
public void setTaskDefinition(TaskDefinition taskDefinition) {
this.taskDefinition = taskDefinition;
}
public String getTaskDefinitionKey() {
return taskDefinitionKey;
}
public void setTaskDefinitionKey(String taskDefinitionKey) {
this.taskDefinitionKey = taskDefinitionKey;
}
public boolean isDeleted() {
return isDeleted;
}
public void setDeleted(boolean isDeleted) {
this.isDeleted = isDeleted;
}
public String getEventName() {
return eventName;
}
public void setEventName(String eventName) {
this.eventName = eventName;
}
}
public boolean requestServiceCertificateValidate(Long id, String carManEntryKey, Json json) {
Assert.assertNotNull(id);
Assert.assertNotNull(carManEntryKey);
Assert.assertNotNull(json);
TempDriver driver = this.tempDriverDao.load(id);
// 不存在流程关系
if (!this.workflowModuleRelationService.hasRelation4Key(
id, TempDriver.WORKFLOW_MTYPE, carManEntryKey)) return false;
// 声明变量
String _true = "1";
// 设置需要获取的变量
String[] args =
new String[] {"isGiveUp", "isPass", "isPairDriver", "pairDriverName", "pairDriverNameId"};
// 复试组组长任务key
String taskKey = "t100RetestHeadCheck";
// 本地变量
String localKey = "isPass_lc";
// 获取最新的司机入职流程相关参数
Map<String, Object> driver_wf =
this.workflowModuleRelationService
.findList(id, TempDriver.WORKFLOW_MTYPE, carManEntryKey, args)
.get(0);
// 流程id
String pid = driver_wf.get("pid").toString();
// 流程状态
int pStatus = Integer.valueOf(driver_wf.get("status").toString());
// 查找复试组长是否选择通过变量
Object pass_lc = this.workflowService.findLocalValue(pid, taskKey, localKey);
// 复试组长 选项 流程未到复试组长组长审批 选择不通过
boolean isPass_lc = _true.equals(pass_lc);
// 不具备发起的条件
// 流程未结束，(流程未到复试组长组长审批或复试组组长选择不通过)
if (SuspensionState.ACTIVE.getStateCode() == pStatus && !isPass_lc) return false;
// 司机放弃入职变量
boolean isGiveUp = _true.equals(driver_wf.get("isGiveUp"));
// 司机通过入职变量
boolean isPass = _true.equals(driver_wf.get("isPass"));
// 是否有对班司机编辑
boolean isPair = _true.equals(driver_wf.get("isPairDriver"));
// 无论是否有对班司机 ，都不具备发起的条件
// 流程结束，司机选择放弃
if (WorkspaceServiceImpl.COMPLETE == pStatus && isGiveUp) return false;
// 流程结束，司机不通过
if (WorkspaceServiceImpl.COMPLETE == pStatus && !isPass) return false;
// 设置司机信息
json.put("id", id.toString());
json.put("name", driver.getName());
json.put("applyAttr", driver.getApplyAttr()); // 申请属性
// 设置对班司机的身份证很从业资格证
json.put("certIdentity", driver.getCertIdentity());
json.put("certCYZG", driver.getCertCYZG());
json.put("pid", pid);
json.put("pname", driver_wf.get("name").toString());
// 设置是否有对班 默认没有
json.put("isPairDriver", false);
// 没有对班，司机具备发起服务资格证流程条件
// 流程结束 &&没有放弃 &&入职通过
if (!isPair && WorkspaceServiceImpl.COMPLETE == pStatus && !isGiveUp && isPass) return true;
// 流程未结束 && 复试组组长选择通过
if (!isPair && SuspensionState.ACTIVE.getStateCode() == pStatus && isPass_lc) return true;
// ******存在对班 查找对班的入职情况***开始****
// 对班id
Long pDriverId = Long.valueOf(driver_wf.get("pairDriverNameId").toString());
TempDriver pDriver = this.tempDriverDao.load(pDriverId);
json.put("isPairDriver", true);
// 对班存在入职流程
if (this.workflowModuleRelationService.hasRelation4Key(
pDriverId, TempDriver.WORKFLOW_MTYPE, carManEntryKey)) {
// 获取对班司机最新的司机入职流程相关参数
Map<String, Object> pDriver_wf =
this.workflowModuleRelationService
.findList(pDriverId, TempDriver.WORKFLOW_MTYPE, carManEntryKey, args)
.get(0);
// 流程id
String pDriver_pid = pDriver_wf.get("pid").toString();
// 司机放弃入职变量
boolean pDriver_isGiveUp = _true.equals(pDriver_wf.get("isGiveUp"));
// 司机通过入职变量
boolean pDriver_isPass = _true.equals(pDriver_wf.get("isPass"));
// 是否有对班司机编辑
boolean pDriver_isPair = _true.equals(pDriver_wf.get("isPairDriver"));
// 流程状态
int pDriver_pStatus = Integer.valueOf(pDriver_wf.get("status").toString());
// 查找复试组长是否选择通过变量
Object pDriver_pass_lc = this.workflowService.findLocalValue(pDriver_pid, taskKey, localKey);
// 复试组长 选项 流程未到复试组长组长审批
// 选择不通过
boolean pDriver_isPass_lc = _true.equals(pDriver_pass_lc);
// 司机和对班都具备发起服务资格证流程的条件
if ( // 条件1)流程结束 &&没有放弃 &&入职通过 && 有对班
(WorkspaceServiceImpl.COMPLETE == pDriver_pStatus
&& !pDriver_isGiveUp
&& pDriver_isPass
&& pDriver_isPair)
// 条件2)流程未结束 && 复试组组长选择通过 && 有对班
|| (SuspensionState.ACTIVE.getStateCode() == pDriver_pStatus
&& pDriver_isPass_lc
&& pDriver_isPair)) {
// 设置对班司机信息
json.put("pair_id", pDriverId.toString());
json.put("pair_name", pDriver.getName());
json.put("pair_applyAttr", pDriver.getApplyAttr()); // 申请属性
// 设置对班司机的身份证很从业资格证
json.put("pair_certIdentity", pDriver.getCertIdentity());
json.put("pair_certCYZG", pDriver.getCertCYZG());
json.put("pair_pid", pDriver_pid);
json.put("pair_pname", pDriver_wf.get("name").toString());
return true;
}
}
// ******存在对班 查找对班的入职情况***结束****
// ****查找对班但未符合发起的条件，入职通过的司机再找另外一个对班司机的情况****开始*****
List<Map<String, Object>> others =
this.workflowModuleRelationService.findList(
null,
TempDriver.WORKFLOW_MTYPE,
carManEntryKey,
new String[] {
"isGiveUp",
"isPass",
"isPairDriver",
"pairDriverName",
"pairDriverNameId",
"tempDriver_id"
});
for (Map<String, Object> wmr : others) {
if (_true.equals(wmr.get("isPairDriver")) // 有选择对班
// 选择原通过的司机
&& String.valueOf(id).equals(wmr.get("pairDriverNameId"))) {
// 流程id
String new_pid = wmr.get("pid").toString();
// 司机放弃入职变量
boolean new_isGiveUp = _true.equals(wmr.get("isGiveUp"));
// 司机通过入职变量
boolean new_isPass = _true.equals(wmr.get("isPass"));
// 流程状态
int new_pStatus = Integer.valueOf(wmr.get("status").toString());
// 查找复试组长是否选择通过变量
Object new_pass_lc = this.workflowService.findLocalValue(new_pid, taskKey, localKey);
// 复试组长 选项 流程未到复试组长组长审批
// 选择不通过
boolean new_isPass_lc = _true.equals(new_pass_lc);
// 新的对班司机
TempDriver newPairDriver =
this.tempDriverDao.load(Long.valueOf(wmr.get("tempDriver_id").toString()));
// 司机和新的对班都具备发起服务资格证流程的条件
if ( // 条件1)流程结束 &&没有放弃 &&入职通过
(WorkspaceServiceImpl.COMPLETE == new_pStatus && !new_isGiveUp && new_isPass)
// 条件2)流程未结束 && 复试组组长选择通过
|| (SuspensionState.ACTIVE.getStateCode() == new_pStatus && new_isPass_lc)) {
// 设置对班司机信息
json.put("pair_id", newPairDriver.getId().toString());
json.put("pair_name", newPairDriver.getName());
json.put("pair_applyAttr", newPairDriver.getApplyAttr()); // 申请属性
// 设置对班司机的身份证很从业资格证
json.put("pair_certIdentity", newPairDriver.getCertIdentity());
json.put("pair_certCYZG", newPairDriver.getCertCYZG());
json.put("pair_pid", new_pid);
json.put("pair_pname", wmr.get("name").toString());
return true;
}
}
}
// ****查找对班但未符合发起的条件，入职通过的司机再找另外一个对班司机的情况****结束*****
return false;
}