加入流程定义功能

java110

2020-06-17 bac0f36dc4d7ee2c1277fe6b83c06692b08e3d80

加入流程定义功能

 docs/document/services/workflow/DeleteWorkflowInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流信息 侦听
 *
 * 处理节点
 * 1、businessWorkflow:{} 工作流基本信息节点
 * 2、businessWorkflowAttr:[{}] 工作流属性信息节点
 * 3、businessWorkflowPhoto:[{}] 工作流照片信息节点
 * 4、businessWorkflowCerdentials:[{}] 工作流证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowInfoListener")
@Transactional
public class DeleteWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowInfoListener.class);
    @Autowired
    IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

            //处理 businessWorkflow 节点
            if(data.containsKey(WorkflowPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowPo.class.getSimpleName());
                JSONArray businessWorkflows = null;
                if(_obj instanceof JSONObject){
                    businessWorkflows = new JSONArray();
                    businessWorkflows.add(_obj);
                }else {
                    businessWorkflows = (JSONArray)_obj;
                }
                //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
                for (int _workflowIndex = 0; _workflowIndex < businessWorkflows.size();_workflowIndex++) {
                    JSONObject businessWorkflow = businessWorkflows.getJSONObject(_workflowIndex);
                    doBusinessWorkflow(business, businessWorkflow);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                    }
                }

        }


    }

    /**
     * 删除 instance数据
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流信息
        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_DEL);

        //工作流信息
        List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if( businessWorkflowInfos != null && businessWorkflowInfos.size() >0) {
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size();_workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo,StatusConstant.STATUS_CD_INVALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
                dataFlowContext.addParamOut("flowId",businessWorkflowInfo.get("flow_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if(workflowInfo != null && workflowInfo.size() > 0){

            //工作流信息
            List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowInfos == null ||  businessWorkflowInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflow），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size();_workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo,StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
            }
        }
    }



    /**
     * 处理 businessWorkflow 节点
     * @param business 总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business,JSONObject businessWorkflow){

        Assert.jsonObjectHaveKey(businessWorkflow,"flowId","businessWorkflow 节点下没有包含 flowId 节点");

        if(businessWorkflow.getString("flowId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"flowId 错误，不能自动生成（必须已经存在的flowId）"+businessWorkflow);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflow(business,businessWorkflow);
    }
    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }
}

 docs/document/services/workflow/SaveWorkflowInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowInfoListener")
@Transactional
public class SaveWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener{

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowInfoListener.class);

    @Autowired
    private IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW;
    }

    /**
     * 保存工作流信息 business 表中
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflow 节点
        if(data.containsKey(WorkflowPo.class.getSimpleName())){
            Object bObj = data.get(WorkflowPo.class.getSimpleName());
            JSONArray businessWorkflows = null;
            if(bObj instanceof JSONObject){
                businessWorkflows = new JSONArray();
                businessWorkflows.add(bObj);
            }else {
                businessWorkflows = (JSONArray)bObj;
            }
            //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
            for (int bWorkflowIndex = 0; bWorkflowIndex < businessWorkflows.size();bWorkflowIndex++) {
                JSONObject businessWorkflow = businessWorkflows.getJSONObject(bWorkflowIndex);
                doBusinessWorkflow(business, businessWorkflow);
                if(bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流信息
        List<Map> businessWorkflowInfo = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if( businessWorkflowInfo != null && businessWorkflowInfo.size() >0) {
            reFreshShareColumn(info, businessWorkflowInfo.get(0));
            workflowServiceDaoImpl.saveWorkflowInfoInstance(info);
            if(businessWorkflowInfo.size() == 1) {
                dataFlowContext.addParamOut("flowId", businessWorkflowInfo.get(0).get("flow_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }
    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId",bId);
        paramIn.put("statusCd",StatusConstant.STATUS_CD_INVALID);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if(workflowInfo != null && workflowInfo.size() > 0){
            reFreshShareColumn(paramIn, workflowInfo.get(0));
            workflowServiceDaoImpl.updateWorkflowInfoInstance(paramIn);
        }
    }



    /**
     * 处理 businessWorkflow 节点
     * @param business 总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business,JSONObject businessWorkflow){

        Assert.jsonObjectHaveKey(businessWorkflow,"flowId","businessWorkflow 节点下没有包含 flowId 节点");

        if(businessWorkflow.getString("flowId").startsWith("-")){
            //刷新缓存
            //flushWorkflowId(business.getDatas());

            businessWorkflow.put("flowId",GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_flowId));

        }

        businessWorkflow.put("bId",business.getbId());
        businessWorkflow.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流信息
        workflowServiceDaoImpl.saveBusinessWorkflowInfo(businessWorkflow);

    }
    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }
}

 docs/document/services/workflow/UpdateWorkflowInfo.md

New file
@@ -0,0 +1,188 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流信息 侦听
 *
 * 处理节点
 * 1、businessWorkflow:{} 工作流基本信息节点
 * 2、businessWorkflowAttr:[{}] 工作流属性信息节点
 * 3、businessWorkflowPhoto:[{}] 工作流照片信息节点
 * 4、businessWorkflowCerdentials:[{}] 工作流证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowInfoListener")
@Transactional
public class UpdateWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowInfoListener.class);
    @Autowired
    private IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW;
    }

    /**
     * business过程
     * @param dataFlowContext 上下文对象
     * @param business 业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");


            //处理 businessWorkflow 节点
            if(data.containsKey(WorkflowPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowPo.class.getSimpleName());
                JSONArray businessWorkflows = null;
                if(_obj instanceof JSONObject){
                    businessWorkflows = new JSONArray();
                    businessWorkflows.add(_obj);
                }else {
                    businessWorkflows = (JSONArray)_obj;
                }
                //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
                for (int _workflowIndex = 0; _workflowIndex < businessWorkflows.size();_workflowIndex++) {
                    JSONObject businessWorkflow = businessWorkflows.getJSONObject(_workflowIndex);
                    doBusinessWorkflow(business, businessWorkflow);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                    }
                }
            }
    }


    /**
     * business to instance 过程
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流信息
        List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if( businessWorkflowInfos != null && businessWorkflowInfos.size() >0) {
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size();_workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo,StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
                if(businessWorkflowInfo.size() == 1) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowInfo.get("flow_id"));
                }
            }
        }

    }

    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if(workflowInfo != null && workflowInfo.size() > 0){

            //工作流信息
            List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowInfos == null || businessWorkflowInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflow），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size();_workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo,StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
            }
        }

    }



    /**
     * 处理 businessWorkflow 节点
     * @param business 总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business,JSONObject businessWorkflow){

        Assert.jsonObjectHaveKey(businessWorkflow,"flowId","businessWorkflow 节点下没有包含 flowId 节点");

        if(businessWorkflow.getString("flowId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"flowId 错误，不能自动生成（必须已经存在的flowId）"+businessWorkflow);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflow(business,businessWorkflow);

        businessWorkflow.put("bId",business.getbId());
        businessWorkflow.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流信息
        workflowServiceDaoImpl.saveBusinessWorkflowInfo(businessWorkflow);

    }



    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }



}

 docs/document/services/workflowStep/DeleteWorkflowStepInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflowStep;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowStepServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流节点信息 侦听
 *
 * 处理节点
 * 1、businessWorkflowStep:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowStepInfoListener")
@Transactional
public class DeleteWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowStepInfoListener.class);
    @Autowired
    IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

            //处理 businessWorkflowStep 节点
            if(data.containsKey(WorkflowStepPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowStepPo.class.getSimpleName());
                JSONArray businessWorkflowSteps = null;
                if(_obj instanceof JSONObject){
                    businessWorkflowSteps = new JSONArray();
                    businessWorkflowSteps.add(_obj);
                }else {
                    businessWorkflowSteps = (JSONArray)_obj;
                }
                //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
                for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowSteps.size();_workflowStepIndex++) {
                    JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(_workflowStepIndex);
                    doBusinessWorkflowStep(business, businessWorkflowStep);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                    }
                }

        }


    }

    /**
     * 删除 instance数据
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流节点信息
        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_DEL);

        //工作流节点信息
        List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if( businessWorkflowStepInfos != null && businessWorkflowStepInfos.size() >0) {
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size();_workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo,StatusConstant.STATUS_CD_INVALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
                dataFlowContext.addParamOut("flowId",businessWorkflowStepInfo.get("flow_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if(workflowStepInfo != null && workflowStepInfo.size() > 0){

            //工作流节点信息
            List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowStepInfos == null ||  businessWorkflowStepInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflowStep），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size();_workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
            }
        }
    }



    /**
     * 处理 businessWorkflowStep 节点
     * @param business 总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business,JSONObject businessWorkflowStep){

        Assert.jsonObjectHaveKey(businessWorkflowStep,"flowId","businessWorkflowStep 节点下没有包含 flowId 节点");

        if(businessWorkflowStep.getString("flowId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"flowId 错误，不能自动生成（必须已经存在的flowId）"+businessWorkflowStep);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflowStep(business,businessWorkflowStep);
    }
    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }
}

 docs/document/services/workflowStep/SaveWorkflowStepInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflowStep;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流节点信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowStepInfoListener")
@Transactional
public class SaveWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener{

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowStepInfoListener.class);

    @Autowired
    private IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP;
    }

    /**
     * 保存工作流节点信息 business 表中
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStep 节点
        if(data.containsKey(WorkflowStepPo.class.getSimpleName())){
            Object bObj = data.get(WorkflowStepPo.class.getSimpleName());
            JSONArray businessWorkflowSteps = null;
            if(bObj instanceof JSONObject){
                businessWorkflowSteps = new JSONArray();
                businessWorkflowSteps.add(bObj);
            }else {
                businessWorkflowSteps = (JSONArray)bObj;
            }
            //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
            for (int bWorkflowStepIndex = 0; bWorkflowStepIndex < businessWorkflowSteps.size();bWorkflowStepIndex++) {
                JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(bWorkflowStepIndex);
                doBusinessWorkflowStep(business, businessWorkflowStep);
                if(bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepInfo = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if( businessWorkflowStepInfo != null && businessWorkflowStepInfo.size() >0) {
            reFreshShareColumn(info, businessWorkflowStepInfo.get(0));
            workflowStepServiceDaoImpl.saveWorkflowStepInfoInstance(info);
            if(businessWorkflowStepInfo.size() == 1) {
                dataFlowContext.addParamOut("flowId", businessWorkflowStepInfo.get(0).get("flow_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }
    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId",bId);
        paramIn.put("statusCd",StatusConstant.STATUS_CD_INVALID);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if(workflowStepInfo != null && workflowStepInfo.size() > 0){
            reFreshShareColumn(paramIn, workflowStepInfo.get(0));
            workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(paramIn);
        }
    }



    /**
     * 处理 businessWorkflowStep 节点
     * @param business 总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business,JSONObject businessWorkflowStep){

        Assert.jsonObjectHaveKey(businessWorkflowStep,"flowId","businessWorkflowStep 节点下没有包含 flowId 节点");

        if(businessWorkflowStep.getString("flowId").startsWith("-")){
            //刷新缓存
            //flushWorkflowStepId(business.getDatas());

            businessWorkflowStep.put("flowId",GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_flowId));

        }

        businessWorkflowStep.put("bId",business.getbId());
        businessWorkflowStep.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepServiceDaoImpl.saveBusinessWorkflowStepInfo(businessWorkflowStep);

    }
    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }
}

 docs/document/services/workflowStep/UpdateWorkflowStepInfo.md

New file
@@ -0,0 +1,188 @@
package com.java110.common.listener.workflowStep;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowStepServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流节点信息 侦听
 *
 * 处理节点
 * 1、businessWorkflowStep:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowStepInfoListener")
@Transactional
public class UpdateWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowStepInfoListener.class);
    @Autowired
    private IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP;
    }

    /**
     * business过程
     * @param dataFlowContext 上下文对象
     * @param business 业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");


            //处理 businessWorkflowStep 节点
            if(data.containsKey(WorkflowStepPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowStepPo.class.getSimpleName());
                JSONArray businessWorkflowSteps = null;
                if(_obj instanceof JSONObject){
                    businessWorkflowSteps = new JSONArray();
                    businessWorkflowSteps.add(_obj);
                }else {
                    businessWorkflowSteps = (JSONArray)_obj;
                }
                //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
                for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowSteps.size();_workflowStepIndex++) {
                    JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(_workflowStepIndex);
                    doBusinessWorkflowStep(business, businessWorkflowStep);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                    }
                }
            }
    }


    /**
     * business to instance 过程
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if( businessWorkflowStepInfos != null && businessWorkflowStepInfos.size() >0) {
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size();_workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
                if(businessWorkflowStepInfo.size() == 1) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStepInfo.get("flow_id"));
                }
            }
        }

    }

    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if(workflowStepInfo != null && workflowStepInfo.size() > 0){

            //工作流节点信息
            List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowStepInfos == null || businessWorkflowStepInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflowStep），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size();_workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
            }
        }

    }



    /**
     * 处理 businessWorkflowStep 节点
     * @param business 总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business,JSONObject businessWorkflowStep){

        Assert.jsonObjectHaveKey(businessWorkflowStep,"flowId","businessWorkflowStep 节点下没有包含 flowId 节点");

        if(businessWorkflowStep.getString("flowId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"flowId 错误，不能自动生成（必须已经存在的flowId）"+businessWorkflowStep);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflowStep(business,businessWorkflowStep);

        businessWorkflowStep.put("bId",business.getbId());
        businessWorkflowStep.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepServiceDaoImpl.saveBusinessWorkflowStepInfo(businessWorkflowStep);

    }



    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }



}

 docs/document/services/workflowStepStaff/DeleteWorkflowStepStaffInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflowStepStaff;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流节点信息 侦听
 *
 * 处理节点
 * 1、businessWorkflowStepStaff:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepStaffAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepStaffPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepStaffCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowStepStaffInfoListener")
@Transactional
public class DeleteWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowStepStaffInfoListener.class);
    @Autowired
    IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP_STAFF;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

            //处理 businessWorkflowStepStaff 节点
            if(data.containsKey(WorkflowStepStaffPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowStepStaffPo.class.getSimpleName());
                JSONArray businessWorkflowStepStaffs = null;
                if(_obj instanceof JSONObject){
                    businessWorkflowStepStaffs = new JSONArray();
                    businessWorkflowStepStaffs.add(_obj);
                }else {
                    businessWorkflowStepStaffs = (JSONArray)_obj;
                }
                //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
                for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffs.size();_workflowStepStaffIndex++) {
                    JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(_workflowStepStaffIndex);
                    doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                    }
                }

        }


    }

    /**
     * 删除 instance数据
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流节点信息
        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_DEL);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if( businessWorkflowStepStaffInfos != null && businessWorkflowStepStaffInfos.size() >0) {
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size();_workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo,StatusConstant.STATUS_CD_INVALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
                dataFlowContext.addParamOut("wssId",businessWorkflowStepStaffInfo.get("wss_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if(workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0){

            //工作流节点信息
            List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowStepStaffInfos == null ||  businessWorkflowStepStaffInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflowStepStaff），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size();_workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
            }
        }
    }



    /**
     * 处理 businessWorkflowStepStaff 节点
     * @param business 总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business,JSONObject businessWorkflowStepStaff){

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff,"wssId","businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if(businessWorkflowStepStaff.getString("wssId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"wssId 错误，不能自动生成（必须已经存在的wssId）"+businessWorkflowStepStaff);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflowStepStaff(business,businessWorkflowStepStaff);
    }
    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }
}

 docs/document/services/workflowStepStaff/SaveWorkflowStepStaffInfo.md

New file
@@ -0,0 +1,175 @@
package com.java110.common.listener.workflowStepStaff;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流节点信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowStepStaffInfoListener")
@Transactional
public class SaveWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener{

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowStepStaffInfoListener.class);

    @Autowired
    private IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP_STAFF;
    }

    /**
     * 保存工作流节点信息 business 表中
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStepStaff 节点
        if(data.containsKey(WorkflowStepStaffPo.class.getSimpleName())){
            Object bObj = data.get(WorkflowStepStaffPo.class.getSimpleName());
            JSONArray businessWorkflowStepStaffs = null;
            if(bObj instanceof JSONObject){
                businessWorkflowStepStaffs = new JSONArray();
                businessWorkflowStepStaffs.add(bObj);
            }else {
                businessWorkflowStepStaffs = (JSONArray)bObj;
            }
            //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
            for (int bWorkflowStepStaffIndex = 0; bWorkflowStepStaffIndex < businessWorkflowStepStaffs.size();bWorkflowStepStaffIndex++) {
                JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(bWorkflowStepStaffIndex);
                doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                if(bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if( businessWorkflowStepStaffInfo != null && businessWorkflowStepStaffInfo.size() >0) {
            reFreshShareColumn(info, businessWorkflowStepStaffInfo.get(0));
            workflowStepStaffServiceDaoImpl.saveWorkflowStepStaffInfoInstance(info);
            if(businessWorkflowStepStaffInfo.size() == 1) {
                dataFlowContext.addParamOut("wssId", businessWorkflowStepStaffInfo.get(0).get("wss_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }
    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId",bId);
        paramIn.put("statusCd",StatusConstant.STATUS_CD_INVALID);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if(workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0){
            reFreshShareColumn(paramIn, workflowStepStaffInfo.get(0));
            workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(paramIn);
        }
    }



    /**
     * 处理 businessWorkflowStepStaff 节点
     * @param business 总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business,JSONObject businessWorkflowStepStaff){

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff,"wssId","businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if(businessWorkflowStepStaff.getString("wssId").startsWith("-")){
            //刷新缓存
            //flushWorkflowStepStaffId(business.getDatas());

            businessWorkflowStepStaff.put("wssId",GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_wssId));

        }

        businessWorkflowStepStaff.put("bId",business.getbId());
        businessWorkflowStepStaff.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepStaffServiceDaoImpl.saveBusinessWorkflowStepStaffInfo(businessWorkflowStepStaff);

    }
    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }
}

 docs/document/services/workflowStepStaff/UpdateWorkflowStepStaffInfo.md

New file
@@ -0,0 +1,188 @@
package com.java110.common.listener.workflowStepStaff;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流节点信息 侦听
 *
 * 处理节点
 * 1、businessWorkflowStepStaff:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepStaffAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepStaffPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepStaffCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowStepStaffInfoListener")
@Transactional
public class UpdateWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowStepStaffInfoListener.class);
    @Autowired
    private IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP_STAFF;
    }

    /**
     * business过程
     * @param dataFlowContext 上下文对象
     * @param business 业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");


            //处理 businessWorkflowStepStaff 节点
            if(data.containsKey(WorkflowStepStaffPo.class.getSimpleName())){
                Object _obj = data.get(WorkflowStepStaffPo.class.getSimpleName());
                JSONArray businessWorkflowStepStaffs = null;
                if(_obj instanceof JSONObject){
                    businessWorkflowStepStaffs = new JSONArray();
                    businessWorkflowStepStaffs.add(_obj);
                }else {
                    businessWorkflowStepStaffs = (JSONArray)_obj;
                }
                //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
                for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffs.size();_workflowStepStaffIndex++) {
                    JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(_workflowStepStaffIndex);
                    doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                    if(_obj instanceof JSONObject) {
                        dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                    }
                }
            }
    }


    /**
     * business to instance 过程
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if( businessWorkflowStepStaffInfos != null && businessWorkflowStepStaffInfos.size() >0) {
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size();_workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
                if(businessWorkflowStepStaffInfo.size() == 1) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaffInfo.get("wss_id"));
                }
            }
        }

    }

    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId",business.getbId());
        delInfo.put("operate",StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if(workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0){

            //工作流节点信息
            List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(delInfo);
            //除非程序出错了，这里不会为空
            if(businessWorkflowStepStaffInfos == null || businessWorkflowStepStaffInfos.size() == 0){
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR,"撤单失败（workflowStepStaff），程序内部异常,请检查！ "+delInfo);
            }
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size();_workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo,StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
            }
        }

    }



    /**
     * 处理 businessWorkflowStepStaff 节点
     * @param business 总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business,JSONObject businessWorkflowStepStaff){

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff,"wssId","businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if(businessWorkflowStepStaff.getString("wssId").startsWith("-")){
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR,"wssId 错误，不能自动生成（必须已经存在的wssId）"+businessWorkflowStepStaff);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflowStepStaff(business,businessWorkflowStepStaff);

        businessWorkflowStepStaff.put("bId",business.getbId());
        businessWorkflowStepStaff.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepStaffServiceDaoImpl.saveBusinessWorkflowStepStaffInfo(businessWorkflowStepStaff);

    }



    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }



}

 java110-bean/src/main/java/com/java110/dto/workflow/WorkflowDto.java

New file
@@ -0,0 +1,107 @@
package com.java110.dto.workflow;

import com.java110.dto.PageDto;

import java.io.Serializable;
import java.util.Date;

/**
 * @ClassName FloorDto
 * @Description 工作流数据层封装
 * @Author wuxw
 * @Date 2019/4/24 8:52
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
public class WorkflowDto extends PageDto implements Serializable {

    //10001 投诉建议 20002 报修 30003 采购
    public static final String FLOW_TYPE_COMPLAINT = "10001";

    private String skipLevel;
    private String describle;
    private String communityId;
    private String storeId;
    private String flowId;
    private String flowName;
    private String flowType;


    private Date createTime;

    private String statusCd = "0";


    public String getSkipLevel() {
        return skipLevel;
    }

    public void setSkipLevel(String skipLevel) {
        this.skipLevel = skipLevel;
    }

    public String getDescrible() {
        return describle;
    }

    public void setDescrible(String describle) {
        this.describle = describle;
    }

    public String getCommunityId() {
        return communityId;
    }

    public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }

    public String getStoreId() {
        return storeId;
    }

    public void setStoreId(String storeId) {
        this.storeId = storeId;
    }

    public String getFlowId() {
        return flowId;
    }

    public void setFlowId(String flowId) {
        this.flowId = flowId;
    }

    public String getFlowName() {
        return flowName;
    }

    public void setFlowName(String flowName) {
        this.flowName = flowName;
    }

    public String getFlowType() {
        return flowType;
    }

    public void setFlowType(String flowType) {
        this.flowType = flowType;
    }


    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getStatusCd() {
        return statusCd;
    }

    public void setStatusCd(String statusCd) {
        this.statusCd = statusCd;
    }
}

 java110-bean/src/main/java/com/java110/dto/workflow/WorkflowStepDto.java

New file
@@ -0,0 +1,83 @@
package com.java110.dto.workflow;

import com.java110.dto.PageDto;
import java.io.Serializable;
import java.util.Date;

/**
 * @ClassName FloorDto
 * @Description 工作流节点数据层封装
 * @Author wuxw
 * @Date 2019/4/24 8:52
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
public class WorkflowStepDto extends PageDto implements Serializable {

    private String stepId;
private String type;
private String communityId;
private String storeId;
private String flowId;
private String seq;


    private Date createTime;

    private String statusCd = "0";


    public String getStepId() {
        return stepId;
    }
public void setStepId(String stepId) {
        this.stepId = stepId;
    }
public String getType() {
        return type;
    }
public void setType(String type) {
        this.type = type;
    }
public String getCommunityId() {
        return communityId;
    }
public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }
public String getStoreId() {
        return storeId;
    }
public void setStoreId(String storeId) {
        this.storeId = storeId;
    }
public String getFlowId() {
        return flowId;
    }
public void setFlowId(String flowId) {
        this.flowId = flowId;
    }
public String getSeq() {
        return seq;
    }
public void setSeq(String seq) {
        this.seq = seq;
    }


    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getStatusCd() {
        return statusCd;
    }

    public void setStatusCd(String statusCd) {
        this.statusCd = statusCd;
    }
}

 java110-bean/src/main/java/com/java110/dto/workflow/WorkflowStepStaffDto.java

New file
@@ -0,0 +1,76 @@
package com.java110.dto.workflow;

import com.java110.dto.PageDto;
import java.io.Serializable;
import java.util.Date;

/**
 * @ClassName FloorDto
 * @Description 工作流节点数据层封装
 * @Author wuxw
 * @Date 2019/4/24 8:52
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
public class WorkflowStepStaffDto extends PageDto implements Serializable {

    private String wssId;
private String stepId;
private String staffName;
private String communityId;
private String staffId;


    private Date createTime;

    private String statusCd = "0";


    public String getWssId() {
        return wssId;
    }
public void setWssId(String wssId) {
        this.wssId = wssId;
    }
public String getStepId() {
        return stepId;
    }
public void setStepId(String stepId) {
        this.stepId = stepId;
    }
public String getStaffName() {
        return staffName;
    }
public void setStaffName(String staffName) {
        this.staffName = staffName;
    }
public String getCommunityId() {
        return communityId;
    }
public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }
public String getStaffId() {
        return staffId;
    }
public void setStaffId(String staffId) {
        this.staffId = staffId;
    }


    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getStatusCd() {
        return statusCd;
    }

    public void setStatusCd(String statusCd) {
        this.statusCd = statusCd;
    }
}

 java110-bean/src/main/java/com/java110/po/workflow/WorkflowPo.java

New file
@@ -0,0 +1,72 @@
package com.java110.po.workflow;

import java.io.Serializable;

public class WorkflowPo implements Serializable {

    private String skipLevel;
    private String describle;
    private String communityId;
    private String storeId;
    private String flowId;
    private String flowName;
    private String flowType;

    public String getSkipLevel() {
        return skipLevel;
    }

    public void setSkipLevel(String skipLevel) {
        this.skipLevel = skipLevel;
    }

    public String getDescrible() {
        return describle;
    }

    public void setDescrible(String describle) {
        this.describle = describle;
    }

    public String getCommunityId() {
        return communityId;
    }

    public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }

    public String getStoreId() {
        return storeId;
    }

    public void setStoreId(String storeId) {
        this.storeId = storeId;
    }

    public String getFlowId() {
        return flowId;
    }

    public void setFlowId(String flowId) {
        this.flowId = flowId;
    }

    public String getFlowName() {
        return flowName;
    }

    public void setFlowName(String flowName) {
        this.flowName = flowName;
    }

    public String getFlowType() {
        return flowType;
    }

    public void setFlowType(String flowType) {
        this.flowType = flowType;
    }


}

 java110-bean/src/main/java/com/java110/po/workflow/WorkflowStepPo.java

New file
@@ -0,0 +1,53 @@
package com.java110.po.workflow;

import java.io.Serializable;
import java.util.Date;

public class WorkflowStepPo implements Serializable {

    private String stepId;
private String type;
private String communityId;
private String storeId;
private String flowId;
private String seq;
public String getStepId() {
        return stepId;
    }
public void setStepId(String stepId) {
        this.stepId = stepId;
    }
public String getType() {
        return type;
    }
public void setType(String type) {
        this.type = type;
    }
public String getCommunityId() {
        return communityId;
    }
public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }
public String getStoreId() {
        return storeId;
    }
public void setStoreId(String storeId) {
        this.storeId = storeId;
    }
public String getFlowId() {
        return flowId;
    }
public void setFlowId(String flowId) {
        this.flowId = flowId;
    }
public String getSeq() {
        return seq;
    }
public void setSeq(String seq) {
        this.seq = seq;
    }



}

 java110-bean/src/main/java/com/java110/po/workflow/WorkflowStepStaffPo.java

New file
@@ -0,0 +1,46 @@
package com.java110.po.workflow;

import java.io.Serializable;
import java.util.Date;

public class WorkflowStepStaffPo implements Serializable {

    private String wssId;
private String stepId;
private String staffName;
private String communityId;
private String staffId;
public String getWssId() {
        return wssId;
    }
public void setWssId(String wssId) {
        this.wssId = wssId;
    }
public String getStepId() {
        return stepId;
    }
public void setStepId(String stepId) {
        this.stepId = stepId;
    }
public String getStaffName() {
        return staffName;
    }
public void setStaffName(String staffName) {
        this.staffName = staffName;
    }
public String getCommunityId() {
        return communityId;
    }
public void setCommunityId(String communityId) {
        this.communityId = communityId;
    }
public String getStaffId() {
        return staffId;
    }
public void setStaffId(String staffId) {
        this.staffId = staffId;
    }



}

 java110-core/src/main/java/com/java110/core/factory/GenerateCodeFactory.java

@@ -130,6 +130,8 @@
    public static final String CODE_PREFIX_oweId = "72";
    public static final String CODE_PREFIX_billId = "73";
    public static final String CODE_PREFIX_locationId = "74";
    public static final String CODE_PREFIX_flowId = "75";
    public static final String CODE_PREFIX_wssId = "76";




 java110-core/src/main/java/com/java110/core/smo/common/IWorkflowInnerServiceSMO.java

New file
@@ -0,0 +1,42 @@
package com.java110.core.smo.common;

import com.java110.core.feign.FeignConfiguration;
import com.java110.dto.workflow.WorkflowDto;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

/**
 * @ClassName IWorkflowInnerServiceSMO
 * @Description 工作流接口类
 * @Author wuxw
 * @Date 2019/4/24 9:04
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@FeignClient(name = "common-service", configuration = {FeignConfiguration.class})
@RequestMapping("/workflowApi")
public interface IWorkflowInnerServiceSMO {

    /**
     * <p>查询小区楼信息</p>
     *
     *
     * @param workflowDto 数据对象分享
     * @return WorkflowDto 对象数据
     */
    @RequestMapping(value = "/queryWorkflows", method = RequestMethod.POST)
    List<WorkflowDto> queryWorkflows(@RequestBody WorkflowDto workflowDto);

    /**
     * 查询<p>小区楼</p>总记录数
     *
     * @param workflowDto 数据对象分享
     * @return 小区下的小区楼记录数
     */
    @RequestMapping(value = "/queryWorkflowsCount", method = RequestMethod.POST)
    int queryWorkflowsCount(@RequestBody WorkflowDto workflowDto);
}

 java110-core/src/main/java/com/java110/core/smo/common/IWorkflowStepInnerServiceSMO.java

New file
@@ -0,0 +1,42 @@
package com.java110.core.smo.common;

import com.java110.core.feign.FeignConfiguration;
import com.java110.dto.workflow.WorkflowStepDto;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

/**
 * @ClassName IWorkflowStepInnerServiceSMO
 * @Description 工作流节点接口类
 * @Author wuxw
 * @Date 2019/4/24 9:04
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@FeignClient(name = "common-service", configuration = {FeignConfiguration.class})
@RequestMapping("/workflowStepApi")
public interface IWorkflowStepInnerServiceSMO {

    /**
     * <p>查询小区楼信息</p>
     *
     *
     * @param workflowStepDto 数据对象分享
     * @return WorkflowStepDto 对象数据
     */
    @RequestMapping(value = "/queryWorkflowSteps", method = RequestMethod.POST)
    List<WorkflowStepDto> queryWorkflowSteps(@RequestBody WorkflowStepDto workflowStepDto);

    /**
     * 查询<p>小区楼</p>总记录数
     *
     * @param workflowStepDto 数据对象分享
     * @return 小区下的小区楼记录数
     */
    @RequestMapping(value = "/queryWorkflowStepsCount", method = RequestMethod.POST)
    int queryWorkflowStepsCount(@RequestBody WorkflowStepDto workflowStepDto);
}

 java110-core/src/main/java/com/java110/core/smo/common/IWorkflowStepStaffInnerServiceSMO.java

New file
@@ -0,0 +1,42 @@
package com.java110.core.smo.common;

import com.java110.core.feign.FeignConfiguration;
import com.java110.dto.workflow.WorkflowStepStaffDto;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

/**
 * @ClassName IWorkflowStepStaffInnerServiceSMO
 * @Description 工作流节点接口类
 * @Author wuxw
 * @Date 2019/4/24 9:04
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@FeignClient(name = "common-service", configuration = {FeignConfiguration.class})
@RequestMapping("/workflowStepStaffApi")
public interface IWorkflowStepStaffInnerServiceSMO {

    /**
     * <p>查询小区楼信息</p>
     *
     *
     * @param workflowStepStaffDto 数据对象分享
     * @return WorkflowStepStaffDto 对象数据
     */
    @RequestMapping(value = "/queryWorkflowStepStaffs", method = RequestMethod.POST)
    List<WorkflowStepStaffDto> queryWorkflowStepStaffs(@RequestBody WorkflowStepStaffDto workflowStepStaffDto);

    /**
     * 查询<p>小区楼</p>总记录数
     *
     * @param workflowStepStaffDto 数据对象分享
     * @return 小区下的小区楼记录数
     */
    @RequestMapping(value = "/queryWorkflowStepStaffsCount", method = RequestMethod.POST)
    int queryWorkflowStepStaffsCount(@RequestBody WorkflowStepStaffDto workflowStepStaffDto);
}

 java110-db/src/main/resources/mapper/common/WorkflowServiceDaoImplMapper.xml

New file
@@ -0,0 +1,202 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="workflowServiceDaoImpl">

    <!-- 保存工作流信息 add by wuxw 2018-07-03 -->
    <insert id="saveBusinessWorkflowInfo" parameterType="Map">
        insert into business_workflow(
        skip_level,operate,describle,b_id,community_id,store_id,flow_id,flow_name,flow_type
        ) values (
        #{skipLevel},#{operate},#{describle},#{bId},#{communityId},#{storeId},#{flowId},#{flowName},#{flowType}
        )
    </insert>


    <!-- 查询工作流信息（Business） add by wuxw 2018-07-03 -->
    <select id="getBusinessWorkflowInfo" parameterType="Map" resultType="Map">
        select t.skip_level,t.skip_level skipLevel,t.operate,t.describle,t.b_id,t.b_id bId,t.community_id,t.community_id
        communityId,t.store_id,t.store_id storeId,t.flow_id,t.flow_id flowId,t.flow_name,t.flow_name
        flowName,t.flow_type,t.flow_type flowType
        from business_workflow t
        where 1 =1
        <if test="skipLevel !=null and skipLevel != ''">
            and t.skip_level= #{skipLevel}
        </if>
        <if test="operate !=null and operate != ''">
            and t.operate= #{operate}
        </if>
        <if test="describle !=null and describle != ''">
            and t.describle= #{describle}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="flowName !=null and flowName != ''">
            and t.flow_name= #{flowName}
        </if>
        <if test="flowType !=null and flowType != ''">
            and t.flow_type= #{flowType}
        </if>

    </select>


    <!-- 保存工作流信息至 instance表中 add by wuxw 2018-07-03 -->
    <insert id="saveWorkflowInfoInstance" parameterType="Map">
        insert into workflow(
        skip_level,describle,status_cd,b_id,community_id,store_id,flow_id,flow_name,flow_type
        ) select t.skip_level,t.describle,'0',t.b_id,t.community_id,t.store_id,t.flow_id,t.flow_name,t.flow_type from
        business_workflow t where 1=1
        <if test="skipLevel !=null and skipLevel != ''">
            and t.skip_level= #{skipLevel}
        </if>
        and t.operate= 'ADD'
        <if test="describle !=null and describle != ''">
            and t.describle= #{describle}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="flowName !=null and flowName != ''">
            and t.flow_name= #{flowName}
        </if>
        <if test="flowType !=null and flowType != ''">
            and t.flow_type= #{flowType}
        </if>

    </insert>


    <!-- 查询工作流信息 add by wuxw 2018-07-03 -->
    <select id="getWorkflowInfo" parameterType="Map" resultType="Map">
        select t.skip_level,t.skip_level skipLevel,t.describle,t.status_cd,t.status_cd statusCd,t.b_id,t.b_id
        bId,t.community_id,t.community_id communityId,t.store_id,t.store_id storeId,t.flow_id,t.flow_id
        flowId,t.flow_name,t.flow_name flowName,t.flow_type,t.flow_type flowType
        from workflow t
        where 1 =1
        <if test="skipLevel !=null and skipLevel != ''">
            and t.skip_level= #{skipLevel}
        </if>
        <if test="describle !=null and describle != ''">
            and t.describle= #{describle}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="flowName !=null and flowName != ''">
            and t.flow_name= #{flowName}
        </if>
        <if test="flowType !=null and flowType != ''">
            and t.flow_type= #{flowType}
        </if>
        order by t.create_time desc
        <if test="page != -1 and page != null ">
            limit #{page}, #{row}
        </if>

    </select>


    <!-- 修改工作流信息 add by wuxw 2018-07-03 -->
    <update id="updateWorkflowInfoInstance" parameterType="Map">
        update workflow t set t.status_cd = #{statusCd}
        <if test="newBId != null and newBId != ''">
            ,t.b_id = #{newBId}
        </if>
        <if test="skipLevel !=null and skipLevel != ''">
            , t.skip_level= #{skipLevel}
        </if>
        <if test="describle !=null and describle != ''">
            , t.describle= #{describle}
        </if>
        <if test="communityId !=null and communityId != ''">
            , t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            , t.store_id= #{storeId}
        </if>
        <if test="flowName !=null and flowName != ''">
            , t.flow_name= #{flowName}
        </if>
        <if test="flowType !=null and flowType != ''">
            , t.flow_type= #{flowType}
        </if>
        where 1=1
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>

    </update>

    <!-- 查询工作流数量 add by wuxw 2018-07-03 -->
    <select id="queryWorkflowsCount" parameterType="Map" resultType="Map">
        select count(1) count
        from workflow t
        where 1 =1
        <if test="skipLevel !=null and skipLevel != ''">
            and t.skip_level= #{skipLevel}
        </if>
        <if test="describle !=null and describle != ''">
            and t.describle= #{describle}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="flowName !=null and flowName != ''">
            and t.flow_name= #{flowName}
        </if>
        <if test="flowType !=null and flowType != ''">
            and t.flow_type= #{flowType}
        </if>


    </select>

</mapper>

 java110-db/src/main/resources/mapper/common/WorkflowStepServiceDaoImplMapper.xml

New file
@@ -0,0 +1,186 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="workflowStepServiceDaoImpl">

    <!-- 保存工作流节点信息 add by wuxw 2018-07-03 -->
    <insert id="saveBusinessWorkflowStepInfo" parameterType="Map">
        insert into business_workflow_step(
        operate,step_id,b_id,type,community_id,store_id,flow_id,seq
        ) values (
        #{operate},#{stepId},#{bId},#{type},#{communityId},#{storeId},#{flowId},#{seq}
        )
    </insert>


    <!-- 查询工作流节点信息（Business） add by wuxw 2018-07-03 -->
    <select id="getBusinessWorkflowStepInfo" parameterType="Map" resultType="Map">
        select t.operate,t.step_id,t.step_id stepId,t.b_id,t.b_id bId,t.type,t.community_id,t.community_id
        communityId,t.store_id,t.store_id storeId,t.flow_id,t.flow_id flowId,t.seq
        from business_workflow_step t
        where 1 =1
        <if test="operate !=null and operate != ''">
            and t.operate= #{operate}
        </if>
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="type !=null and type != ''">
            and t.type= #{type}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="seq !=null and seq != ''">
            and t.seq= #{seq}
        </if>

    </select>


    <!-- 保存工作流节点信息至 instance表中 add by wuxw 2018-07-03 -->
    <insert id="saveWorkflowStepInfoInstance" parameterType="Map">
        insert into workflow_step(
        step_id,status_cd,b_id,type,community_id,store_id,flow_id,seq
        ) select t.step_id,'0',t.b_id,t.type,t.community_id,t.store_id,t.flow_id,t.seq from business_workflow_step t
        where 1=1
        and t.operate= 'ADD'
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="type !=null and type != ''">
            and t.type= #{type}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="seq !=null and seq != ''">
            and t.seq= #{seq}
        </if>

    </insert>


    <!-- 查询工作流节点信息 add by wuxw 2018-07-03 -->
    <select id="getWorkflowStepInfo" parameterType="Map" resultType="Map">
        select t.step_id,t.step_id stepId,t.status_cd,t.status_cd statusCd,t.b_id,t.b_id
        bId,t.type,t.community_id,t.community_id communityId,t.store_id,t.store_id storeId,t.flow_id,t.flow_id
        flowId,t.seq
        from workflow_step t
        where 1 =1
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="type !=null and type != ''">
            and t.type= #{type}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="seq !=null and seq != ''">
            and t.seq= #{seq}
        </if>
        order by t.create_time desc
        <if test="page != -1 and page != null ">
            limit #{page}, #{row}
        </if>

    </select>


    <!-- 修改工作流节点信息 add by wuxw 2018-07-03 -->
    <update id="updateWorkflowStepInfoInstance" parameterType="Map">
        update workflow_step t set t.status_cd = #{statusCd}
        <if test="newBId != null and newBId != ''">
            ,t.b_id = #{newBId}
        </if>
        <if test="stepId !=null and stepId != ''">
            , t.step_id= #{stepId}
        </if>
        <if test="type !=null and type != ''">
            , t.type= #{type}
        </if>
        <if test="communityId !=null and communityId != ''">
            , t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            , t.store_id= #{storeId}
        </if>
        <if test="seq !=null and seq != ''">
            , t.seq= #{seq}
        </if>
        where 1=1
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>

    </update>

    <!-- 查询工作流节点数量 add by wuxw 2018-07-03 -->
    <select id="queryWorkflowStepsCount" parameterType="Map" resultType="Map">
        select count(1) count
        from workflow_step t
        where 1 =1
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="type !=null and type != ''">
            and t.type= #{type}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="storeId !=null and storeId != ''">
            and t.store_id= #{storeId}
        </if>
        <if test="flowId !=null and flowId != ''">
            and t.flow_id= #{flowId}
        </if>
        <if test="seq !=null and seq != ''">
            and t.seq= #{seq}
        </if>


    </select>

</mapper>

 java110-db/src/main/resources/mapper/common/WorkflowStepStaffServiceDaoImplMapper.xml

New file
@@ -0,0 +1,171 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="workflowStepStaffServiceDaoImpl">

    <!-- 保存工作流节点信息 add by wuxw 2018-07-03 -->
    <insert id="saveBusinessWorkflowStepStaffInfo" parameterType="Map">
        insert into business_workflow_step_staff(
        wss_id,operate,step_id,staff_name,b_id,community_id,staff_id
        ) values (
        #{wssId},#{operate},#{stepId},#{staffName},#{bId},#{communityId},#{staffId}
        )
    </insert>


    <!-- 查询工作流节点信息（Business） add by wuxw 2018-07-03 -->
    <select id="getBusinessWorkflowStepStaffInfo" parameterType="Map" resultType="Map">
        select t.wss_id,t.wss_id wssId,t.operate,t.step_id,t.step_id stepId,t.staff_name,t.staff_name
        staffName,t.b_id,t.b_id bId,t.community_id,t.community_id communityId,t.staff_id,t.staff_id staffId
        from business_workflow_step_staff t
        where 1 =1
        <if test="wssId !=null and wssId != ''">
            and t.wss_id= #{wssId}
        </if>
        <if test="operate !=null and operate != ''">
            and t.operate= #{operate}
        </if>
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="staffName !=null and staffName != ''">
            and t.staff_name= #{staffName}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="staffId !=null and staffId != ''">
            and t.staff_id= #{staffId}
        </if>

    </select>


    <!-- 保存工作流节点信息至 instance表中 add by wuxw 2018-07-03 -->
    <insert id="saveWorkflowStepStaffInfoInstance" parameterType="Map">
        insert into workflow_step_staff(
        wss_id,step_id,staff_name,status_cd,b_id,community_id,staff_id
        ) select t.wss_id,t.step_id,t.staff_name,'0',t.b_id,t.community_id,t.staff_id from business_workflow_step_staff
        t where 1=1
        <if test="wssId !=null and wssId != ''">
            and t.wss_id= #{wssId}
        </if>
        and t.operate= 'ADD'
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="staffName !=null and staffName != ''">
            and t.staff_name= #{staffName}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="staffId !=null and staffId != ''">
            and t.staff_id= #{staffId}
        </if>

    </insert>


    <!-- 查询工作流节点信息 add by wuxw 2018-07-03 -->
    <select id="getWorkflowStepStaffInfo" parameterType="Map" resultType="Map">
        select t.wss_id,t.wss_id wssId,t.step_id,t.step_id stepId,t.staff_name,t.staff_name
        staffName,t.status_cd,t.status_cd statusCd,t.b_id,t.b_id bId,t.community_id,t.community_id
        communityId,t.staff_id,t.staff_id staffId
        from workflow_step_staff t
        where 1 =1
        <if test="wssId !=null and wssId != ''">
            and t.wss_id= #{wssId}
        </if>
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="staffName !=null and staffName != ''">
            and t.staff_name= #{staffName}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="staffId !=null and staffId != ''">
            and t.staff_id= #{staffId}
        </if>
        order by t.create_time desc
        <if test="page != -1 and page != null ">
            limit #{page}, #{row}
        </if>

    </select>


    <!-- 修改工作流节点信息 add by wuxw 2018-07-03 -->
    <update id="updateWorkflowStepStaffInfoInstance" parameterType="Map">
        update workflow_step_staff t set t.status_cd = #{statusCd}
        <if test="newBId != null and newBId != ''">
            ,t.b_id = #{newBId}
        </if>
        <if test="stepId !=null and stepId != ''">
            , t.step_id= #{stepId}
        </if>
        <if test="staffName !=null and staffName != ''">
            , t.staff_name= #{staffName}
        </if>
        <if test="communityId !=null and communityId != ''">
            , t.community_id= #{communityId}
        </if>
        <if test="staffId !=null and staffId != ''">
            , t.staff_id= #{staffId}
        </if>
        where 1=1
        <if test="wssId !=null and wssId != ''">
            and t.wss_id= #{wssId}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>

    </update>

    <!-- 查询工作流节点数量 add by wuxw 2018-07-03 -->
    <select id="queryWorkflowStepStaffsCount" parameterType="Map" resultType="Map">
        select count(1) count
        from workflow_step_staff t
        where 1 =1
        <if test="wssId !=null and wssId != ''">
            and t.wss_id= #{wssId}
        </if>
        <if test="stepId !=null and stepId != ''">
            and t.step_id= #{stepId}
        </if>
        <if test="staffName !=null and staffName != ''">
            and t.staff_name= #{staffName}
        </if>
        <if test="statusCd !=null and statusCd != ''">
            and t.status_cd= #{statusCd}
        </if>
        <if test="bId !=null and bId != ''">
            and t.b_id= #{bId}
        </if>
        <if test="communityId !=null and communityId != ''">
            and t.community_id= #{communityId}
        </if>
        <if test="staffId !=null and staffId != ''">
            and t.staff_id= #{staffId}
        </if>


    </select>

</mapper>

 java110-generator/src/main/resources/back/template_1.json

@@ -1,36 +1,41 @@
{
  "autoMove": true,
  "id": "attrId",
  "name": "userAttr",
  "desc": "用户属性",
  "shareParam": "userId",
  "shareColumn": "user_id",
  "shareName": "user",
  "newBusinessTypeCd": "BUSINESS_TYPE_SAVE_USER_ATTR_INFO",
  "updateBusinessTypeCd": "BUSINESS_TYPE_UPDATE_USER_ATTR_INFO",
  "deleteBusinessTypeCd": "BUSINESS_TYPE_DELETE_USER_ATTR_INFO",
  "newBusinessTypeCdValue": "100200030001",
  "updateBusinessTypeCdValue": "100200040001",
  "deleteBusinessTypeCdValue": "100200050001",
  "businessTableName": "business_user_attr",
  "tableName": "u_user_attr",
  "id": "wssId",
  "name": "workflowStepStaff",
  "desc": "工作流节点",
  "shareParam": "communityId",
  "shareColumn": "community_id",
  "shareName": "common",
  "newBusinessTypeCd": "BUSINESS_TYPE_SAVE_WORKFLOW_STEP_STAFF",
  "updateBusinessTypeCd": "BUSINESS_TYPE_UPDATE_WORKFLOW_STEP_STAFF",
  "deleteBusinessTypeCd": "BUSINESS_TYPE_DELETE_WORKFLOW_STEP_STAFF",
  "newBusinessTypeCdValue": "580300030001",
  "updateBusinessTypeCdValue": "580300040001",
  "deleteBusinessTypeCdValue": "580300050001",
  "businessTableName": "business_workflow_step_staff",
  "tableName": "workflow_step_staff",
  "param": {
    "attrId": "attr_id",
    "wssId": "wss_id",
    "stepId": "step_id",
    "bId": "b_id",
    "userId": "user_id",
    "specCd": "spec_cd",
    "value": "value",
    "staffId": "staff_id",
    "staffName": "staff_name",
    "communityId": "community_id",
    "statusCd": "status_cd",
    "operate": "operate"
  },
  "required": [
    {
      "code": "userId",
      "msg": "用户ID不能为空"
      "code": "staffId",
      "msg": "员工不能为空"
    },
    {
      "code": "specCd",
      "msg": "用户属性不能为空"
      "code": "communityId",
      "msg": "小区不能为空"
    },
    {
      "code": "staffName",
      "msg": "员工名称不能为空"
    }
  ]
}

 java110-generator/src/main/resources/back/template_user_attr.json

New file
@@ -0,0 +1,37 @@
{
  "autoMove": true,
  "id": "attrId",
  "name": "userAttr",
  "desc": "用户属性",
  "shareParam": "userId",
  "shareColumn": "user_id",
  "shareName": "user",
  "newBusinessTypeCd": "BUSINESS_TYPE_SAVE_USER_ATTR_INFO",
  "updateBusinessTypeCd": "BUSINESS_TYPE_UPDATE_USER_ATTR_INFO",
  "deleteBusinessTypeCd": "BUSINESS_TYPE_DELETE_USER_ATTR_INFO",
  "newBusinessTypeCdValue": "100200030001",
  "updateBusinessTypeCdValue": "100200040001",
  "deleteBusinessTypeCdValue": "100200050001",
  "businessTableName": "business_user_attr",
  "tableName": "u_user_attr",
  "param": {
    "attrId": "attr_id",
    "bId": "b_id",
    "userId": "user_id",
    "specCd": "spec_cd",
    "value": "value",
    "statusCd": "status_cd",
    "operate": "operate"
  },
  "required": [
    {
      "code": "userId",
      "msg": "用户ID不能为空"
    },
    {
      "code": "specCd",
      "msg": "用户属性不能为空"
    }
  ]
}


 java110-generator/src/main/resources/back/template_workflow.json

New file
@@ -0,0 +1,48 @@
{
  "autoMove": true,
  "id": "flowId",
  "name": "workflow",
  "desc": "工作流",
  "shareParam": "communityId",
  "shareColumn": "community_id",
  "shareName": "common",
  "newBusinessTypeCd": "BUSINESS_TYPE_SAVE_WORKFLOW",
  "updateBusinessTypeCd": "BUSINESS_TYPE_UPDATE_WORKFLOW",
  "deleteBusinessTypeCd": "BUSINESS_TYPE_DELETE_WORKFLOW",
  "newBusinessTypeCdValue": "580100030001",
  "updateBusinessTypeCdValue": "580100040001",
  "deleteBusinessTypeCdValue": "580100050001",
  "businessTableName": "business_workflow",
  "tableName": "workflow",
  "param": {
    "flowId": "flow_id",
    "bId": "b_id",
    "flowName": "flow_name",
    "describle": "describle",
    "skipLevel": "skip_level",
    "communityId": "community_id",
    "storeId": "store_id",
    "flowType": "flow_type",
    "statusCd": "status_cd",
    "operate": "operate"
  },
  "required": [
    {
      "code": "flowName",
      "msg": "流程名称不能为空"
    },
    {
      "code": "communityId",
      "msg": "小区不能为空"
    },
    {
      "code": "flowType",
      "msg": "流程类型不能为空"
    },
    {
      "code": "storeId",
      "msg": "商户ID不能为空"
    }
  ]
}


 java110-generator/src/main/resources/back/template_workflow_step.json

New file
@@ -0,0 +1,43 @@
{
  "autoMove": true,
  "id": "flowId",
  "name": "workflowStep",
  "desc": "工作流节点",
  "shareParam": "communityId",
  "shareColumn": "community_id",
  "shareName": "common",
  "newBusinessTypeCd": "BUSINESS_TYPE_SAVE_WORKFLOW_STEP",
  "updateBusinessTypeCd": "BUSINESS_TYPE_UPDATE_WORKFLOW_STEP",
  "deleteBusinessTypeCd": "BUSINESS_TYPE_DELETE_WORKFLOW_STEP",
  "newBusinessTypeCdValue": "580200030001",
  "updateBusinessTypeCdValue": "580200040001",
  "deleteBusinessTypeCdValue": "580200050001",
  "businessTableName": "business_workflow_step",
  "tableName": "workflow_step",
  "param": {
    "flowId": "flow_id",
    "stepId": "step_id",
    "bId": "b_id",
    "type": "type",
    "seq": "seq",
    "communityId": "community_id",
    "storeId": "store_id",
    "statusCd": "status_cd",
    "operate": "operate"
  },
  "required": [
    {
      "code": "type",
      "msg": "节点类型不能为空"
    },
    {
      "code": "communityId",
      "msg": "小区不能为空"
    },
    {
      "code": "storeId",
      "msg": "商户ID不能为空"
    }
  ]
}


 java110-utils/src/main/java/com/java110/utils/constant/BusinessTypeConstant.java

@@ -1086,5 +1086,59 @@
     */
    public static final String BUSINESS_TYPE_DELETE_LOCATION="570100050001";

    /**
     *  保存工作流
     *  3保存
     */
    public static final String BUSINESS_TYPE_SAVE_WORKFLOW="580100030001";


    /**
     *  修改工作流
     *  3保存
     */
    public static final String BUSINESS_TYPE_UPDATE_WORKFLOW="580100040001";

    /**
     * 删除工作流
     */
    public static final String BUSINESS_TYPE_DELETE_WORKFLOW="580100050001";

    /**
     *  保存工作流节点
     *  3保存
     */
    public static final String BUSINESS_TYPE_SAVE_WORKFLOW_STEP="580200030001";


    /**
     *  修改工作流节点
     *  3保存
     */
    public static final String BUSINESS_TYPE_UPDATE_WORKFLOW_STEP="580200040001";

    /**
     * 删除工作流节点
     */
    public static final String BUSINESS_TYPE_DELETE_WORKFLOW_STEP="580200050001";

    /**
     *  保存工作流节点 处理员工
     *  3保存
     */
    public static final String BUSINESS_TYPE_SAVE_WORKFLOW_STEP_STAFF="580300030001";


    /**
     *  修改工作流节点 处理员工
     *  3保存
     */
    public static final String BUSINESS_TYPE_UPDATE_WORKFLOW_STEP_STAFF="580300040001";

    /**
     * 删除工作流节点 处理员工
     */
    public static final String BUSINESS_TYPE_DELETE_WORKFLOW_STEP_STAFF="580300050001";


}

 java110-utils/src/main/java/com/java110/utils/constant/ServiceCodeWorkflowConstant.java

New file
@@ -0,0 +1,31 @@
package com.java110.utils.constant;

/**
 * 工作流常量类
 * Created by wuxw on 2017/5/20.
 */
public class ServiceCodeWorkflowConstant {

    /**
     * 添加 工作流
     */
    public static final String ADD_WORKFLOW = "workflow.saveWorkflow";


    /**
     * 修改 工作流
     */
    public static final String UPDATE_WORKFLOW = "workflow.updateWorkflow";
    /**
     * 删除 工作流
     */
    public static final String DELETE_WORKFLOW = "workflow.deleteWorkflow";


    /**
     * 查询 工作流
     */
    public static final String LIST_WORKFLOWS = "workflow.listWorkflows";


}

 java110-utils/src/main/java/com/java110/utils/constant/ServiceCodeWorkflowStepConstant.java

New file
@@ -0,0 +1,31 @@
package com.java110.utils.constant;

/**
 * 工作流节点常量类
 * Created by wuxw on 2017/5/20.
 */
public class ServiceCodeWorkflowStepConstant {

    /**
     * 添加 工作流节点
     */
    public static final String ADD_WORKFLOWSTEP = "workflow.saveWorkflowStep";


    /**
     * 修改 工作流节点
     */
    public static final String UPDATE_WORKFLOWSTEP = "workflow.updateWorkflowStep";
    /**
     * 删除 工作流节点
     */
    public static final String DELETE_WORKFLOWSTEP = "workflow.deleteWorkflowStep";


    /**
     * 查询 工作流节点
     */
    public static final String LIST_WORKFLOWSTEPS = "workflow.listWorkflowSteps";


}

 java110-utils/src/main/java/com/java110/utils/constant/ServiceCodeWorkflowStepStaffConstant.java

New file
@@ -0,0 +1,31 @@
package com.java110.utils.constant;

/**
 * 工作流节点常量类
 * Created by wuxw on 2017/5/20.
 */
public class ServiceCodeWorkflowStepStaffConstant {

    /**
     * 添加 工作流节点
     */
    public static final String ADD_WORKFLOWSTEPSTAFF = "workflow.saveWorkflowStepStaff";


    /**
     * 修改 工作流节点
     */
    public static final String UPDATE_WORKFLOWSTEPSTAFF = "workflow.updateWorkflowStepStaff";
    /**
     * 删除 工作流节点
     */
    public static final String DELETE_WORKFLOWSTEPSTAFF = "workflow.deleteWorkflowStepStaff";


    /**
     * 查询 工作流节点
     */
    public static final String LIST_WORKFLOWSTEPSTAFFS = "workflow.listWorkflowStepStaffs";


}

 service-api/src/main/java/com/java110/api/bmo/workflow/IWorkflowBMO.java

New file
@@ -0,0 +1,38 @@
package com.java110.api.bmo.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.IApiBaseBMO;
import com.java110.core.context.DataFlowContext;

public interface IWorkflowBMO extends IApiBaseBMO {


    /**
     * 添加工作流
     * @param paramInJson
     * @param dataFlowContext
     * @return
     */
     void addWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 添加工作流信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void updateWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 删除工作流
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void deleteWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext);



}

 service-api/src/main/java/com/java110/api/bmo/workflow/IWorkflowStepBMO.java

New file
@@ -0,0 +1,38 @@
package com.java110.api.bmo.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.IApiBaseBMO;
import com.java110.core.context.DataFlowContext;

public interface IWorkflowStepBMO extends IApiBaseBMO {


    /**
     * 添加工作流节点
     * @param paramInJson
     * @param dataFlowContext
     * @return
     */
     void addWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 添加工作流节点信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void updateWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 删除工作流节点
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void deleteWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext);



}

 service-api/src/main/java/com/java110/api/bmo/workflow/IWorkflowStepStaffBMO.java

New file
@@ -0,0 +1,38 @@
package com.java110.api.bmo.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.IApiBaseBMO;
import com.java110.core.context.DataFlowContext;

public interface IWorkflowStepStaffBMO extends IApiBaseBMO {


    /**
     * 添加工作流节点
     * @param paramInJson
     * @param dataFlowContext
     * @return
     */
     void addWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 添加工作流节点信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void updateWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext);

    /**
     * 删除工作流节点
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
     void deleteWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext);



}

 service-api/src/main/java/com/java110/api/bmo/workflow/impl/WorkflowBMOImpl.java

New file
@@ -0,0 +1,61 @@
package com.java110.api.bmo.workflow.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.ApiBaseBMO;
import com.java110.api.bmo.workflow.IWorkflowBMO;
import com.java110.core.context.DataFlowContext;
import com.java110.core.smo.common.IWorkflowInnerServiceSMO;
import com.java110.po.workflow.WorkflowPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.util.BeanConvertUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("workflowBMOImpl")
public class WorkflowBMOImpl extends ApiBaseBMO implements IWorkflowBMO {

    @Autowired
    private IWorkflowInnerServiceSMO workflowInnerServiceSMOImpl;

    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void addWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        paramInJson.put("flowId", "-1");
        WorkflowPo workflowPo = BeanConvertUtil.covertBean(paramInJson, WorkflowPo.class);
        super.insert(dataFlowContext, workflowPo, BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW);
    }


    /**
     * 添加活动信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void updateWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext) {
        WorkflowPo workflowPo = BeanConvertUtil.covertBean(paramInJson, WorkflowPo.class);
        super.update(dataFlowContext, workflowPo, BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW);
    }


    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void deleteWorkflow(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        WorkflowPo workflowPo = BeanConvertUtil.covertBean(paramInJson, WorkflowPo.class);
        super.update(dataFlowContext, workflowPo, BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW);
    }

}

 service-api/src/main/java/com/java110/api/bmo/workflow/impl/WorkflowStepBMOImpl.java

New file
@@ -0,0 +1,62 @@
package com.java110.api.bmo.workflow.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.ApiBaseBMO;
import com.java110.api.bmo.workflow.IWorkflowStepBMO;
import com.java110.core.context.DataFlowContext;
import com.java110.core.smo.common.IWorkflowStepInnerServiceSMO;
import com.java110.po.workflow.WorkflowStepPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.util.BeanConvertUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("workflowStepBMOImpl")
public class WorkflowStepBMOImpl extends ApiBaseBMO implements IWorkflowStepBMO {

    @Autowired
    private IWorkflowStepInnerServiceSMO workflowStepInnerServiceSMOImpl;

    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void addWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        paramInJson.put("flowId", "-1");
        WorkflowStepPo workflowStepPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepPo.class);
        super.insert(dataFlowContext, workflowStepPo, BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP);
    }


    /**
     * 添加活动信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void updateWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext) {
        WorkflowStepPo workflowStepPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepPo.class);
        super.update(dataFlowContext, workflowStepPo, BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP);
    }



    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void deleteWorkflowStep(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        WorkflowStepPo workflowStepPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepPo.class);
        super.update(dataFlowContext, workflowStepPo, BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP);
    }

}

 service-api/src/main/java/com/java110/api/bmo/workflow/impl/WorkflowStepStaffBMOImpl.java

New file
@@ -0,0 +1,62 @@
package com.java110.api.bmo.workflow.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.ApiBaseBMO;
import com.java110.api.bmo.workflow.IWorkflowStepStaffBMO;
import com.java110.core.context.DataFlowContext;
import com.java110.core.smo.common.IWorkflowStepStaffInnerServiceSMO;
import com.java110.po.workflow.WorkflowStepStaffPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.util.BeanConvertUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("workflowStepStaffBMOImpl")
public class WorkflowStepStaffBMOImpl extends ApiBaseBMO implements IWorkflowStepStaffBMO {

    @Autowired
    private IWorkflowStepStaffInnerServiceSMO workflowStepStaffInnerServiceSMOImpl;

    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void addWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        paramInJson.put("wssId", "-1");
        WorkflowStepStaffPo workflowStepStaffPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepStaffPo.class);
        super.insert(dataFlowContext, workflowStepStaffPo, BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP_STAFF);
    }


    /**
     * 添加活动信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void updateWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext) {
        WorkflowStepStaffPo workflowStepStaffPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepStaffPo.class);
        super.update(dataFlowContext, workflowStepStaffPo, BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP_STAFF);
    }



    /**
     * 添加小区信息
     *
     * @param paramInJson     接口调用放传入入参
     * @param dataFlowContext 数据上下文
     * @return 订单服务能够接受的报文
     */
    public void deleteWorkflowStepStaff(JSONObject paramInJson, DataFlowContext dataFlowContext) {

        WorkflowStepStaffPo workflowStepStaffPo = BeanConvertUtil.covertBean(paramInJson, WorkflowStepStaffPo.class);
        super.update(dataFlowContext, workflowStepStaffPo, BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP_STAFF);
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/DeleteWorkflowListener.java

New file
@@ -0,0 +1,49 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;


/**
 * 保存小区侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("deleteWorkflowListener")
public class DeleteWorkflowListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowBMO workflowBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "flowId", "flowId不能为空");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowBMOImpl.deleteWorkflow(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowConstant.DELETE_WORKFLOW;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/DeleteWorkflowStepListener.java

New file
@@ -0,0 +1,49 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;


/**
 * 保存小区侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("deleteWorkflowStepListener")
public class DeleteWorkflowStepListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepBMO workflowStepBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "flowId", "flowId不能为空");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowStepBMOImpl.deleteWorkflowStep(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepConstant.DELETE_WORKFLOWSTEP;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/DeleteWorkflowStepStaffListener.java

New file
@@ -0,0 +1,49 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepStaffBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepStaffConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;


/**
 * 保存小区侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("deleteWorkflowStepStaffListener")
public class DeleteWorkflowStepStaffListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepStaffBMO workflowStepStaffBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "wssId", "wssId不能为空");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowStepStaffBMOImpl.deleteWorkflowStepStaff(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepStaffConstant.DELETE_WORKFLOWSTEPSTAFF;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/ListWorkflowStepStaffsListener.java

New file
@@ -0,0 +1,82 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.listener.AbstractServiceApiListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.core.smo.common.IWorkflowStepStaffInnerServiceSMO;
import com.java110.dto.workflow.WorkflowStepStaffDto;
import com.java110.utils.constant.ServiceCodeWorkflowStepStaffConstant;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.vo.ResultVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import java.util.ArrayList;
import java.util.List;

/**
 * 查询小区侦听类
 */
@Java110Listener("listWorkflowStepStaffsListener")
public class ListWorkflowStepStaffsListener extends AbstractServiceApiListener {

    @Autowired
    private IWorkflowStepStaffInnerServiceSMO workflowStepStaffInnerServiceSMOImpl;

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepStaffConstant.LIST_WORKFLOWSTEPSTAFFS;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.GET;
    }


    @Override
    public int getOrder() {
        return DEFAULT_ORDER;
    }


    public IWorkflowStepStaffInnerServiceSMO getWorkflowStepStaffInnerServiceSMOImpl() {
        return workflowStepStaffInnerServiceSMOImpl;
    }

    public void setWorkflowStepStaffInnerServiceSMOImpl(IWorkflowStepStaffInnerServiceSMO workflowStepStaffInnerServiceSMOImpl) {
        this.workflowStepStaffInnerServiceSMOImpl = workflowStepStaffInnerServiceSMOImpl;
    }

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        super.validatePageInfo(reqJson);
    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        WorkflowStepStaffDto workflowStepStaffDto = BeanConvertUtil.covertBean(reqJson, WorkflowStepStaffDto.class);

        int count = workflowStepStaffInnerServiceSMOImpl.queryWorkflowStepStaffsCount(workflowStepStaffDto);

        List<WorkflowStepStaffDto> workflowStepStaffDtos = null;

        if (count > 0) {
            workflowStepStaffDtos = workflowStepStaffInnerServiceSMOImpl.queryWorkflowStepStaffs(workflowStepStaffDto);
        } else {
            workflowStepStaffDtos = new ArrayList<>();
        }

        ResultVo resultVo = new ResultVo((int) Math.ceil((double) count / (double) reqJson.getInteger("row")), count, workflowStepStaffDtos);

        ResponseEntity<String> responseEntity = new ResponseEntity<String>(resultVo.toString(), HttpStatus.OK);

        context.setResponseEntity(responseEntity);

    }
}

 service-api/src/main/java/com/java110/api/listener/workflow/ListWorkflowStepsListener.java

New file
@@ -0,0 +1,82 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.listener.AbstractServiceApiListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.core.smo.common.IWorkflowStepInnerServiceSMO;
import com.java110.dto.workflow.WorkflowStepDto;
import com.java110.utils.constant.ServiceCodeWorkflowStepConstant;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.vo.ResultVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import java.util.ArrayList;
import java.util.List;

/**
 * 查询小区侦听类
 */
@Java110Listener("listWorkflowStepsListener")
public class ListWorkflowStepsListener extends AbstractServiceApiListener {

    @Autowired
    private IWorkflowStepInnerServiceSMO workflowStepInnerServiceSMOImpl;

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepConstant.LIST_WORKFLOWSTEPS;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.GET;
    }


    @Override
    public int getOrder() {
        return DEFAULT_ORDER;
    }


    public IWorkflowStepInnerServiceSMO getWorkflowStepInnerServiceSMOImpl() {
        return workflowStepInnerServiceSMOImpl;
    }

    public void setWorkflowStepInnerServiceSMOImpl(IWorkflowStepInnerServiceSMO workflowStepInnerServiceSMOImpl) {
        this.workflowStepInnerServiceSMOImpl = workflowStepInnerServiceSMOImpl;
    }

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        super.validatePageInfo(reqJson);
    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        WorkflowStepDto workflowStepDto = BeanConvertUtil.covertBean(reqJson, WorkflowStepDto.class);

        int count = workflowStepInnerServiceSMOImpl.queryWorkflowStepsCount(workflowStepDto);

        List<WorkflowStepDto> workflowStepDtos = null;

        if (count > 0) {
            workflowStepDtos = workflowStepInnerServiceSMOImpl.queryWorkflowSteps(workflowStepDto);
        } else {
            workflowStepDtos = new ArrayList<>();
        }

        ResultVo resultVo = new ResultVo((int) Math.ceil((double) count / (double) reqJson.getInteger("row")), count, workflowStepDtos);

        ResponseEntity<String> responseEntity = new ResponseEntity<String>(resultVo.toString(), HttpStatus.OK);

        context.setResponseEntity(responseEntity);

    }
}

 service-api/src/main/java/com/java110/api/listener/workflow/ListWorkflowsListener.java

New file
@@ -0,0 +1,82 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.listener.AbstractServiceApiListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.core.smo.common.IWorkflowInnerServiceSMO;
import com.java110.dto.workflow.WorkflowDto;
import com.java110.utils.constant.ServiceCodeWorkflowConstant;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.vo.ResultVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import java.util.ArrayList;
import java.util.List;

/**
 * 查询小区侦听类
 */
@Java110Listener("listWorkflowsListener")
public class ListWorkflowsListener extends AbstractServiceApiListener {

    @Autowired
    private IWorkflowInnerServiceSMO workflowInnerServiceSMOImpl;

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowConstant.LIST_WORKFLOWS;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.GET;
    }


    @Override
    public int getOrder() {
        return DEFAULT_ORDER;
    }


    public IWorkflowInnerServiceSMO getWorkflowInnerServiceSMOImpl() {
        return workflowInnerServiceSMOImpl;
    }

    public void setWorkflowInnerServiceSMOImpl(IWorkflowInnerServiceSMO workflowInnerServiceSMOImpl) {
        this.workflowInnerServiceSMOImpl = workflowInnerServiceSMOImpl;
    }

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        super.validatePageInfo(reqJson);
    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        WorkflowDto workflowDto = BeanConvertUtil.covertBean(reqJson, WorkflowDto.class);

        int count = workflowInnerServiceSMOImpl.queryWorkflowsCount(workflowDto);

        List<WorkflowDto> workflowDtos = null;

        if (count > 0) {
            workflowDtos = workflowInnerServiceSMOImpl.queryWorkflows(workflowDto);
        } else {
            workflowDtos = new ArrayList<>();
        }

        ResultVo resultVo = new ResultVo((int) Math.ceil((double) count / (double) reqJson.getInteger("row")), count, workflowDtos);

        ResponseEntity<String> responseEntity = new ResponseEntity<String>(resultVo.toString(), HttpStatus.OK);

        context.setResponseEntity(responseEntity);

    }
}

 service-api/src/main/java/com/java110/api/listener/workflow/SaveWorkflowListener.java

New file
@@ -0,0 +1,50 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;

/**
 * 保存商户侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("saveWorkflowListener")
public class SaveWorkflowListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowBMO workflowBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "flowName", "请求报文中未包含flowName");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "flowType", "请求报文中未包含flowType");
        Assert.hasKeyAndValue(reqJson, "storeId", "请求报文中未包含storeId");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {
        workflowBMOImpl.addWorkflow(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowConstant.ADD_WORKFLOW;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/SaveWorkflowStepListener.java

New file
@@ -0,0 +1,49 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;

/**
 * 保存商户侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("saveWorkflowStepListener")
public class SaveWorkflowStepListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepBMO workflowStepBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "type", "请求报文中未包含type");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "storeId", "请求报文中未包含storeId");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {
        workflowStepBMOImpl.addWorkflowStep(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepConstant.ADD_WORKFLOWSTEP;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/SaveWorkflowStepStaffListener.java

New file
@@ -0,0 +1,49 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepStaffBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepStaffConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;

/**
 * 保存商户侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("saveWorkflowStepStaffListener")
public class SaveWorkflowStepStaffListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepStaffBMO workflowStepStaffBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {
        //Assert.hasKeyAndValue(reqJson, "xxx", "xxx");

        Assert.hasKeyAndValue(reqJson, "staffId", "请求报文中未包含staffId");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "staffName", "请求报文中未包含staffName");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {
        workflowStepStaffBMOImpl.addWorkflowStepStaff(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepStaffConstant.ADD_WORKFLOWSTEPSTAFF;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }

}

 service-api/src/main/java/com/java110/api/listener/workflow/UpdateWorkflowListener.java

New file
@@ -0,0 +1,51 @@
package com.java110.api.listener.workflow;


import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;

/**
 * 保存工作流侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("updateWorkflowListener")
public class UpdateWorkflowListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowBMO workflowBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {

        Assert.hasKeyAndValue(reqJson, "flowId", "flowId不能为空");
        Assert.hasKeyAndValue(reqJson, "flowName", "请求报文中未包含flowName");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "flowType", "请求报文中未包含flowType");
        Assert.hasKeyAndValue(reqJson, "storeId", "请求报文中未包含storeId");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowBMOImpl.updateWorkflow(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowConstant.UPDATE_WORKFLOW;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }
}

 service-api/src/main/java/com/java110/api/listener/workflow/UpdateWorkflowStepListener.java

New file
@@ -0,0 +1,50 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;


/**
 * 保存工作流节点侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("updateWorkflowStepListener")
public class UpdateWorkflowStepListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepBMO workflowStepBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {

        Assert.hasKeyAndValue(reqJson, "flowId", "flowId不能为空");
        Assert.hasKeyAndValue(reqJson, "type", "请求报文中未包含type");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "storeId", "请求报文中未包含storeId");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowStepBMOImpl.updateWorkflowStep(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepConstant.UPDATE_WORKFLOWSTEP;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }
}

 service-api/src/main/java/com/java110/api/listener/workflow/UpdateWorkflowStepStaffListener.java

New file
@@ -0,0 +1,50 @@
package com.java110.api.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.api.bmo.workflow.IWorkflowStepStaffBMO;
import com.java110.api.listener.AbstractServiceApiPlusListener;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.event.service.api.ServiceDataFlowEvent;
import com.java110.utils.constant.ServiceCodeWorkflowStepStaffConstant;
import com.java110.utils.util.Assert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;


/**
 * 保存工作流节点侦听
 * add by wuxw 2019-06-30
 */
@Java110Listener("updateWorkflowStepStaffListener")
public class UpdateWorkflowStepStaffListener extends AbstractServiceApiPlusListener {

    @Autowired
    private IWorkflowStepStaffBMO workflowStepStaffBMOImpl;

    @Override
    protected void validate(ServiceDataFlowEvent event, JSONObject reqJson) {

        Assert.hasKeyAndValue(reqJson, "wssId", "wssId不能为空");
        Assert.hasKeyAndValue(reqJson, "staffId", "请求报文中未包含staffId");
        Assert.hasKeyAndValue(reqJson, "communityId", "请求报文中未包含communityId");
        Assert.hasKeyAndValue(reqJson, "staffName", "请求报文中未包含staffName");

    }

    @Override
    protected void doSoService(ServiceDataFlowEvent event, DataFlowContext context, JSONObject reqJson) {

        workflowStepStaffBMOImpl.updateWorkflowStepStaff(reqJson, context);
    }

    @Override
    public String getServiceCode() {
        return ServiceCodeWorkflowStepStaffConstant.UPDATE_WORKFLOWSTEPSTAFF;
    }

    @Override
    public HttpMethod getHttpMethod() {
        return HttpMethod.POST;
    }
}

 service-common/src/main/java/com/java110/common/dao/IWorkflowServiceDao.java

New file
@@ -0,0 +1,81 @@
package com.java110.common.dao;


import com.java110.utils.exception.DAOException;
import com.java110.entity.merchant.BoMerchant;
import com.java110.entity.merchant.BoMerchantAttr;
import com.java110.entity.merchant.Merchant;
import com.java110.entity.merchant.MerchantAttr;


import java.util.List;
import java.util.Map;

/**
 * 工作流组件内部之间使用，没有给外围系统提供服务能力
 * 工作流服务接口类，要求全部以字符串传输，方便微服务化
 * 新建客户，修改客户，删除客户，查询客户等功能
 *
 * Created by wuxw on 2016/12/27.
 */
public interface IWorkflowServiceDao {

    /**
     * 保存 工作流信息
     * @param businessWorkflowInfo 工作流信息 封装
     * @throws DAOException 操作数据库异常
     */
    void saveBusinessWorkflowInfo(Map businessWorkflowInfo) throws DAOException;



    /**
     * 查询工作流信息（business过程）
     * 根据bId 查询工作流信息
     * @param info bId 信息
     * @return 工作流信息
     * @throws DAOException DAO异常
     */
    List<Map> getBusinessWorkflowInfo(Map info) throws DAOException;




    /**
     * 保存 工作流信息 Business数据到 Instance中
     * @param info
     * @throws DAOException DAO异常
     */
    void saveWorkflowInfoInstance(Map info) throws DAOException;




    /**
     * 查询工作流信息（instance过程）
     * 根据bId 查询工作流信息
     * @param info bId 信息
     * @return 工作流信息
     * @throws DAOException DAO异常
     */
    List<Map> getWorkflowInfo(Map info) throws DAOException;



    /**
     * 修改工作流信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    void updateWorkflowInfoInstance(Map info) throws DAOException;


    /**
     * 查询工作流总数
     *
     * @param info 工作流信息
     * @return 工作流数量
     */
    int queryWorkflowsCount(Map info);

}

 service-common/src/main/java/com/java110/common/dao/IWorkflowStepServiceDao.java

New file
@@ -0,0 +1,81 @@
package com.java110.common.dao;


import com.java110.utils.exception.DAOException;
import com.java110.entity.merchant.BoMerchant;
import com.java110.entity.merchant.BoMerchantAttr;
import com.java110.entity.merchant.Merchant;
import com.java110.entity.merchant.MerchantAttr;


import java.util.List;
import java.util.Map;

/**
 * 工作流节点组件内部之间使用，没有给外围系统提供服务能力
 * 工作流节点服务接口类，要求全部以字符串传输，方便微服务化
 * 新建客户，修改客户，删除客户，查询客户等功能
 *
 * Created by wuxw on 2016/12/27.
 */
public interface IWorkflowStepServiceDao {

    /**
     * 保存 工作流节点信息
     * @param businessWorkflowStepInfo 工作流节点信息 封装
     * @throws DAOException 操作数据库异常
     */
    void saveBusinessWorkflowStepInfo(Map businessWorkflowStepInfo) throws DAOException;



    /**
     * 查询工作流节点信息（business过程）
     * 根据bId 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    List<Map> getBusinessWorkflowStepInfo(Map info) throws DAOException;




    /**
     * 保存 工作流节点信息 Business数据到 Instance中
     * @param info
     * @throws DAOException DAO异常
     */
    void saveWorkflowStepInfoInstance(Map info) throws DAOException;




    /**
     * 查询工作流节点信息（instance过程）
     * 根据bId 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    List<Map> getWorkflowStepInfo(Map info) throws DAOException;



    /**
     * 修改工作流节点信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    void updateWorkflowStepInfoInstance(Map info) throws DAOException;


    /**
     * 查询工作流节点总数
     *
     * @param info 工作流节点信息
     * @return 工作流节点数量
     */
    int queryWorkflowStepsCount(Map info);

}

 service-common/src/main/java/com/java110/common/dao/IWorkflowStepStaffServiceDao.java

New file
@@ -0,0 +1,81 @@
package com.java110.common.dao;


import com.java110.utils.exception.DAOException;
import com.java110.entity.merchant.BoMerchant;
import com.java110.entity.merchant.BoMerchantAttr;
import com.java110.entity.merchant.Merchant;
import com.java110.entity.merchant.MerchantAttr;


import java.util.List;
import java.util.Map;

/**
 * 工作流节点组件内部之间使用，没有给外围系统提供服务能力
 * 工作流节点服务接口类，要求全部以字符串传输，方便微服务化
 * 新建客户，修改客户，删除客户，查询客户等功能
 *
 * Created by wuxw on 2016/12/27.
 */
public interface IWorkflowStepStaffServiceDao {

    /**
     * 保存 工作流节点信息
     * @param businessWorkflowStepStaffInfo 工作流节点信息 封装
     * @throws DAOException 操作数据库异常
     */
    void saveBusinessWorkflowStepStaffInfo(Map businessWorkflowStepStaffInfo) throws DAOException;



    /**
     * 查询工作流节点信息（business过程）
     * 根据bId 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    List<Map> getBusinessWorkflowStepStaffInfo(Map info) throws DAOException;




    /**
     * 保存 工作流节点信息 Business数据到 Instance中
     * @param info
     * @throws DAOException DAO异常
     */
    void saveWorkflowStepStaffInfoInstance(Map info) throws DAOException;




    /**
     * 查询工作流节点信息（instance过程）
     * 根据bId 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    List<Map> getWorkflowStepStaffInfo(Map info) throws DAOException;



    /**
     * 修改工作流节点信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    void updateWorkflowStepStaffInfoInstance(Map info) throws DAOException;


    /**
     * 查询工作流节点总数
     *
     * @param info 工作流节点信息
     * @return 工作流节点数量
     */
    int queryWorkflowStepStaffsCount(Map info);

}

 service-common/src/main/java/com/java110/common/dao/impl/WorkflowServiceDaoImpl.java

New file
@@ -0,0 +1,130 @@
package com.java110.common.dao.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.exception.DAOException;
import com.java110.utils.util.DateUtil;
import com.java110.core.base.dao.BaseServiceDao;
import com.java110.common.dao.IWorkflowServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

/**
 * 工作流服务 与数据库交互
 * Created by wuxw on 2017/4/5.
 */
@Service("workflowServiceDaoImpl")
//@Transactional
public class WorkflowServiceDaoImpl extends BaseServiceDao implements IWorkflowServiceDao {

    private static Logger logger = LoggerFactory.getLogger(WorkflowServiceDaoImpl.class);

    /**
     * 工作流信息封装
     * @param businessWorkflowInfo 工作流信息 封装
     * @throws DAOException DAO异常
     */
    @Override
    public void saveBusinessWorkflowInfo(Map businessWorkflowInfo) throws DAOException {
        businessWorkflowInfo.put("month", DateUtil.getCurrentMonth());
        // 查询business_user 数据是否已经存在
        logger.debug("保存工作流信息 入参 businessWorkflowInfo : {}",businessWorkflowInfo);
        int saveFlag = sqlSessionTemplate.insert("workflowServiceDaoImpl.saveBusinessWorkflowInfo",businessWorkflowInfo);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流数据失败："+ JSONObject.toJSONString(businessWorkflowInfo));
        }
    }


    /**
     * 查询工作流信息
     * @param info bId 信息
     * @return 工作流信息
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getBusinessWorkflowInfo(Map info) throws DAOException {

        logger.debug("查询工作流信息 入参 info : {}",info);

        List<Map> businessWorkflowInfos = sqlSessionTemplate.selectList("workflowServiceDaoImpl.getBusinessWorkflowInfo",info);

        return businessWorkflowInfos;
    }



    /**
     * 保存工作流信息 到 instance
     * @param info   bId 信息
     * @throws DAOException DAO异常
     */
    @Override
    public void saveWorkflowInfoInstance(Map info) throws DAOException {
        logger.debug("保存工作流信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.insert("workflowServiceDaoImpl.saveWorkflowInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }


    /**
     * 查询工作流信息（instance）
     * @param info bId 信息
     * @return List<Map>
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getWorkflowInfo(Map info) throws DAOException {
        logger.debug("查询工作流信息 入参 info : {}",info);

        List<Map> businessWorkflowInfos = sqlSessionTemplate.selectList("workflowServiceDaoImpl.getWorkflowInfo",info);

        return businessWorkflowInfos;
    }


    /**
     * 修改工作流信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    @Override
    public void updateWorkflowInfoInstance(Map info) throws DAOException {
        logger.debug("修改工作流信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.update("workflowServiceDaoImpl.updateWorkflowInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"修改工作流信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }

     /**
     * 查询工作流数量
     * @param info 工作流信息
     * @return 工作流数量
     */
    @Override
    public int queryWorkflowsCount(Map info) {
        logger.debug("查询工作流数据 入参 info : {}",info);

        List<Map> businessWorkflowInfos = sqlSessionTemplate.selectList("workflowServiceDaoImpl.queryWorkflowsCount", info);
        if (businessWorkflowInfos.size() < 1) {
            return 0;
        }

        return Integer.parseInt(businessWorkflowInfos.get(0).get("count").toString());
    }


}

 service-common/src/main/java/com/java110/common/dao/impl/WorkflowStepServiceDaoImpl.java

New file
@@ -0,0 +1,130 @@
package com.java110.common.dao.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.exception.DAOException;
import com.java110.utils.util.DateUtil;
import com.java110.core.base.dao.BaseServiceDao;
import com.java110.common.dao.IWorkflowStepServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

/**
 * 工作流节点服务 与数据库交互
 * Created by wuxw on 2017/4/5.
 */
@Service("workflowStepServiceDaoImpl")
//@Transactional
public class WorkflowStepServiceDaoImpl extends BaseServiceDao implements IWorkflowStepServiceDao {

    private static Logger logger = LoggerFactory.getLogger(WorkflowStepServiceDaoImpl.class);

    /**
     * 工作流节点信息封装
     * @param businessWorkflowStepInfo 工作流节点信息 封装
     * @throws DAOException DAO异常
     */
    @Override
    public void saveBusinessWorkflowStepInfo(Map businessWorkflowStepInfo) throws DAOException {
        businessWorkflowStepInfo.put("month", DateUtil.getCurrentMonth());
        // 查询business_user 数据是否已经存在
        logger.debug("保存工作流节点信息 入参 businessWorkflowStepInfo : {}",businessWorkflowStepInfo);
        int saveFlag = sqlSessionTemplate.insert("workflowStepServiceDaoImpl.saveBusinessWorkflowStepInfo",businessWorkflowStepInfo);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流节点数据失败："+ JSONObject.toJSONString(businessWorkflowStepInfo));
        }
    }


    /**
     * 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getBusinessWorkflowStepInfo(Map info) throws DAOException {

        logger.debug("查询工作流节点信息 入参 info : {}",info);

        List<Map> businessWorkflowStepInfos = sqlSessionTemplate.selectList("workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo",info);

        return businessWorkflowStepInfos;
    }



    /**
     * 保存工作流节点信息 到 instance
     * @param info   bId 信息
     * @throws DAOException DAO异常
     */
    @Override
    public void saveWorkflowStepInfoInstance(Map info) throws DAOException {
        logger.debug("保存工作流节点信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.insert("workflowStepServiceDaoImpl.saveWorkflowStepInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流节点信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }


    /**
     * 查询工作流节点信息（instance）
     * @param info bId 信息
     * @return List<Map>
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getWorkflowStepInfo(Map info) throws DAOException {
        logger.debug("查询工作流节点信息 入参 info : {}",info);

        List<Map> businessWorkflowStepInfos = sqlSessionTemplate.selectList("workflowStepServiceDaoImpl.getWorkflowStepInfo",info);

        return businessWorkflowStepInfos;
    }


    /**
     * 修改工作流节点信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    @Override
    public void updateWorkflowStepInfoInstance(Map info) throws DAOException {
        logger.debug("修改工作流节点信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.update("workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"修改工作流节点信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }

     /**
     * 查询工作流节点数量
     * @param info 工作流节点信息
     * @return 工作流节点数量
     */
    @Override
    public int queryWorkflowStepsCount(Map info) {
        logger.debug("查询工作流节点数据 入参 info : {}",info);

        List<Map> businessWorkflowStepInfos = sqlSessionTemplate.selectList("workflowStepServiceDaoImpl.queryWorkflowStepsCount", info);
        if (businessWorkflowStepInfos.size() < 1) {
            return 0;
        }

        return Integer.parseInt(businessWorkflowStepInfos.get(0).get("count").toString());
    }


}

 service-common/src/main/java/com/java110/common/dao/impl/WorkflowStepStaffServiceDaoImpl.java

New file
@@ -0,0 +1,130 @@
package com.java110.common.dao.impl;

import com.alibaba.fastjson.JSONObject;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.exception.DAOException;
import com.java110.utils.util.DateUtil;
import com.java110.core.base.dao.BaseServiceDao;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

/**
 * 工作流节点服务 与数据库交互
 * Created by wuxw on 2017/4/5.
 */
@Service("workflowStepStaffServiceDaoImpl")
//@Transactional
public class WorkflowStepStaffServiceDaoImpl extends BaseServiceDao implements IWorkflowStepStaffServiceDao {

    private static Logger logger = LoggerFactory.getLogger(WorkflowStepStaffServiceDaoImpl.class);

    /**
     * 工作流节点信息封装
     * @param businessWorkflowStepStaffInfo 工作流节点信息 封装
     * @throws DAOException DAO异常
     */
    @Override
    public void saveBusinessWorkflowStepStaffInfo(Map businessWorkflowStepStaffInfo) throws DAOException {
        businessWorkflowStepStaffInfo.put("month", DateUtil.getCurrentMonth());
        // 查询business_user 数据是否已经存在
        logger.debug("保存工作流节点信息 入参 businessWorkflowStepStaffInfo : {}",businessWorkflowStepStaffInfo);
        int saveFlag = sqlSessionTemplate.insert("workflowStepStaffServiceDaoImpl.saveBusinessWorkflowStepStaffInfo",businessWorkflowStepStaffInfo);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流节点数据失败："+ JSONObject.toJSONString(businessWorkflowStepStaffInfo));
        }
    }


    /**
     * 查询工作流节点信息
     * @param info bId 信息
     * @return 工作流节点信息
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getBusinessWorkflowStepStaffInfo(Map info) throws DAOException {

        logger.debug("查询工作流节点信息 入参 info : {}",info);

        List<Map> businessWorkflowStepStaffInfos = sqlSessionTemplate.selectList("workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo",info);

        return businessWorkflowStepStaffInfos;
    }



    /**
     * 保存工作流节点信息 到 instance
     * @param info   bId 信息
     * @throws DAOException DAO异常
     */
    @Override
    public void saveWorkflowStepStaffInfoInstance(Map info) throws DAOException {
        logger.debug("保存工作流节点信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.insert("workflowStepStaffServiceDaoImpl.saveWorkflowStepStaffInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"保存工作流节点信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }


    /**
     * 查询工作流节点信息（instance）
     * @param info bId 信息
     * @return List<Map>
     * @throws DAOException DAO异常
     */
    @Override
    public List<Map> getWorkflowStepStaffInfo(Map info) throws DAOException {
        logger.debug("查询工作流节点信息 入参 info : {}",info);

        List<Map> businessWorkflowStepStaffInfos = sqlSessionTemplate.selectList("workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo",info);

        return businessWorkflowStepStaffInfos;
    }


    /**
     * 修改工作流节点信息
     * @param info 修改信息
     * @throws DAOException DAO异常
     */
    @Override
    public void updateWorkflowStepStaffInfoInstance(Map info) throws DAOException {
        logger.debug("修改工作流节点信息Instance 入参 info : {}",info);

        int saveFlag = sqlSessionTemplate.update("workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance",info);

        if(saveFlag < 1){
            throw new DAOException(ResponseConstant.RESULT_PARAM_ERROR,"修改工作流节点信息Instance数据失败："+ JSONObject.toJSONString(info));
        }
    }

     /**
     * 查询工作流节点数量
     * @param info 工作流节点信息
     * @return 工作流节点数量
     */
    @Override
    public int queryWorkflowStepStaffsCount(Map info) {
        logger.debug("查询工作流节点数据 入参 info : {}",info);

        List<Map> businessWorkflowStepStaffInfos = sqlSessionTemplate.selectList("workflowStepStaffServiceDaoImpl.queryWorkflowStepStaffsCount", info);
        if (businessWorkflowStepStaffInfos.size() < 1) {
            return 0;
        }

        return Integer.parseInt(businessWorkflowStepStaffInfos.get(0).get("count").toString());
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/AbstractWorkflowBusinessServiceDataFlowListener.java

New file
@@ -0,0 +1,92 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.event.service.AbstractBusinessServiceDataFlowListener;
import com.java110.entity.center.Business;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 工作流 服务侦听 父类
 * Created by wuxw on 2018/7/4.
 */
public abstract class AbstractWorkflowBusinessServiceDataFlowListener extends AbstractBusinessServiceDataFlowListener {
    private static Logger logger = LoggerFactory.getLogger(AbstractWorkflowBusinessServiceDataFlowListener.class);


    /**
     * 获取 DAO工具类
     *
     * @return
     */
    public abstract IWorkflowServiceDao getWorkflowServiceDaoImpl();

    /**
     * 刷新 businessWorkflowInfo 数据
     * 主要将 数据库 中字段和 接口传递字段建立关系
     *
     * @param businessWorkflowInfo
     */
    protected void flushBusinessWorkflowInfo(Map businessWorkflowInfo, String statusCd) {
        businessWorkflowInfo.put("newBId", businessWorkflowInfo.get("b_id"));
        businessWorkflowInfo.put("skipLevel", businessWorkflowInfo.get("skip_level"));
        businessWorkflowInfo.put("operate", businessWorkflowInfo.get("operate"));
        businessWorkflowInfo.put("describle", businessWorkflowInfo.get("describle"));
        businessWorkflowInfo.put("communityId", businessWorkflowInfo.get("community_id"));
        businessWorkflowInfo.put("storeId", businessWorkflowInfo.get("store_id"));
        businessWorkflowInfo.put("flowId", businessWorkflowInfo.get("flow_id"));
        businessWorkflowInfo.put("flowName", businessWorkflowInfo.get("flow_name"));
        businessWorkflowInfo.put("flowType", businessWorkflowInfo.get("flow_type"));
        businessWorkflowInfo.remove("bId");
        businessWorkflowInfo.put("statusCd", statusCd);
    }


    /**
     * 当修改数据时，查询instance表中的数据 自动保存删除数据到business中
     *
     * @param businessWorkflow 工作流信息
     */
    protected void autoSaveDelBusinessWorkflow(Business business, JSONObject businessWorkflow) {
//自动插入DEL
        Map info = new HashMap();
        info.put("flowId", businessWorkflow.getString("flowId"));
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        List<Map> currentWorkflowInfos = getWorkflowServiceDaoImpl().getWorkflowInfo(info);
        if (currentWorkflowInfos == null || currentWorkflowInfos.size() != 1) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "未找到需要修改数据信息，入参错误或数据有问题，请检查" + info);
        }

        Map currentWorkflowInfo = currentWorkflowInfos.get(0);

        currentWorkflowInfo.put("bId", business.getbId());

        currentWorkflowInfo.put("skipLevel", currentWorkflowInfo.get("skip_level"));
        currentWorkflowInfo.put("operate", currentWorkflowInfo.get("operate"));
        currentWorkflowInfo.put("describle", currentWorkflowInfo.get("describle"));
        currentWorkflowInfo.put("communityId", currentWorkflowInfo.get("community_id"));
        currentWorkflowInfo.put("storeId", currentWorkflowInfo.get("store_id"));
        currentWorkflowInfo.put("flowId", currentWorkflowInfo.get("flow_id"));
        currentWorkflowInfo.put("flowName", currentWorkflowInfo.get("flow_name"));
        currentWorkflowInfo.put("flowType", currentWorkflowInfo.get("flow_type"));


        currentWorkflowInfo.put("operate", StatusConstant.OPERATE_DEL);
        getWorkflowServiceDaoImpl().saveBusinessWorkflowInfo(currentWorkflowInfo);
        for (Object key : currentWorkflowInfo.keySet()) {
            if (businessWorkflow.get(key) == null) {
                businessWorkflow.put(key.toString(), currentWorkflowInfo.get(key));
            }
        }
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/AbstractWorkflowStepBusinessServiceDataFlowListener.java

New file
@@ -0,0 +1,90 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.event.service.AbstractBusinessServiceDataFlowListener;
import com.java110.entity.center.Business;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 工作流节点 服务侦听 父类
 * Created by wuxw on 2018/7/4.
 */
public abstract class AbstractWorkflowStepBusinessServiceDataFlowListener extends AbstractBusinessServiceDataFlowListener {
    private static Logger logger = LoggerFactory.getLogger(AbstractWorkflowStepBusinessServiceDataFlowListener.class);


    /**
     * 获取 DAO工具类
     *
     * @return
     */
    public abstract IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl();

    /**
     * 刷新 businessWorkflowStepInfo 数据
     * 主要将 数据库 中字段和 接口传递字段建立关系
     *
     * @param businessWorkflowStepInfo
     */
    protected void flushBusinessWorkflowStepInfo(Map businessWorkflowStepInfo, String statusCd) {
        businessWorkflowStepInfo.put("newBId", businessWorkflowStepInfo.get("b_id"));
        businessWorkflowStepInfo.put("operate", businessWorkflowStepInfo.get("operate"));
        businessWorkflowStepInfo.put("stepId", businessWorkflowStepInfo.get("step_id"));
        businessWorkflowStepInfo.put("type", businessWorkflowStepInfo.get("type"));
        businessWorkflowStepInfo.put("communityId", businessWorkflowStepInfo.get("community_id"));
        businessWorkflowStepInfo.put("storeId", businessWorkflowStepInfo.get("store_id"));
        businessWorkflowStepInfo.put("flowId", businessWorkflowStepInfo.get("flow_id"));
        businessWorkflowStepInfo.put("seq", businessWorkflowStepInfo.get("seq"));
        businessWorkflowStepInfo.remove("bId");
        businessWorkflowStepInfo.put("statusCd", statusCd);
    }


    /**
     * 当修改数据时，查询instance表中的数据 自动保存删除数据到business中
     *
     * @param businessWorkflowStep 工作流节点信息
     */
    protected void autoSaveDelBusinessWorkflowStep(Business business, JSONObject businessWorkflowStep) {
//自动插入DEL
        Map info = new HashMap();
        info.put("flowId", businessWorkflowStep.getString("flowId"));
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        List<Map> currentWorkflowStepInfos = getWorkflowStepServiceDaoImpl().getWorkflowStepInfo(info);
        if (currentWorkflowStepInfos == null || currentWorkflowStepInfos.size() != 1) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "未找到需要修改数据信息，入参错误或数据有问题，请检查" + info);
        }

        Map currentWorkflowStepInfo = currentWorkflowStepInfos.get(0);

        currentWorkflowStepInfo.put("bId", business.getbId());

        currentWorkflowStepInfo.put("operate", currentWorkflowStepInfo.get("operate"));
        currentWorkflowStepInfo.put("stepId", currentWorkflowStepInfo.get("step_id"));
        currentWorkflowStepInfo.put("type", currentWorkflowStepInfo.get("type"));
        currentWorkflowStepInfo.put("communityId", currentWorkflowStepInfo.get("community_id"));
        currentWorkflowStepInfo.put("storeId", currentWorkflowStepInfo.get("store_id"));
        currentWorkflowStepInfo.put("flowId", currentWorkflowStepInfo.get("flow_id"));
        currentWorkflowStepInfo.put("seq", currentWorkflowStepInfo.get("seq"));


        currentWorkflowStepInfo.put("operate", StatusConstant.OPERATE_DEL);
        getWorkflowStepServiceDaoImpl().saveBusinessWorkflowStepInfo(currentWorkflowStepInfo);
        for (Object key : currentWorkflowStepInfo.keySet()) {
            if (businessWorkflowStep.get(key) == null) {
                businessWorkflowStep.put(key.toString(), currentWorkflowStepInfo.get(key));
            }
        }
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/AbstractWorkflowStepStaffBusinessServiceDataFlowListener.java

New file
@@ -0,0 +1,88 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.event.service.AbstractBusinessServiceDataFlowListener;
import com.java110.entity.center.Business;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 工作流节点 服务侦听 父类
 * Created by wuxw on 2018/7/4.
 */
public abstract class AbstractWorkflowStepStaffBusinessServiceDataFlowListener extends AbstractBusinessServiceDataFlowListener {
    private static Logger logger = LoggerFactory.getLogger(AbstractWorkflowStepStaffBusinessServiceDataFlowListener.class);


    /**
     * 获取 DAO工具类
     *
     * @return
     */
    public abstract IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl();

    /**
     * 刷新 businessWorkflowStepStaffInfo 数据
     * 主要将 数据库 中字段和 接口传递字段建立关系
     *
     * @param businessWorkflowStepStaffInfo
     */
    protected void flushBusinessWorkflowStepStaffInfo(Map businessWorkflowStepStaffInfo, String statusCd) {
        businessWorkflowStepStaffInfo.put("newBId", businessWorkflowStepStaffInfo.get("b_id"));
        businessWorkflowStepStaffInfo.put("wssId", businessWorkflowStepStaffInfo.get("wss_id"));
        businessWorkflowStepStaffInfo.put("operate", businessWorkflowStepStaffInfo.get("operate"));
        businessWorkflowStepStaffInfo.put("stepId", businessWorkflowStepStaffInfo.get("step_id"));
        businessWorkflowStepStaffInfo.put("staffName", businessWorkflowStepStaffInfo.get("staff_name"));
        businessWorkflowStepStaffInfo.put("communityId", businessWorkflowStepStaffInfo.get("community_id"));
        businessWorkflowStepStaffInfo.put("staffId", businessWorkflowStepStaffInfo.get("staff_id"));
        businessWorkflowStepStaffInfo.remove("bId");
        businessWorkflowStepStaffInfo.put("statusCd", statusCd);
    }


    /**
     * 当修改数据时，查询instance表中的数据 自动保存删除数据到business中
     *
     * @param businessWorkflowStepStaff 工作流节点信息
     */
    protected void autoSaveDelBusinessWorkflowStepStaff(Business business, JSONObject businessWorkflowStepStaff) {
//自动插入DEL
        Map info = new HashMap();
        info.put("wssId", businessWorkflowStepStaff.getString("wssId"));
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        List<Map> currentWorkflowStepStaffInfos = getWorkflowStepStaffServiceDaoImpl().getWorkflowStepStaffInfo(info);
        if (currentWorkflowStepStaffInfos == null || currentWorkflowStepStaffInfos.size() != 1) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "未找到需要修改数据信息，入参错误或数据有问题，请检查" + info);
        }

        Map currentWorkflowStepStaffInfo = currentWorkflowStepStaffInfos.get(0);

        currentWorkflowStepStaffInfo.put("bId", business.getbId());

        currentWorkflowStepStaffInfo.put("wssId", currentWorkflowStepStaffInfo.get("wss_id"));
        currentWorkflowStepStaffInfo.put("operate", currentWorkflowStepStaffInfo.get("operate"));
        currentWorkflowStepStaffInfo.put("stepId", currentWorkflowStepStaffInfo.get("step_id"));
        currentWorkflowStepStaffInfo.put("staffName", currentWorkflowStepStaffInfo.get("staff_name"));
        currentWorkflowStepStaffInfo.put("communityId", currentWorkflowStepStaffInfo.get("community_id"));
        currentWorkflowStepStaffInfo.put("staffId", currentWorkflowStepStaffInfo.get("staff_id"));


        currentWorkflowStepStaffInfo.put("operate", StatusConstant.OPERATE_DEL);
        getWorkflowStepStaffServiceDaoImpl().saveBusinessWorkflowStepStaffInfo(currentWorkflowStepStaffInfo);
        for (Object key : currentWorkflowStepStaffInfo.keySet()) {
            if (businessWorkflowStepStaff.get(key) == null) {
                businessWorkflowStepStaff.put(key.toString(), currentWorkflowStepStaffInfo.get(key));
            }
        }
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/DeleteWorkflowInfoListener.java

New file
@@ -0,0 +1,180 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflow:{} 工作流基本信息节点
 * 2、businessWorkflowAttr:[{}] 工作流属性信息节点
 * 3、businessWorkflowPhoto:[{}] 工作流照片信息节点
 * 4、businessWorkflowCerdentials:[{}] 工作流证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowInfoListener")
@Transactional
public class DeleteWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowInfoListener.class);
    @Autowired
    IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflow 节点
        if (data.containsKey(WorkflowPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowPo.class.getSimpleName());
            JSONArray businessWorkflows = null;
            if (_obj instanceof JSONObject) {
                businessWorkflows = new JSONArray();
                businessWorkflows.add(_obj);
            } else {
                businessWorkflows = (JSONArray) _obj;
            }
            //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflows.size(); _workflowIndex++) {
                JSONObject businessWorkflow = businessWorkflows.getJSONObject(_workflowIndex);
                doBusinessWorkflow(business, businessWorkflow);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                }
            }

        }


    }

    /**
     * 删除 instance数据
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流信息
        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_DEL);

        //工作流信息
        List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if (businessWorkflowInfos != null && businessWorkflowInfos.size() > 0) {
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size(); _workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo, StatusConstant.STATUS_CD_INVALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
                dataFlowContext.addParamOut("flowId", businessWorkflowInfo.get("flow_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if (workflowInfo != null && workflowInfo.size() > 0) {

            //工作流信息
            List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowInfos == null || businessWorkflowInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflow），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size(); _workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo, StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
            }
        }
    }


    /**
     * 处理 businessWorkflow 节点
     *
     * @param business         总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business, JSONObject businessWorkflow) {

        Assert.jsonObjectHaveKey(businessWorkflow, "flowId", "businessWorkflow 节点下没有包含 flowId 节点");

        if (businessWorkflow.getString("flowId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "flowId 错误，不能自动生成（必须已经存在的flowId）" + businessWorkflow);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflow(business, businessWorkflow);
    }

    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/DeleteWorkflowStepInfoListener.java

New file
@@ -0,0 +1,180 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowStepPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流节点信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflowStep:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowStepInfoListener")
@Transactional
public class DeleteWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowStepInfoListener.class);
    @Autowired
    IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStep 节点
        if (data.containsKey(WorkflowStepPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowStepPo.class.getSimpleName());
            JSONArray businessWorkflowSteps = null;
            if (_obj instanceof JSONObject) {
                businessWorkflowSteps = new JSONArray();
                businessWorkflowSteps.add(_obj);
            } else {
                businessWorkflowSteps = (JSONArray) _obj;
            }
            //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowSteps.size(); _workflowStepIndex++) {
                JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(_workflowStepIndex);
                doBusinessWorkflowStep(business, businessWorkflowStep);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                }
            }

        }


    }

    /**
     * 删除 instance数据
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流节点信息
        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_DEL);

        //工作流节点信息
        List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if (businessWorkflowStepInfos != null && businessWorkflowStepInfos.size() > 0) {
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size(); _workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo, StatusConstant.STATUS_CD_INVALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
                dataFlowContext.addParamOut("flowId", businessWorkflowStepInfo.get("flow_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if (workflowStepInfo != null && workflowStepInfo.size() > 0) {

            //工作流节点信息
            List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowStepInfos == null || businessWorkflowStepInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflowStep），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size(); _workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
            }
        }
    }


    /**
     * 处理 businessWorkflowStep 节点
     *
     * @param business             总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business, JSONObject businessWorkflowStep) {

        Assert.jsonObjectHaveKey(businessWorkflowStep, "flowId", "businessWorkflowStep 节点下没有包含 flowId 节点");

        if (businessWorkflowStep.getString("flowId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "flowId 错误，不能自动生成（必须已经存在的flowId）" + businessWorkflowStep);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflowStep(business, businessWorkflowStep);
    }

    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/DeleteWorkflowStepStaffInfoListener.java

New file
@@ -0,0 +1,180 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowStepStaffPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 删除工作流节点信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflowStepStaff:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepStaffAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepStaffPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepStaffCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E5%88%A0%E9%99%A4%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("deleteWorkflowStepStaffInfoListener")
@Transactional
public class DeleteWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener {

    private final static Logger logger = LoggerFactory.getLogger(DeleteWorkflowStepStaffInfoListener.class);
    @Autowired
    IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 3;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_DELETE_WORKFLOW_STEP_STAFF;
    }

    /**
     * 根据删除信息 查出Instance表中数据 保存至business表 （状态写DEL） 方便撤单时直接更新回去
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStepStaff 节点
        if (data.containsKey(WorkflowStepStaffPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowStepStaffPo.class.getSimpleName());
            JSONArray businessWorkflowStepStaffs = null;
            if (_obj instanceof JSONObject) {
                businessWorkflowStepStaffs = new JSONArray();
                businessWorkflowStepStaffs.add(_obj);
            } else {
                businessWorkflowStepStaffs = (JSONArray) _obj;
            }
            //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffs.size(); _workflowStepStaffIndex++) {
                JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(_workflowStepStaffIndex);
                doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                }
            }

        }


    }

    /**
     * 删除 instance数据
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");

        //工作流节点信息
        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_DEL);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if (businessWorkflowStepStaffInfos != null && businessWorkflowStepStaffInfos.size() > 0) {
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size(); _workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo, StatusConstant.STATUS_CD_INVALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
                dataFlowContext.addParamOut("wssId", businessWorkflowStepStaffInfo.get("wss_id"));
            }
        }

    }

    /**
     * 撤单
     * 从business表中查询到DEL的数据 将instance中的数据更新回来
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_INVALID);

        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if (workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0) {

            //工作流节点信息
            List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowStepStaffInfos == null || businessWorkflowStepStaffInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflowStepStaff），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size(); _workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
            }
        }
    }


    /**
     * 处理 businessWorkflowStepStaff 节点
     *
     * @param business                  总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business, JSONObject businessWorkflowStepStaff) {

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff, "wssId", "businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if (businessWorkflowStepStaff.getString("wssId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "wssId 错误，不能自动生成（必须已经存在的wssId）" + businessWorkflowStepStaff);
        }
        //自动插入DEL
        autoSaveDelBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
    }

    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/SaveWorkflowInfoListener.java

New file
@@ -0,0 +1,181 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowInfoListener")
@Transactional
public class SaveWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowInfoListener.class);

    @Autowired
    private IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW;
    }

    /**
     * 保存工作流信息 business 表中
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflow 节点
        if (data.containsKey(WorkflowPo.class.getSimpleName())) {
            Object bObj = data.get(WorkflowPo.class.getSimpleName());
            JSONArray businessWorkflows = null;
            if (bObj instanceof JSONObject) {
                businessWorkflows = new JSONArray();
                businessWorkflows.add(bObj);
            } else {
                businessWorkflows = (JSONArray) bObj;
            }
            //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
            for (int bWorkflowIndex = 0; bWorkflowIndex < businessWorkflows.size(); bWorkflowIndex++) {
                JSONObject businessWorkflow = businessWorkflows.getJSONObject(bWorkflowIndex);
                doBusinessWorkflow(business, businessWorkflow);
                if (bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_ADD);

        //工作流信息
        List<Map> businessWorkflowInfo = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if (businessWorkflowInfo != null && businessWorkflowInfo.size() > 0) {
            reFreshShareColumn(info, businessWorkflowInfo.get(0));
            workflowServiceDaoImpl.saveWorkflowInfoInstance(info);
            if (businessWorkflowInfo.size() == 1) {
                dataFlowContext.addParamOut("flowId", businessWorkflowInfo.get(0).get("flow_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }

    /**
     * 撤单
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId", bId);
        paramIn.put("statusCd", StatusConstant.STATUS_CD_INVALID);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if (workflowInfo != null && workflowInfo.size() > 0) {
            reFreshShareColumn(paramIn, workflowInfo.get(0));
            workflowServiceDaoImpl.updateWorkflowInfoInstance(paramIn);
        }
    }


    /**
     * 处理 businessWorkflow 节点
     *
     * @param business         总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business, JSONObject businessWorkflow) {

        Assert.jsonObjectHaveKey(businessWorkflow, "flowId", "businessWorkflow 节点下没有包含 flowId 节点");

        if (businessWorkflow.getString("flowId").startsWith("-")) {
            //刷新缓存
            //flushWorkflowId(business.getDatas());

            businessWorkflow.put("flowId", GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_flowId));

        }

        businessWorkflow.put("bId", business.getbId());
        businessWorkflow.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流信息
        workflowServiceDaoImpl.saveBusinessWorkflowInfo(businessWorkflow);

    }

    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/SaveWorkflowStepInfoListener.java

New file
@@ -0,0 +1,176 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.po.workflow.WorkflowStepPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流节点信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowStepInfoListener")
@Transactional
public class SaveWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener{

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowStepInfoListener.class);

    @Autowired
    private IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP;
    }

    /**
     * 保存工作流节点信息 business 表中
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data,"没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStep 节点
        if(data.containsKey(WorkflowStepPo.class.getSimpleName())){
            Object bObj = data.get(WorkflowStepPo.class.getSimpleName());
            JSONArray businessWorkflowSteps = null;
            if(bObj instanceof JSONObject){
                businessWorkflowSteps = new JSONArray();
                businessWorkflowSteps.add(bObj);
            }else {
                businessWorkflowSteps = (JSONArray)bObj;
            }
            //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
            for (int bWorkflowStepIndex = 0; bWorkflowStepIndex < businessWorkflowSteps.size();bWorkflowStepIndex++) {
                JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(bWorkflowStepIndex);
                doBusinessWorkflowStep(business, businessWorkflowStep);
                if(bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId",business.getbId());
        info.put("operate",StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepInfo = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if( businessWorkflowStepInfo != null && businessWorkflowStepInfo.size() >0) {
            reFreshShareColumn(info, businessWorkflowStepInfo.get(0));
            workflowStepServiceDaoImpl.saveWorkflowStepInfoInstance(info);
            if(businessWorkflowStepInfo.size() == 1) {
                dataFlowContext.addParamOut("flowId", businessWorkflowStepInfo.get(0).get("flow_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }
    /**
     * 撤单
     * @param dataFlowContext 数据对象
     * @param business 当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId",bId);
        info.put("statusCd",StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId",bId);
        paramIn.put("statusCd",StatusConstant.STATUS_CD_INVALID);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if(workflowStepInfo != null && workflowStepInfo.size() > 0){
            reFreshShareColumn(paramIn, workflowStepInfo.get(0));
            workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(paramIn);
        }
    }



    /**
     * 处理 businessWorkflowStep 节点
     * @param business 总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business,JSONObject businessWorkflowStep){

        Assert.jsonObjectHaveKey(businessWorkflowStep,"flowId","businessWorkflowStep 节点下没有包含 flowId 节点");

        if(businessWorkflowStep.getString("flowId").startsWith("-")){
            //刷新缓存
            //flushWorkflowStepId(business.getDatas());

            businessWorkflowStep.put("flowId",GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_flowId));

        }

        businessWorkflowStep.put("bId",business.getbId());
        businessWorkflowStep.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepServiceDaoImpl.saveBusinessWorkflowStepInfo(businessWorkflowStep);

    }
    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/SaveWorkflowStepStaffInfoListener.java

New file
@@ -0,0 +1,181 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.core.factory.GenerateCodeFactory;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowStepStaffPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 保存 工作流节点信息 侦听
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("saveWorkflowStepStaffInfoListener")
@Transactional
public class SaveWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(SaveWorkflowStepStaffInfoListener.class);

    @Autowired
    private IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_SAVE_WORKFLOW_STEP_STAFF;
    }

    /**
     * 保存工作流节点信息 business 表中
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();
        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");

        //处理 businessWorkflowStepStaff 节点
        if (data.containsKey(WorkflowStepStaffPo.class.getSimpleName())) {
            Object bObj = data.get(WorkflowStepStaffPo.class.getSimpleName());
            JSONArray businessWorkflowStepStaffs = null;
            if (bObj instanceof JSONObject) {
                businessWorkflowStepStaffs = new JSONArray();
                businessWorkflowStepStaffs.add(bObj);
            } else {
                businessWorkflowStepStaffs = (JSONArray) bObj;
            }
            //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
            for (int bWorkflowStepStaffIndex = 0; bWorkflowStepStaffIndex < businessWorkflowStepStaffs.size(); bWorkflowStepStaffIndex++) {
                JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(bWorkflowStepStaffIndex);
                doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                if (bObj instanceof JSONObject) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                }
            }
        }
    }

    /**
     * business 数据转移到 instance
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {
        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if (businessWorkflowStepStaffInfo != null && businessWorkflowStepStaffInfo.size() > 0) {
            reFreshShareColumn(info, businessWorkflowStepStaffInfo.get(0));
            workflowStepStaffServiceDaoImpl.saveWorkflowStepStaffInfoInstance(info);
            if (businessWorkflowStepStaffInfo.size() == 1) {
                dataFlowContext.addParamOut("wssId", businessWorkflowStepStaffInfo.get(0).get("wss_id"));
            }
        }
    }


    /**
     * 刷 分片字段
     *
     * @param info         查询对象
     * @param businessInfo 小区ID
     */
    private void reFreshShareColumn(Map info, Map businessInfo) {

        if (info.containsKey("communityId")) {
            return;
        }

        if (!businessInfo.containsKey("community_id")) {
            return;
        }

        info.put("communityId", businessInfo.get("community_id"));
    }

    /**
     * 撤单
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {
        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        Map paramIn = new HashMap();
        paramIn.put("bId", bId);
        paramIn.put("statusCd", StatusConstant.STATUS_CD_INVALID);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if (workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0) {
            reFreshShareColumn(paramIn, workflowStepStaffInfo.get(0));
            workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(paramIn);
        }
    }


    /**
     * 处理 businessWorkflowStepStaff 节点
     *
     * @param business                  总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business, JSONObject businessWorkflowStepStaff) {

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff, "wssId", "businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if (businessWorkflowStepStaff.getString("wssId").startsWith("-")) {
            //刷新缓存
            //flushWorkflowStepStaffId(business.getDatas());

            businessWorkflowStepStaff.put("wssId", GenerateCodeFactory.getGeneratorId(GenerateCodeFactory.CODE_PREFIX_wssId));

        }

        businessWorkflowStepStaff.put("bId", business.getbId());
        businessWorkflowStepStaff.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepStaffServiceDaoImpl.saveBusinessWorkflowStepStaffInfo(businessWorkflowStepStaff);

    }

    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }
}

 service-common/src/main/java/com/java110/common/listener/workflow/UpdateWorkflowInfoListener.java

New file
@@ -0,0 +1,190 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflow:{} 工作流基本信息节点
 * 2、businessWorkflowAttr:[{}] 工作流属性信息节点
 * 3、businessWorkflowPhoto:[{}] 工作流照片信息节点
 * 4、businessWorkflowCerdentials:[{}] 工作流证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowInfoListener")
@Transactional
public class UpdateWorkflowInfoListener extends AbstractWorkflowBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowInfoListener.class);
    @Autowired
    private IWorkflowServiceDao workflowServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW;
    }

    /**
     * business过程
     *
     * @param dataFlowContext 上下文对象
     * @param business        业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");


        //处理 businessWorkflow 节点
        if (data.containsKey(WorkflowPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowPo.class.getSimpleName());
            JSONArray businessWorkflows = null;
            if (_obj instanceof JSONObject) {
                businessWorkflows = new JSONArray();
                businessWorkflows.add(_obj);
            } else {
                businessWorkflows = (JSONArray) _obj;
            }
            //JSONObject businessWorkflow = data.getJSONObject(WorkflowPo.class.getSimpleName());
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflows.size(); _workflowIndex++) {
                JSONObject businessWorkflow = businessWorkflows.getJSONObject(_workflowIndex);
                doBusinessWorkflow(business, businessWorkflow);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflow.getString("flowId"));
                }
            }
        }
    }


    /**
     * business to instance 过程
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_ADD);

        //工作流信息
        List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(info);
        if (businessWorkflowInfos != null && businessWorkflowInfos.size() > 0) {
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size(); _workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo, StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
                if (businessWorkflowInfo.size() == 1) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowInfo.get("flow_id"));
                }
            }
        }

    }

    /**
     * 撤单
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流信息
        List<Map> workflowInfo = workflowServiceDaoImpl.getWorkflowInfo(info);
        if (workflowInfo != null && workflowInfo.size() > 0) {

            //工作流信息
            List<Map> businessWorkflowInfos = workflowServiceDaoImpl.getBusinessWorkflowInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowInfos == null || businessWorkflowInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflow），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowIndex = 0; _workflowIndex < businessWorkflowInfos.size(); _workflowIndex++) {
                Map businessWorkflowInfo = businessWorkflowInfos.get(_workflowIndex);
                flushBusinessWorkflowInfo(businessWorkflowInfo, StatusConstant.STATUS_CD_VALID);
                workflowServiceDaoImpl.updateWorkflowInfoInstance(businessWorkflowInfo);
            }
        }

    }


    /**
     * 处理 businessWorkflow 节点
     *
     * @param business         总的数据节点
     * @param businessWorkflow 工作流节点
     */
    private void doBusinessWorkflow(Business business, JSONObject businessWorkflow) {

        Assert.jsonObjectHaveKey(businessWorkflow, "flowId", "businessWorkflow 节点下没有包含 flowId 节点");

        if (businessWorkflow.getString("flowId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "flowId 错误，不能自动生成（必须已经存在的flowId）" + businessWorkflow);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflow(business, businessWorkflow);

        businessWorkflow.put("bId", business.getbId());
        businessWorkflow.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流信息
        workflowServiceDaoImpl.saveBusinessWorkflowInfo(businessWorkflow);

    }


    @Override
    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/UpdateWorkflowStepInfoListener.java

New file
@@ -0,0 +1,190 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowStepPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流节点信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflowStep:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowStepInfoListener")
@Transactional
public class UpdateWorkflowStepInfoListener extends AbstractWorkflowStepBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowStepInfoListener.class);
    @Autowired
    private IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP;
    }

    /**
     * business过程
     *
     * @param dataFlowContext 上下文对象
     * @param business        业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");


        //处理 businessWorkflowStep 节点
        if (data.containsKey(WorkflowStepPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowStepPo.class.getSimpleName());
            JSONArray businessWorkflowSteps = null;
            if (_obj instanceof JSONObject) {
                businessWorkflowSteps = new JSONArray();
                businessWorkflowSteps.add(_obj);
            } else {
                businessWorkflowSteps = (JSONArray) _obj;
            }
            //JSONObject businessWorkflowStep = data.getJSONObject(WorkflowStepPo.class.getSimpleName());
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowSteps.size(); _workflowStepIndex++) {
                JSONObject businessWorkflowStep = businessWorkflowSteps.getJSONObject(_workflowStepIndex);
                doBusinessWorkflowStep(business, businessWorkflowStep);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStep.getString("flowId"));
                }
            }
        }
    }


    /**
     * business to instance 过程
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(info);
        if (businessWorkflowStepInfos != null && businessWorkflowStepInfos.size() > 0) {
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size(); _workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
                if (businessWorkflowStepInfo.size() == 1) {
                    dataFlowContext.addParamOut("flowId", businessWorkflowStepInfo.get("flow_id"));
                }
            }
        }

    }

    /**
     * 撤单
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepInfo = workflowStepServiceDaoImpl.getWorkflowStepInfo(info);
        if (workflowStepInfo != null && workflowStepInfo.size() > 0) {

            //工作流节点信息
            List<Map> businessWorkflowStepInfos = workflowStepServiceDaoImpl.getBusinessWorkflowStepInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowStepInfos == null || businessWorkflowStepInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflowStep），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowStepIndex = 0; _workflowStepIndex < businessWorkflowStepInfos.size(); _workflowStepIndex++) {
                Map businessWorkflowStepInfo = businessWorkflowStepInfos.get(_workflowStepIndex);
                flushBusinessWorkflowStepInfo(businessWorkflowStepInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepServiceDaoImpl.updateWorkflowStepInfoInstance(businessWorkflowStepInfo);
            }
        }

    }


    /**
     * 处理 businessWorkflowStep 节点
     *
     * @param business             总的数据节点
     * @param businessWorkflowStep 工作流节点节点
     */
    private void doBusinessWorkflowStep(Business business, JSONObject businessWorkflowStep) {

        Assert.jsonObjectHaveKey(businessWorkflowStep, "flowId", "businessWorkflowStep 节点下没有包含 flowId 节点");

        if (businessWorkflowStep.getString("flowId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "flowId 错误，不能自动生成（必须已经存在的flowId）" + businessWorkflowStep);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflowStep(business, businessWorkflowStep);

        businessWorkflowStep.put("bId", business.getbId());
        businessWorkflowStep.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepServiceDaoImpl.saveBusinessWorkflowStepInfo(businessWorkflowStep);

    }


    @Override
    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }


}

 service-common/src/main/java/com/java110/common/listener/workflow/UpdateWorkflowStepStaffInfoListener.java

New file
@@ -0,0 +1,190 @@
package com.java110.common.listener.workflow;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.annotation.Java110Listener;
import com.java110.core.context.DataFlowContext;
import com.java110.entity.center.Business;
import com.java110.po.workflow.WorkflowStepStaffPo;
import com.java110.utils.constant.BusinessTypeConstant;
import com.java110.utils.constant.ResponseConstant;
import com.java110.utils.constant.StatusConstant;
import com.java110.utils.exception.ListenerExecuteException;
import com.java110.utils.util.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 修改工作流节点信息 侦听
 * <p>
 * 处理节点
 * 1、businessWorkflowStepStaff:{} 工作流节点基本信息节点
 * 2、businessWorkflowStepStaffAttr:[{}] 工作流节点属性信息节点
 * 3、businessWorkflowStepStaffPhoto:[{}] 工作流节点照片信息节点
 * 4、businessWorkflowStepStaffCerdentials:[{}] 工作流节点证件信息节点
 * 协议地址 ：https://github.com/java110/MicroCommunity/wiki/%E4%BF%AE%E6%94%B9%E5%95%86%E6%88%B7%E4%BF%A1%E6%81%AF-%E5%8D%8F%E8%AE%AE
 * Created by wuxw on 2018/5/18.
 */
@Java110Listener("updateWorkflowStepStaffInfoListener")
@Transactional
public class UpdateWorkflowStepStaffInfoListener extends AbstractWorkflowStepStaffBusinessServiceDataFlowListener {

    private static Logger logger = LoggerFactory.getLogger(UpdateWorkflowStepStaffInfoListener.class);
    @Autowired
    private IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public String getBusinessTypeCd() {
        return BusinessTypeConstant.BUSINESS_TYPE_UPDATE_WORKFLOW_STEP_STAFF;
    }

    /**
     * business过程
     *
     * @param dataFlowContext 上下文对象
     * @param business        业务对象
     */
    @Override
    protected void doSaveBusiness(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Assert.notEmpty(data, "没有datas 节点，或没有子节点需要处理");


        //处理 businessWorkflowStepStaff 节点
        if (data.containsKey(WorkflowStepStaffPo.class.getSimpleName())) {
            Object _obj = data.get(WorkflowStepStaffPo.class.getSimpleName());
            JSONArray businessWorkflowStepStaffs = null;
            if (_obj instanceof JSONObject) {
                businessWorkflowStepStaffs = new JSONArray();
                businessWorkflowStepStaffs.add(_obj);
            } else {
                businessWorkflowStepStaffs = (JSONArray) _obj;
            }
            //JSONObject businessWorkflowStepStaff = data.getJSONObject(WorkflowStepStaffPo.class.getSimpleName());
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffs.size(); _workflowStepStaffIndex++) {
                JSONObject businessWorkflowStepStaff = businessWorkflowStepStaffs.getJSONObject(_workflowStepStaffIndex);
                doBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);
                if (_obj instanceof JSONObject) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaff.getString("wssId"));
                }
            }
        }
    }


    /**
     * business to instance 过程
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doBusinessToInstance(DataFlowContext dataFlowContext, Business business) {

        JSONObject data = business.getDatas();

        Map info = new HashMap();
        info.put("bId", business.getbId());
        info.put("operate", StatusConstant.OPERATE_ADD);

        //工作流节点信息
        List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(info);
        if (businessWorkflowStepStaffInfos != null && businessWorkflowStepStaffInfos.size() > 0) {
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size(); _workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
                if (businessWorkflowStepStaffInfo.size() == 1) {
                    dataFlowContext.addParamOut("wssId", businessWorkflowStepStaffInfo.get("wss_id"));
                }
            }
        }

    }

    /**
     * 撤单
     *
     * @param dataFlowContext 数据对象
     * @param business        当前业务对象
     */
    @Override
    protected void doRecover(DataFlowContext dataFlowContext, Business business) {

        String bId = business.getbId();
        //Assert.hasLength(bId,"请求报文中没有包含 bId");
        Map info = new HashMap();
        info.put("bId", bId);
        info.put("statusCd", StatusConstant.STATUS_CD_VALID);
        Map delInfo = new HashMap();
        delInfo.put("bId", business.getbId());
        delInfo.put("operate", StatusConstant.OPERATE_DEL);
        //工作流节点信息
        List<Map> workflowStepStaffInfo = workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(info);
        if (workflowStepStaffInfo != null && workflowStepStaffInfo.size() > 0) {

            //工作流节点信息
            List<Map> businessWorkflowStepStaffInfos = workflowStepStaffServiceDaoImpl.getBusinessWorkflowStepStaffInfo(delInfo);
            //除非程序出错了，这里不会为空
            if (businessWorkflowStepStaffInfos == null || businessWorkflowStepStaffInfos.size() == 0) {
                throw new ListenerExecuteException(ResponseConstant.RESULT_CODE_INNER_ERROR, "撤单失败（workflowStepStaff），程序内部异常,请检查！ " + delInfo);
            }
            for (int _workflowStepStaffIndex = 0; _workflowStepStaffIndex < businessWorkflowStepStaffInfos.size(); _workflowStepStaffIndex++) {
                Map businessWorkflowStepStaffInfo = businessWorkflowStepStaffInfos.get(_workflowStepStaffIndex);
                flushBusinessWorkflowStepStaffInfo(businessWorkflowStepStaffInfo, StatusConstant.STATUS_CD_VALID);
                workflowStepStaffServiceDaoImpl.updateWorkflowStepStaffInfoInstance(businessWorkflowStepStaffInfo);
            }
        }

    }


    /**
     * 处理 businessWorkflowStepStaff 节点
     *
     * @param business                  总的数据节点
     * @param businessWorkflowStepStaff 工作流节点节点
     */
    private void doBusinessWorkflowStepStaff(Business business, JSONObject businessWorkflowStepStaff) {

        Assert.jsonObjectHaveKey(businessWorkflowStepStaff, "wssId", "businessWorkflowStepStaff 节点下没有包含 wssId 节点");

        if (businessWorkflowStepStaff.getString("wssId").startsWith("-")) {
            throw new ListenerExecuteException(ResponseConstant.RESULT_PARAM_ERROR, "wssId 错误，不能自动生成（必须已经存在的wssId）" + businessWorkflowStepStaff);
        }
        //自动保存DEL
        autoSaveDelBusinessWorkflowStepStaff(business, businessWorkflowStepStaff);

        businessWorkflowStepStaff.put("bId", business.getbId());
        businessWorkflowStepStaff.put("operate", StatusConstant.OPERATE_ADD);
        //保存工作流节点信息
        workflowStepStaffServiceDaoImpl.saveBusinessWorkflowStepStaffInfo(businessWorkflowStepStaff);

    }


    @Override
    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }


}

 service-common/src/main/java/com/java110/common/smo/impl/WorkflowInnerServiceSMOImpl.java

New file
@@ -0,0 +1,111 @@
package com.java110.common.smo.impl;


import com.java110.common.dao.IWorkflowServiceDao;
import com.java110.core.smo.common.IWorkflowInnerServiceSMO;
import com.java110.dto.workflow.WorkflowDto;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.core.base.smo.BaseServiceSMO;
import com.java110.dto.user.UserDto;
import com.java110.core.smo.user.IUserInnerServiceSMO;
import com.java110.dto.PageDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName FloorInnerServiceSMOImpl
 * @Description 工作流内部服务实现类
 * @Author wuxw
 * @Date 2019/4/24 9:20
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@RestController
public class WorkflowInnerServiceSMOImpl extends BaseServiceSMO implements IWorkflowInnerServiceSMO {

    @Autowired
    private IWorkflowServiceDao workflowServiceDaoImpl;

    @Autowired
    private IUserInnerServiceSMO userInnerServiceSMOImpl;

    @Override
    public List<WorkflowDto> queryWorkflows(@RequestBody  WorkflowDto workflowDto) {

        //校验是否传了 分页信息

        int page = workflowDto.getPage();

        if (page != PageDto.DEFAULT_PAGE) {
            workflowDto.setPage((page - 1) * workflowDto.getRow());
        }

        List<WorkflowDto> workflows = BeanConvertUtil.covertBeanList(workflowServiceDaoImpl.getWorkflowInfo(BeanConvertUtil.beanCovertMap(workflowDto)), WorkflowDto.class);

        if (workflows == null || workflows.size() == 0) {
            return workflows;
        }

        String[] userIds = getUserIds(workflows);
        //根据 userId 查询用户信息
        List<UserDto> users = userInnerServiceSMOImpl.getUserInfo(userIds);

        for (WorkflowDto workflow : workflows) {
            refreshWorkflow(workflow, users);
        }
        return workflows;
    }

    /**
     * 从用户列表中查询用户，将用户中的信息 刷新到 floor对象中
     *
     * @param workflow 小区工作流信息
     * @param users 用户列表
     */
    private void refreshWorkflow(WorkflowDto workflow, List<UserDto> users) {
        for (UserDto user : users) {
            if (workflow.getFlowId().equals(user.getUserId())) {
                BeanConvertUtil.covertBean(user, workflow);
            }
        }
    }

    /**
     * 获取批量userId
     *
     * @param workflows 小区楼信息
     * @return 批量userIds 信息
     */
     private String[] getUserIds(List<WorkflowDto> workflows) {
        List<String> userIds = new ArrayList<String>();
        for (WorkflowDto workflow : workflows) {
            userIds.add(workflow.getFlowId());
        }

        return userIds.toArray(new String[userIds.size()]);
    }

    @Override
    public int queryWorkflowsCount(@RequestBody WorkflowDto workflowDto) {
        return workflowServiceDaoImpl.queryWorkflowsCount(BeanConvertUtil.beanCovertMap(workflowDto));    }

    public IWorkflowServiceDao getWorkflowServiceDaoImpl() {
        return workflowServiceDaoImpl;
    }

    public void setWorkflowServiceDaoImpl(IWorkflowServiceDao workflowServiceDaoImpl) {
        this.workflowServiceDaoImpl = workflowServiceDaoImpl;
    }

    public IUserInnerServiceSMO getUserInnerServiceSMOImpl() {
        return userInnerServiceSMOImpl;
    }

    public void setUserInnerServiceSMOImpl(IUserInnerServiceSMO userInnerServiceSMOImpl) {
        this.userInnerServiceSMOImpl = userInnerServiceSMOImpl;
    }
}

 service-common/src/main/java/com/java110/common/smo/impl/WorkflowStepInnerServiceSMOImpl.java

New file
@@ -0,0 +1,111 @@
package com.java110.common.smo.impl;


import com.java110.common.dao.IWorkflowStepServiceDao;
import com.java110.core.smo.common.IWorkflowStepInnerServiceSMO;
import com.java110.dto.workflow.WorkflowStepDto;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.core.base.smo.BaseServiceSMO;
import com.java110.dto.user.UserDto;
import com.java110.core.smo.user.IUserInnerServiceSMO;
import com.java110.dto.PageDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName FloorInnerServiceSMOImpl
 * @Description 工作流节点内部服务实现类
 * @Author wuxw
 * @Date 2019/4/24 9:20
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@RestController
public class WorkflowStepInnerServiceSMOImpl extends BaseServiceSMO implements IWorkflowStepInnerServiceSMO {

    @Autowired
    private IWorkflowStepServiceDao workflowStepServiceDaoImpl;

    @Autowired
    private IUserInnerServiceSMO userInnerServiceSMOImpl;

    @Override
    public List<WorkflowStepDto> queryWorkflowSteps(@RequestBody  WorkflowStepDto workflowStepDto) {

        //校验是否传了 分页信息

        int page = workflowStepDto.getPage();

        if (page != PageDto.DEFAULT_PAGE) {
            workflowStepDto.setPage((page - 1) * workflowStepDto.getRow());
        }

        List<WorkflowStepDto> workflowSteps = BeanConvertUtil.covertBeanList(workflowStepServiceDaoImpl.getWorkflowStepInfo(BeanConvertUtil.beanCovertMap(workflowStepDto)), WorkflowStepDto.class);

        if (workflowSteps == null || workflowSteps.size() == 0) {
            return workflowSteps;
        }

        String[] userIds = getUserIds(workflowSteps);
        //根据 userId 查询用户信息
        List<UserDto> users = userInnerServiceSMOImpl.getUserInfo(userIds);

        for (WorkflowStepDto workflowStep : workflowSteps) {
            refreshWorkflowStep(workflowStep, users);
        }
        return workflowSteps;
    }

    /**
     * 从用户列表中查询用户，将用户中的信息 刷新到 floor对象中
     *
     * @param workflowStep 小区工作流节点信息
     * @param users 用户列表
     */
    private void refreshWorkflowStep(WorkflowStepDto workflowStep, List<UserDto> users) {
        for (UserDto user : users) {
            if (workflowStep.getFlowId().equals(user.getUserId())) {
                BeanConvertUtil.covertBean(user, workflowStep);
            }
        }
    }

    /**
     * 获取批量userId
     *
     * @param workflowSteps 小区楼信息
     * @return 批量userIds 信息
     */
     private String[] getUserIds(List<WorkflowStepDto> workflowSteps) {
        List<String> userIds = new ArrayList<String>();
        for (WorkflowStepDto workflowStep : workflowSteps) {
            userIds.add(workflowStep.getFlowId());
        }

        return userIds.toArray(new String[userIds.size()]);
    }

    @Override
    public int queryWorkflowStepsCount(@RequestBody WorkflowStepDto workflowStepDto) {
        return workflowStepServiceDaoImpl.queryWorkflowStepsCount(BeanConvertUtil.beanCovertMap(workflowStepDto));    }

    public IWorkflowStepServiceDao getWorkflowStepServiceDaoImpl() {
        return workflowStepServiceDaoImpl;
    }

    public void setWorkflowStepServiceDaoImpl(IWorkflowStepServiceDao workflowStepServiceDaoImpl) {
        this.workflowStepServiceDaoImpl = workflowStepServiceDaoImpl;
    }

    public IUserInnerServiceSMO getUserInnerServiceSMOImpl() {
        return userInnerServiceSMOImpl;
    }

    public void setUserInnerServiceSMOImpl(IUserInnerServiceSMO userInnerServiceSMOImpl) {
        this.userInnerServiceSMOImpl = userInnerServiceSMOImpl;
    }
}

 service-common/src/main/java/com/java110/common/smo/impl/WorkflowStepStaffInnerServiceSMOImpl.java

New file
@@ -0,0 +1,111 @@
package com.java110.common.smo.impl;


import com.java110.common.dao.IWorkflowStepStaffServiceDao;
import com.java110.core.smo.common.IWorkflowStepStaffInnerServiceSMO;
import com.java110.dto.workflow.WorkflowStepStaffDto;
import com.java110.utils.util.BeanConvertUtil;
import com.java110.core.base.smo.BaseServiceSMO;
import com.java110.dto.user.UserDto;
import com.java110.core.smo.user.IUserInnerServiceSMO;
import com.java110.dto.PageDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName FloorInnerServiceSMOImpl
 * @Description 工作流节点内部服务实现类
 * @Author wuxw
 * @Date 2019/4/24 9:20
 * @Version 1.0
 * add by wuxw 2019/4/24
 **/
@RestController
public class WorkflowStepStaffInnerServiceSMOImpl extends BaseServiceSMO implements IWorkflowStepStaffInnerServiceSMO {

    @Autowired
    private IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl;

    @Autowired
    private IUserInnerServiceSMO userInnerServiceSMOImpl;

    @Override
    public List<WorkflowStepStaffDto> queryWorkflowStepStaffs(@RequestBody  WorkflowStepStaffDto workflowStepStaffDto) {

        //校验是否传了 分页信息

        int page = workflowStepStaffDto.getPage();

        if (page != PageDto.DEFAULT_PAGE) {
            workflowStepStaffDto.setPage((page - 1) * workflowStepStaffDto.getRow());
        }

        List<WorkflowStepStaffDto> workflowStepStaffs = BeanConvertUtil.covertBeanList(workflowStepStaffServiceDaoImpl.getWorkflowStepStaffInfo(BeanConvertUtil.beanCovertMap(workflowStepStaffDto)), WorkflowStepStaffDto.class);

        if (workflowStepStaffs == null || workflowStepStaffs.size() == 0) {
            return workflowStepStaffs;
        }

        String[] userIds = getUserIds(workflowStepStaffs);
        //根据 userId 查询用户信息
        List<UserDto> users = userInnerServiceSMOImpl.getUserInfo(userIds);

        for (WorkflowStepStaffDto workflowStepStaff : workflowStepStaffs) {
            refreshWorkflowStepStaff(workflowStepStaff, users);
        }
        return workflowStepStaffs;
    }

    /**
     * 从用户列表中查询用户，将用户中的信息 刷新到 floor对象中
     *
     * @param workflowStepStaff 小区工作流节点信息
     * @param users 用户列表
     */
    private void refreshWorkflowStepStaff(WorkflowStepStaffDto workflowStepStaff, List<UserDto> users) {
        for (UserDto user : users) {
            if (workflowStepStaff.getWssId().equals(user.getUserId())) {
                BeanConvertUtil.covertBean(user, workflowStepStaff);
            }
        }
    }

    /**
     * 获取批量userId
     *
     * @param workflowStepStaffs 小区楼信息
     * @return 批量userIds 信息
     */
     private String[] getUserIds(List<WorkflowStepStaffDto> workflowStepStaffs) {
        List<String> userIds = new ArrayList<String>();
        for (WorkflowStepStaffDto workflowStepStaff : workflowStepStaffs) {
            userIds.add(workflowStepStaff.getWssId());
        }

        return userIds.toArray(new String[userIds.size()]);
    }

    @Override
    public int queryWorkflowStepStaffsCount(@RequestBody WorkflowStepStaffDto workflowStepStaffDto) {
        return workflowStepStaffServiceDaoImpl.queryWorkflowStepStaffsCount(BeanConvertUtil.beanCovertMap(workflowStepStaffDto));    }

    public IWorkflowStepStaffServiceDao getWorkflowStepStaffServiceDaoImpl() {
        return workflowStepStaffServiceDaoImpl;
    }

    public void setWorkflowStepStaffServiceDaoImpl(IWorkflowStepStaffServiceDao workflowStepStaffServiceDaoImpl) {
        this.workflowStepStaffServiceDaoImpl = workflowStepStaffServiceDaoImpl;
    }

    public IUserInnerServiceSMO getUserInnerServiceSMOImpl() {
        return userInnerServiceSMOImpl;
    }

    public void setUserInnerServiceSMOImpl(IUserInnerServiceSMO userInnerServiceSMOImpl) {
        this.userInnerServiceSMOImpl = userInnerServiceSMOImpl;
    }
}