Activiti工作流委托功能

委托：一般是指办理人指定A为其在指定时间内代理审批公文。有新建委托记录，撤销委托记录操作。

具体实现：

一.创建数据库表

1.创建委托数据表

CREATE TABLE WF_DELEGATE_INFO(
ID BIGINT auto_increment,
ASSIGNEE VARCHAR(200),
ATTORNEY VARCHAR(200),
START_TIME TIMESTAMP,
END_TIME TIMESTAMP,
PROCESS_DEFINITION_ID VARCHAR(100),
STATUS INTEGER
)

2.委托办理流水记录表

CREATE TABLE WF_DELEGATE_HISTORY(
ID BIGINT auto_increment,
ASSIGNEE VARCHAR(200),
ATTORNEY VARCHAR(200),
DELEGATE_TIME TIMESTAMP,
TASK_ID VARCHAR(100),
STATUS INTEGER
)

二.JAVA代码

1.创建实体

DelegateInfo

DelegateHistory

2.创建DelegateService

public class DelegateService {
    private static Logger logger = LoggerFactory
            .getLogger(DelegateService.class);
    public static final String SQL_GET_DELEGATE_INFO = "select * from bpm_delegate_info"
            + " where status=1 and assignee=? order by id desc";
    public static final String SQL_SET_DELEGATE_INFO = "insert into bpm_delegate_history"
            + "(assignee,attorney,delegate_time,task_id,status) values(?,?,now(),?,1)";
    private JdbcTemplate jdbcTemplate;

    public DelegateInfo getDelegateInfo(String targetAssignee,
            String targetProcessDefinitionId) {
        List<Map<String, Object>> list = jdbcTemplate.queryForList(
                SQL_GET_DELEGATE_INFO, targetAssignee);

        for (Map<String, Object> map : list) {
            logger.info("map : {}", map);

            Long id = (Long) map.get("id");
            String assignee = (String) map.get("assignee");
            String attorney = (String) map.get("attorney");
            String processDefinitionId = (String) map
                    .get("process_definition_id");
            Date startTime = (Date) map.get("start_time");
            Date endTime = (Date) map.get("end_time");
            Integer status = (Integer) map.get("status");

            if (timeNotBetweenNow(startTime, endTime)) {
                logger.info("timeNotBetweenNow");

                continue;
            }

            if ((processDefinitionId == null)
                    || processDefinitionId.equals(targetProcessDefinitionId)) {
                logger.info("delegate to {}", attorney);

                // delegateTask.setAssignee(attorney);
                // jdbcTemplate.update(SQL_SET_DELEGATE_INFO, assignee,
                // attorney, delegateTask.getId());
                DelegateInfo delegateInfo = new DelegateInfo();
                delegateInfo.setId(id);
                delegateInfo.setAssignee(assignee);
                delegateInfo.setAttorney(attorney);
                delegateInfo.setProcessDefinitionId(processDefinitionId);
                delegateInfo.setStartTime(startTime);
                delegateInfo.setEndTime(endTime);
                delegateInfo.setStatus(status);

                return delegateInfo;
            }
        }

        return null;
    }

    public void saveRecord(String assignee, String attorney, String taskId) {
        jdbcTemplate.update(SQL_SET_DELEGATE_INFO, assignee, attorney, taskId);
    }

    public void removeRecord(Long id) {
        jdbcTemplate.update("delete from bpm_delegate_info where id=?", id);
    }

    public void addDelegateInfo(String assignee, String attorney,
            Date startTime, Date endTime, String processDefinitionId) {
        String sql = "insert into bpm_delegate_info(assignee,attorney,start_time,end_time,process_definition_id,status) values(?,?,?,?,?,?)";
        jdbcTemplate.update(sql, assignee, attorney, startTime, endTime,
                processDefinitionId, 1);
    }

    private boolean timeNotBetweenNow(Date startTime, Date endTime) {
        Date now = new Date();

        if (startTime != null) {
            return now.before(startTime);
        }

        if (endTime != null) {
            return now.after(endTime);
        }

        return false;
    }

    @Resource
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
}

3.创建activiti监听器DelegateTaskListener

public class DelegateTaskListener extends DefaultTaskListener {
    private DelegateService delegateService;

    @Override
    public void onAssignment(DelegateTask delegateTask) throws Exception {
        String assignee = delegateTask.getAssignee();
        String processDefinitionId = delegateTask.getProcessDefinitionId();
        DelegateInfo delegateInfo = delegateService.getDelegateInfo(assignee,
                processDefinitionId);

        if (delegateInfo == null) {
            return;
        }

        String attorney = delegateInfo.getAttorney();
        delegateTask.setAssignee(attorney);
        delegateService.saveRecord(assignee, attorney, delegateTask.getId());
    }

    @Resource
    public void setDelegateService(DelegateService delegateService) {
        this.delegateService = delegateService;
    }
}