package cn.ksource.web.facade.question;

import cn.ksource.beans.*;
import cn.ksource.core.dao.BaseDao;
import cn.ksource.core.dao.SqlParameter;
import cn.ksource.core.page.PageInfo;
import cn.ksource.core.util.*;
import cn.ksource.core.web.SysInfoMsg;
import cn.ksource.core.web.WebUtil;
import cn.ksource.core.workflow.*;
import cn.ksource.web.Constants;
import cn.ksource.web.controller.wechat.util.WechatConstants;
import cn.ksource.web.facade.message.MessageFacade;
import cn.ksource.web.service.DataDictionaryService;
import cn.ksource.web.service.WorkOrderCodeService;
import cn.ksource.web.service.device.DeviceService;
import cn.ksource.web.service.file.FileService;
import cn.ksource.web.service.order.OrderService;
import cn.ksource.web.service.record.RecordService;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service("questionFacade")
public class QuestionFacadeImpl implements QuestionFacade {

	@Autowired
	private BaseDao baseDao;

	@Autowired
	private FileService fileService;

	@Autowired
	private RecordService recordService;

	@Autowired
	private OrderService orderService;

	@Autowired
	private DeviceService deviceService;

	@Autowired
	private WorkOrderCodeService workOrderCodeService;

	@Autowired
	private WorkflowBusinessService workflowBusinessService;

	@Autowired
	private WorkflowCoreService workflowCoreService;

	@Autowired
	private MessageFacade messageFacade;

	@Autowired
	private DataDictionaryService dataDictionaryService;

	@Override
	public Map getQuestionMsgByOrderId(HttpServletRequest request) {
		String orderId = request.getParameter("changeId");
		String bustype = request.getParameter("bustype");
		Map questionmsg = new HashMap();
		Map ordermsg = new HashMap();
		Map param = new HashMap();
		param.put("orderId", orderId);
		if(!StringUtil.isEmpty(bustype)&&!StringUtil.isEmpty(orderId)){
			if(Constants.WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT == ConvertUtil.obj2Int(bustype)){
				questionmsg = baseDao.queryForMap("SELECT A.*,B.WFSTATE FROM SC_WORKFLOW_INCIDENT A,WORKFLOW_BASE B WHERE A.ID = B.BUSINESS_ID AND A.ID = :orderId ", param);
			}else if(Constants.WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT_LOCAL == ConvertUtil.obj2Int(bustype)){
				questionmsg = baseDao.queryForMap("SELECT A.*,B.WFSTATE FROM SC_WORKFLOW_INCIDENT_LOCAL A,WORKFLOW_BASE B WHERE A.ID = B.BUSINESS_ID AND A.ID = :orderId ", param);
			}
			List<Map> cilist = deviceService.queryLinkDevices(ConvertUtil.obj2StrBlank(questionmsg.get("FLOW_ID")));
			List<Map> orderlist = orderService.queryLinkOrders(ConvertUtil.obj2StrBlank(questionmsg.get("FLOW_ID")));
			List<Map> filelist = fileService.getFileList(ConvertUtil.obj2StrBlank(questionmsg.get("FLOW_ID")));
			questionmsg.put("ciList", cilist);
			questionmsg.put("orderList", orderlist);
			for(Map file:filelist){
				file.put("ID", "");
			}
			questionmsg.put("filelist", filelist);
		}
		return questionmsg;
	}

	@Override
	public Map saveQuestion(HttpServletRequest request,
			SC_WORKFLOW_QUESTION sc_workflow_question) {

		String changeId = request.getParameter("changeId");
		String bustype = request.getParameter("bustype");
		Map resultMap = new HashMap();
		resultMap.put("result", 2);
        Map user = WebUtil.getLoginUser(request).getLoginUser();
        String sh = request.getParameter("sh");
        String flowId = request.getParameter("flowId");
        String nodeId = request.getParameter("nodeId");
		String bz = request.getParameter("bz");
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		String serivceListId = request.getParameter("serivceListId");
		String serivceList = request.getParameter("serivceList");
		String first_category_id = new String();
		String first_category_name = new String();
		String second_category_id = new String();
		String second_category_name = new String();
		String third_category_id = new String();
		String third_category_name = new String();

		if(StringUtil.notEmpty(serivceListId) && StringUtil.notEmpty(serivceList)) {
			String[] serivceListIds = serivceListId.split("-");
			String[] serivceLists = serivceList.split("->");
			first_category_id = serivceListIds[0];
			first_category_name = serivceLists[0];
			second_category_id = serivceListIds[1];
			second_category_name = serivceLists[1];
			third_category_id = serivceListIds[2];
			third_category_name = serivceLists[2];
		}
		String selectUser = request.getParameter("selectUser");
		if(StringUtil.notEmpty(selectUser)) {
			String[] userMsg = selectUser.split("&");
			String state = Constants.SC_WORKFLOW_QUESTION_STATE_SL;
			String dealer_type = "1";
			String dealUserId = userId;
			String dealUserName = userName;
			String nextnodeid = "";
			if(userMsg.length==4) {
				dealer_type = userMsg[0];
				nextnodeid = userMsg[1];
				dealUserId = userMsg[2];
				dealUserName = userMsg[3];

				if(nextnodeid.equals(Constants.WTSL)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_SL;
				} else if(nextnodeid.equals(Constants.WTSH)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_SH;
				} else if(nextnodeid.equals(Constants.WTZD)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_WTZD;
				} else if(nextnodeid.equals(Constants.WTFASP)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_FASP;
				} else if(nextnodeid.equals(Constants.WTFASS)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_FASS;
				} else if(nextnodeid.equals(Constants.WTHG)) {
					state = Constants.SC_WORKFLOW_QUESTION_STATE_HG;
				}else{
					state = Constants.SC_WORKFLOW_QUESTION_STATE_YDJ;
				}

				String sla_id = request.getParameter("sla_id");
				String sla_name = request.getParameter("sla_name");
				String order_code = workOrderCodeService.getQuestionOrderCode();
				long createTime = DateUtil.getCurrentDate14();
				sc_workflow_question.setPri_level_id(sla_id).setPri_level(sla_name)
				.setFirst_category_id(first_category_id).setFirst_category_name(first_category_name)
				.setSecond_category_id(second_category_id).setSecond_category_name(second_category_name)
				.setThird_category_id(third_category_id).setThird_category_name(third_category_name);
				if(StringUtil.isBlank(sc_workflow_question.getId())){
					sc_workflow_question.setCreate_user_id(userId).setCreate_user_name(userName).setCreate_time(createTime);
					sc_workflow_question.setOrder_code(order_code);
				}

				sc_workflow_question.setState(ConvertUtil.obj2Integer(state)).setFlow_name(sc_workflow_question.getName()).insertOrUpdate();

				//获取当前所处的节点
				Map flowMsg = getFlowMsg(flowId,userId);
				String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
				String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
				if("1".equals(sh)){

					//增加问题处理记录
					GG_RECORD record = new GG_RECORD();
					record.setDeal_content("修改问题："+userName+"修改了问题信息");
					record.setDeal_time(DateUtil.getCurrentDate14());
					record.setDeal_user_id("1");
					record.setDeal_user_name(userName);
					record.setBusiness_id(flowId);
					record.setNode_id(nodeid).setNode_name(nodeName);
					recordService.addRecord(record);
				}



				if(!"1".equals(sh)){
					WORKFLOW_BASE base = new WORKFLOW_BASE();
					if(!"2".equals(sh)){
						//发起流程
						base =  workflowBusinessService.startQuestionWorkflow(sc_workflow_question.getId(),bz);
						//增加问题处理记录
						GG_RECORD record = new GG_RECORD();
						record.setDeal_content("创建问题："+userName+"创建了问题");
						record.setDeal_time(DateUtil.getCurrentDate14());
						record.setDeal_user_id("1");
						record.setDeal_user_name(userName);
						record.setBusiness_id(base.getId());
						record.setNode_id(nodeid).setNode_name(nodeName);
						recordService.addRecord(record);
						flowId = base.getId();
					}else{

						base = new WORKFLOW_BASE(flowId).getInstanceById();

						NodeFinishEntity finishEntity = new NodeFinishEntity();
						finishEntity.setDeal_result(1);
						finishEntity.setDeal_note_title(userName+"完成了节点");
						finishEntity.setDeal_note(userName+"完成了节点");
						WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
						//关闭当前节点
						workflowCoreService.finishNode(base, node, finishEntity);

					}


					NodeDealEntity entity = new NodeDealEntity();
					List<Map> userMap = new ArrayList();
					if("2".equals(sh)){
						dealer_type = "2";
						entity.setBefore_Dealer_type(2);
						WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
						WORKFLOW_NODE beforenode = new WORKFLOW_NODE(node.getSource_node_instance_id()).getInstanceById();
						String node_template_id = beforenode.getNode_template_id();
						nextnodeid = node_template_id;
						String sql = "SELECT * FROM WORKFLOW_NODE WHERE FLOWID = :flowid AND NODE_TEMPLATE_ID = :node_template_id AND IS_ADMIN = :is_admin ";
						Map param = new HashMap();
						param.put("flowid", beforenode.getFlowid());
						param.put("node_template_id", node_template_id);
						param.put("is_admin", "1");
						Map nodeMap = baseDao.queryForMap(sql, param);
						Map map = new HashMap();
						map.put("USER_ID", nodeMap.get("CURRENT_DEALER_ID"));
						map.put("USER_NAME", nodeMap.get("CURRENT_DEALER_NAME"));
						map.put("IS_ADMIN", "1");
						userMap.add(map);
						entity.setDealerList(userMap);
						dealUserName = ConvertUtil.obj2StrBlank(nodeMap.get("CURRENT_DEALER_NAME"));
					}else{
						dealer_type = getDealUser(entity,flowId,dealer_type,userMap,dealUserId,dealUserName);
					}
					workflowCoreService.toNode(base,nextnodeid , entity);

					String hasMsg = request.getParameter("hasMsg");
					/*if(StringUtil.notEmptyNum(hasMsg) && hasMsg.equals("2")) {
						//保存联系人的信息
						CUSTOMER_CONTACTS project_contacts = new CUSTOMER_CONTACTS();
						project_contacts.setId(StringUtil.getUUID()).setCustomer_id(sc_workflow_question.getCustomer_id())
						.setContact_name(sc_workflow_question.getContact_name()).setContacts_type(sc_workflow_question.getContact_phone()).setYwks(sc_workflow_question.getKeshi())
						.setIs_satis(0).setState(1).setIsemail(1).setIsphone(1).setAllow_login(2).setSub_customer_id(sc_workflow_question.getSub_customer_id()).setSub_customer_name(sc_workflow_question.getSub_customer_name());
						project_contacts.insert();
					}*/
					String wxUrl = WechatConstants.ORDER_INCIDENT_DETAIL_ADDRESS+"?nodeId="+base.getCurrent_node_id()+"&orderId="+base.getBusiness_id()+"&orderType="+Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION;
					//发送消息
					GG_MESSAGE message = new GG_MESSAGE();
					message.setTitle(base.getWfname())
					.setContent(base.getWfname())
					.setSender_id(userId)
					.setSender_name(userName)
					.setSend_time(DateUtil.getCurrentDate14())
					.setBusiness_id(base.getBusiness_id())
					.setWeb_url(Constants.QUESTION_WEB_MSG_URL+"?flowId="+base.getId()+"&orderId="+base.getBusiness_id())
					.setWx_url(wxUrl)
					.setOrder_code(sc_workflow_question.getOrder_code())
					.setType(Constants.GG_MESSAGE_TYPE_WTGL);
					messageFacade.doSendMessage(message, userMap);
					resultMap.put("result", 1);


				}
				String usertype = "1";
				if("1".equals(dealer_type)){
					usertype = "2";
				}
				Map paramuser = new HashMap();
				paramuser.put("ID", StringUtil.getUUID());
				paramuser.put("WORKFLOWID", sc_workflow_question.getFlow_id());
				paramuser.put("PNAME", "处理人");
				paramuser.put("PVALUE", usertype+"@"+selectUser);
				if(nextnodeid.equals(Constants.WTSL)) {
					baseDao.execute("INSERT INTO WORKFLOW_PARAMETER(ID,WORKFLOWID,PNAME,PVALUE) VALUES(:ID,:WORKFLOWID,:PNAME,:PVALUE)", paramuser);
				} else if(nextnodeid.equals(Constants.WTSH)) {
					baseDao.execute("UPDATE WORKFLOW_PARAMETER SET PVALUE=:PVALUE WHERE WORKFLOWID = :WORKFLOWID AND PNAME = :PNAME ", paramuser);
				}

				Map paramrecord = new HashMap();
				paramrecord.put("flowId", flowId);
				//提交工单时添加关联工单
				//先删除已存在的工单
				baseDao.execute("DELETE FROM ORDER_REF_ORDER WHERE BUSINESS_ID = :flowId ", paramrecord);
				String[] orderId = request.getParameterValues("orderId");
				orderService.saveLinkOrders(flowId,orderId,request);

				//提交工单时上传文档附件
				fileService.uploadFile(request,flowId,flowId,null,null,Constants.GG_FOLDERS_WTFOLDERS,Constants.FILE_STATE_SHTG,null);


				//提交工单时添加关联设备
				//先删除已存在的设备
				baseDao.execute("DELETE FROM CMDB_CI_REF_ORDER WHERE FLOW_ID = :flowId ", paramrecord);
				String[] deviceId = request.getParameterValues("deviceId");
				deviceService.saveLinkDevices(flowId,deviceId);
				SysInfoMsg msg = new SysInfoMsg(dealer_type,dealUserName,Constants.questionNode.get(nextnodeid));
				resultMap.put("msg", msg);
			}
			//事件转问题
			if(!StringUtil.isEmpty(changeId)){
				if(Constants.WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT == ConvertUtil.obj2Int(bustype)){
					SC_WORKFLOW_INCIDENT incident = new SC_WORKFLOW_INCIDENT(changeId);
					incident.setQuestionid(sc_workflow_question.getId()).update();
				}else if(Constants.WORKFLOW_BASE_BUSINESS_TYPE_INCIDENT_LOCAL == ConvertUtil.obj2Int(bustype)){
					SC_WORKFLOW_INCIDENT_LOCAL zcyw = new SC_WORKFLOW_INCIDENT_LOCAL(changeId);
					zcyw.setQuestionid(sc_workflow_question.getId()).update();
				}
			}

		}else{
			resultMap.put("nouser", "1");
		}
		return resultMap;
	}

    public String getDealUser(NodeDealEntity entity,String flowId,String dealer_type,List<Map> userMap,String dealUserId,String dealUserName) {
    	Map param = new HashMap();
		param.put("ID", StringUtil.getUUID());
		param.put("WORKFLOWID", flowId);
		param.put("PNAME", "处理人");

    	entity.setDealer_type(3);
		if(dealer_type.equals("1")||dealer_type.equals("3")) {
			entity.setBefore_Dealer_type(2);
			String sqluser = "select * from gg_user ";
			List<Map> userList = baseDao.queryForList(sqluser);
			Map cacheuser = new HashMap();
			for(Map users:userList){
				cacheuser.put(users.get("ID"), users.get("ZSXM"));
			}
			String[] userList2 = dealUserId.split(",");
			String[] userNameList2 = dealUserName.split(",");
			for(int i=0;i<userList2.length;i++){
				Map map = new HashMap();
				if(userList2[i].split("-").length == 2){
					map.put("USER_ID", userList2[i].split("-")[0]);
					map.put("IS_ADMIN", "1");
					map.put("USER_NAME", cacheuser.get(userList2[i].split("-")[0]));
					param.put("PVALUE", "1"+"&"+userList2[i].split("-")[0]+"-1");
				}else{
					map.put("USER_ID", userList2[i]);
					map.put("USER_NAME", cacheuser.get(userList2[i]));
				}

				userMap.add(map);
			}
			dealer_type = "2";
		} else {
			entity.setBefore_Dealer_type(1);
			entity.setRoleID(dealUserId);
			entity.setRoleName(dealUserName);
			param.put("PVALUE", "2"+"&"+dealUserId);
			//查询改角色下面的所有人员信息
			String sqlUser = "SELECT B.ID AS USER_ID ,B.ZSXM AS USER_NAME FROM AC_USER_REF_ROLE A,GG_USER B WHERE A.YHBH = B.ID AND A.JSBH = :groupId ";
			userMap = baseDao.queryForList(sqlUser,new SqlParameter("groupId",dealUserId));
			dealer_type = "1";
		}
		entity.setDealerList(userMap);

		baseDao.execute("INSERT INTO WORKFLOW_PARAMETER(ID,WORKFLOWID,PNAME,PVALUE) VALUES(:ID,:WORKFLOWID,:PNAME,:PVALUE)", param);
		return dealer_type;
	}

	@Override
	public Map queryQuestionCount(HttpServletRequest request) {
        //初始化变量

		//问题受理响应中
		int wtsldxy = 0;
		//问题受理处理中
		int wtslclz = 0;

		//问题审核待响应
		int wtshdxy = 0;
		//问题审核处理中
		int wtshclz = 0;

		//问题诊断待响应
		int wtzddxy = 0;
		//问题诊断处理中
		int wtzdclz = 0;


		//方案审批待响应
		int faspdxy = 0;
		//方案审批处理中
		int faspclz = 0;

		//方案实施待响应
		int fassdxy = 0;
		//方案实施处理中
		int fassclz = 0;

		//问题回顾待响应
		int wthgdxy = 0;
		//问题回顾处理中
		int wthgclz = 0;

		//已完成
		int ywc = 0;
		//进行中
		int jxz = 0;

		StringBuffer selectSql = new StringBuffer();
		StringBuffer sql = new StringBuffer();

		Map paramMap = new HashMap();
		selectSql.append("SELECT COUNT(*) AS NUM,A.STATE,C.FLOWSTATE FROM SC_WORKFLOW_QUESTION A,WORKFLOW_BASE B LEFT JOIN WORKFLOW_NODE C ON B.ID = C.FLOWID AND B.CURRENT_NODE_ID = C.ID  WHERE A.ID = B.BUSINESS_ID  AND C.FLOWSTATE is not null   ");
		sql.append("SELECT COUNT(ID) FROM SC_WORKFLOW_QUESTION WHERE STATE != :yjj AND STATE !=:gb AND STATE != :ypj ");
		String customerId = request.getParameter("customerId");
	    if(!StringUtil.isEmpty(customerId)) {
		   selectSql.append(" AND B.CUSTOMER_ID = :customerId ");
		   sql.append(" AND CUSTOMER_ID = :customerId ");
		   paramMap.put("customerId", customerId);
	    }

		paramMap.put("flowstate", 3);

		selectSql.append(" GROUP BY A.STATE,C.FLOWSTATE ");
		List<Map> list = baseDao.queryForList(selectSql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int flowstate = 0;
				if(StringUtil.isNotBlank(ConvertUtil.obj2StrBlank(map.get("FLOWSTATE")))){
					flowstate = ConvertUtil.obj2Integer(map.get("FLOWSTATE"));
				}
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						wtsldxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						wtslclz += num;
					}
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						wtshdxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						wtshclz += num;
					}
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						wtzddxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						wtzdclz += num;
					}
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						faspdxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						faspclz += num;
					}
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						fassdxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						fassclz += num;
					}
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE){
						wthgdxy += num;
					}else if(flowstate == Constants.WORKFLOW_NODE_FLOWSTATE_DOING){
						wthgclz += num;
					}
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_YWC)) {
					ywc += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_YPJ)) {
					ywc += num;
					continue;
				}

			}
		}

		Map map = new HashMap();
		map.put("wtsldxy", wtsldxy);
		map.put("wtslclz", wtslclz);

		map.put("wtshdxy", wtshdxy);
		map.put("wtshclz", wtshclz);

		map.put("wtzddxy", wtzddxy);
		map.put("wtzdclz", wtzdclz);

		map.put("faspdxy", faspdxy);
		map.put("faspclz", faspclz);

		map.put("fassdxy", fassdxy);
		map.put("fassclz", fassclz);

		map.put("wthgdxy", wthgdxy);
		map.put("wthgclz", wthgclz);

		//查询该加盟商未完成的事件

		paramMap.put("yjj", Constants.SC_WORKFLOW_QUESTION_STATE_YWC);
		paramMap.put("gb", Constants.SC_WORKFLOW_QUESTION_STATE_YGB);
		paramMap.put("ypj", Constants.SC_WORKFLOW_QUESTION_STATE_YPJ);


		jxz = baseDao.queryForInteger(sql.toString(),paramMap);

		map.put("ywc", ywc);
		map.put("jxz", jxz);

		return map;
	}

	@Override
	public int queryQuestionOrderCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();

		sql.append("SELECT COUNT(WB.ID) FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB LEFT JOIN WORKFLOW_NODE C ON  C.FLOWID = WB.ID AND WB.CURRENT_NODE_ID = C.ID AND C.FLOWSTATE <> 3  ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID AND WB.BUSINESSTYPE = :businessType ");
		sqlpart = getOrderSql(sqlpart,params);
		sql.append(sqlpart);
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo queryQuestionOrderList(PageInfo pageInfo,
			Map<String, String> params) {


		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME,WB.WFNOTE,C.FLOWSTATE , ");
		sql.append("WB.CURRENT_NODE_ID,WB.CURRENT_NODE_NAME,WB.CUSTOMER_NAME,WB.SUB_CUSTOMER_NAME,WB.PROJECT_NAME,WB.CURRENT_DEALER_NAME,WB.BUSINESS_ID,WB.WFSTATE,B.STATE ,B.NAME ");
		sql.append("FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB LEFT JOIN WORKFLOW_NODE C ON  C.FLOWID = WB.ID AND WB.CURRENT_NODE_ID = C.ID AND C.FLOWSTATE <> 3 ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID AND WB.BUSINESSTYPE = :businessType ");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		sqlpart = getOrderSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

	public StringBuilder getOrderSql(StringBuilder sqlpart,Map<String, String> params){
		String customerid = params.get("customerId");
		if(StringUtil.notEmpty(customerid)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}

		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
			params.put("subCustomerId", subCustomerId);
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			String[] state = status.split(",");
			if("ywc".equals(state[0])){
				sqlpart.append( " AND (B.STATE = :state  OR B.STATE = :state1 )");
				params.put("state", Constants.SC_WORKFLOW_QUESTION_STATE_YWC);
				params.put("state1", Constants.SC_WORKFLOW_QUESTION_STATE_YPJ);
			}else if("jxz".equals(state[0])){
				sqlpart.append( " AND (B.STATE != :state  AND B.STATE != :state1 AND B.STATE != :state2 ) ");
				params.put("state", Constants.SC_WORKFLOW_QUESTION_STATE_YWC);
				params.put("state1", Constants.SC_WORKFLOW_QUESTION_STATE_YPJ);
				params.put("state2", Constants.SC_WORKFLOW_QUESTION_STATE_YGB);
			}else if(!"all".equals(state[0])){
				sqlpart.append( " AND B.STATE = :state  ");
				params.put("state", state[0]);
				if(state.length == 2){
					sqlpart.append( "  AND C.FLOWSTATE = :flowstate ");
					params.put("flowstate", state[1]);
				}


			}

		}
		return sqlpart;
	}

	@Override
	public int queryMyQuestionCount(Map<String, String> params) {
		StringBuilder builder = new StringBuilder();
		params.put("ysc",ConvertUtil.obj2StrBlank( Constants.WORKFLOW_BASE_WFSTATE_DELETE));

		/**
		 * 查询逻辑
		 * 1.如果节点状态选择为全部，则查询节点表中处理人是我的，或者处理角色是我的并且没有分配处理人的，
		 * 	 但查询出来的数据会有重复，因为一个节点我可以处理多次，这样查询出来会有重复的工单，需要过滤，如果同一个工单 有待处理，已处理   或者进行中，已处理，则显示待处理 或进行中，不显示已处理 （待处理和进行中是不会同时存在的）
		 * 2.如果节点状态选择为待处理，则查询节点表中处理人是我的，或者处理角色是我的并且没有分配处理人的 （不需要过滤，因为一个工单待处理节点，只会有一个）
		 * 3.如果节点状态选择为进行中，则查询节点表中处理人是我的 （不需要过滤，因为一个工单进行中节点，只会有一个）
		 * 4.如果节点状态查询未已处理，则查询节点表中处理人是我的，需要过滤（因为一个节点一个人可以处理多次，通过节点表作为主表查询出来的工单会有重复）
		 */

		String flowstate = params.get("flowstate");
		if(StringUtil.notEmpty(flowstate)) {
			if(flowstate.equals("1")) {
				builder.append(" SELECT DISTINCT D.* FROM ( ");
				//查询处理人是我的
				builder.append(" SELECT B.WFSTATE,B.CURRENT_NODE_NAME,B.ORDER_CODE,B.CUSTOMER_ID,B.SUB_CUSTOMER_ID,C.NAME,B.BUSINESSTYPE,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID AND A.CURRENT_DEALER_ID = :userId AND A.FLOWSTATE = :jddcl ");
				builder.append(")D");
				builder.append(" WHERE 1 = 1 ");
				params.put("jddcl", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE));
			} else if(flowstate.equals("2")) {
				builder.append(" SELECT DISTINCT D.* FROM ( ");
				builder.append(" SELECT B.WFSTATE,B.CURRENT_NODE_NAME,B.ORDER_CODE,B.CUSTOMER_ID,B.SUB_CUSTOMER_ID,C.NAME,B.BUSINESSTYPE,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID  AND A.CURRENT_DEALER_ID = :userId AND A.FLOWSTATE = :jdjxz");
				builder.append(")D");
				builder.append(" WHERE 1 = 1 ");
				params.put("jdjxz", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_DOING));
			}else {
				builder.append(" SELECT DISTINCT D.* FROM ( ");
				builder.append(" SELECT B.WFSTATE,B.CURRENT_NODE_NAME,B.ORDER_CODE,B.CUSTOMER_ID,B.SUB_CUSTOMER_ID,C.NAME,B.BUSINESSTYPE,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID  FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C  WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID  AND A.CURRENT_DEALER_ID = :userId AND A.FLOWSTATE = :jdywc ");
				builder.append(")D");
				builder.append(" WHERE 1 = 1 ");
				params.put("jdywc", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_FINISH));
			}
		} else {
			builder.append(" SELECT DISTINCT D.* FROM ( ");
			//查询处理人是我的
			builder.append(" SELECT B.WFSTATE,B.CURRENT_NODE_NAME,B.ORDER_CODE,B.CUSTOMER_ID,B.SUB_CUSTOMER_ID,C.NAME,B.BUSINESSTYPE,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID AND A.CURRENT_DEALER_ID = :userId ");
			builder.append(")D");
			builder.append(" WHERE  D.WFSTATE != :ysc  ");
		}

		builder = getMyquestionSql(builder,params);

		builder.append(" AND D.BUSINESSTYPE = :businessType");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		StringBuilder newBuild = new StringBuilder();
		newBuild.append("SELECT COUNT(*) FROM ( ");
		newBuild.append(builder.toString());
		newBuild.append(") E");

		return baseDao.queryForInteger(newBuild.toString(),params);
	}

	@Override
	public PageInfo queryMyQuestionData(PageInfo pageInfo,
			Map<String, String> params) {

		StringBuilder builder = new StringBuilder();
		params.put("ysc", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_WFSTATE_DELETE));


		/**
		 * 查询逻辑
		 * 1.如果节点状态选择为全部，则查询节点表中处理人是我的，或者处理角色是我的并且没有分配处理人的，
		 * 	 但查询出来的数据会有重复，因为一个节点我可以处理多次，这样查询出来会有重复的工单，需要过滤，如果同一个工单 有待处理，已处理   或者进行中，已处理，则显示待处理 或进行中，不显示已处理 （待处理和进行中是不会同时存在的）
		 * 2.如果节点状态选择为待处理，则查询节点表中处理人是我的，或者处理角色是我的并且没有分配处理人的 （不需要过滤，因为一个工单待处理节点，只会有一个）
		 * 3.如果节点状态选择为进行中，则查询节点表中处理人是我的 （不需要过滤，因为一个工单进行中节点，只会有一个）
		 * 4.如果节点状态查询未已处理，则查询节点表中处理人是我的，需要过滤（因为一个节点一个人可以处理多次，通过节点表作为主表查询出来的工单会有重复）
		 */

		String flowstate = params.get("flowstate");
		if(StringUtil.notEmpty(flowstate)) {
			if(flowstate.equals("1")) {
				builder.append(" SELECT D.* FROM ( ");
				//查询处理人是我的
				builder.append(" SELECT B.*,A.FLOWSTATE,C.NAME,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID,C.STATE FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID  AND A.CURRENT_DEALER_ID = :userId ");

				builder.append(")D");
				builder.append(" WHERE D.FLOWSTATE = :jddcl ");
				params.put("jddcl", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE));
			} else if(flowstate.equals("2")) {
				builder.append(" SELECT D.* FROM ( ");
				builder.append(" SELECT B.*,A.FLOWSTATE,C.NAME,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID,C.STATE FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C  WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID AND A.CURRENT_DEALER_ID = :userId AND A.FLOWSTATE = :jdjxz");
				builder.append(")D");
				builder.append(" WHERE 1 = 1 ");
				params.put("jdjxz", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_DOING));
			}else {
				builder.append(" SELECT D.* FROM ( ");
				builder.append(" SELECT DISTINCT B.*,A.FLOWSTATE,C.NAME,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID,C.STATE FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C   WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID  AND A.CURRENT_DEALER_ID = :userId AND  A.FLOWSTATE = :jdywc ");
				builder.append(")D");
				builder.append(" WHERE 1 = 1 ");
				params.put("jdywc", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_NODE_FLOWSTATE_FINISH));
			}
		} else {
			builder.append(" SELECT D.* FROM ( ");
			//查询处理人是我的
			builder.append(" SELECT B.*,A.FLOWSTATE,C.NAME,C.CONTACT_NAME,C.PRIORITY_ID,C.INFLUENCE_ID,C.THIRD_CATEGORY_ID,C.SOURCE_ID,C.STATE FROM WORKFLOW_NODE A,WORKFLOW_BASE B,SC_WORKFLOW_QUESTION C WHERE A.FLOWID = B.ID AND B.BUSINESS_ID = C.ID AND A.CURRENT_DEALER_ID = :userId ");
			builder.append(")D");
			builder.append(" WHERE D.WFSTATE != :ysc ");
		}
		builder = getMyquestionSql(builder,params);

		builder.append(" AND D.BUSINESSTYPE = :businessType");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		String pageSize = pageInfo.getPageSize();
		String currPage = pageInfo.getCurrPage();
		if(!StringUtil.notEmptyNum(pageSize)){
			pageSize = "10";
		}
		if(!StringUtil.notEmptyNum(currPage)){
			currPage = "1";
		}
		int begin = Integer.valueOf(currPage);
		int size = Integer.valueOf(pageSize);

		if(!StringUtil.notEmpty(flowstate)) {
			builder.append( " ORDER BY D.FLOWSTATE,D.CREATETIME DESC" );
			List<Map> result = baseDao.queryForList(builder.toString(),params);
			List resultList = new ArrayList();
			List<String> list = new ArrayList<String>();
			Map cacheMap = new HashMap();
			if(null!=result && result.size()>0) {
				for(Map m : result) {
					String flowId = ConvertUtil.obj2StrBlank(m.get("ID"));
					if(cacheMap.containsKey(flowId)) {
						String flowState = ConvertUtil.obj2StrBlank(m.get("FLOWSTATE"));
						if(flowState.equals(Constants.WORKFLOW_NODE_FLOWSTATE_UNDISPOSE.toString()) || flowState.equals(Constants.WORKFLOW_NODE_FLOWSTATE_DOING.toString())) {
							cacheMap.put(flowId, m);
							if(!list.contains(flowId)) {
								list.add(flowId);
							}
						}
					} else {
						cacheMap.put(flowId, m);
						list.add(flowId);
					}
				}

				if(cacheMap.size()>0) {
					for(String str : list) {
						resultList.add(cacheMap.get(str));
					}
				}
			}

			int infoCount = resultList.size();
			int bin = (begin-1)* size ;
			int end = (begin-1)* size + size;
			if(end>infoCount){
				end=infoCount;
			}
			PageInfo info = new PageInfo();
			info.setDatas(resultList.subList(bin, end));
			info.setRowNum(infoCount);
			return info;
		} else {
			builder.append( " ORDER BY D.CREATETIME DESC ");
			PageInfo result = baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), params);
			return result;
		}
	}

	public StringBuilder getMyquestionSql(StringBuilder builder,Map<String, String> params){
		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			builder.append(" AND D.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND D.SUB_CUSTOMER_ID = :subCustomerId ");
			params.put("subCustomerId", subCustomerId);
		}

		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			builder.append(" AND D.WFSTATE = :status ");
			params.put("status", status);
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			builder.append(" AND D.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}


		String hjName = params.get("hjName");
		if(StringUtil.notEmpty(hjName)) {
			builder.append(" AND D.CURRENT_NODE_NAME LIKE :hjName ");
			params.put("hjName", "%"+hjName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			builder.append(" AND D.ORDER_CODE LIKE :orderCode");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			builder.append(" AND D.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}

		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				builder.append(" AND D.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				builder.append(" AND D.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					builder.append(" :pri"+i);
					builder.append(",");
					params.put("pri"+i, pris[i]);
				}
				builder.deleteCharAt(builder.lastIndexOf(","));
				builder.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				builder.append(" AND D.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				builder.append(" AND D.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					builder.append(" :dg"+i);
					builder.append(",");
					params.put("dg"+i, dgs[i]);
				}
				builder.deleteCharAt(builder.lastIndexOf(","));
				builder.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				builder.append(" AND D.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				builder.append(" AND D.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					builder.append(" :type"+i);
					builder.append(",");
					params.put("type"+i, sources[i]);
				}
				builder.deleteCharAt(builder.lastIndexOf(","));
				builder.append(")");
			}
		}


		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				builder.append(" AND D.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				builder.append(" AND D.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					builder.append(" :third_category_id"+i);
					builder.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				builder.deleteCharAt(builder.lastIndexOf(","));
				builder.append(")");
			}
		}
		return builder;
	}

	@Override
	public Map queryLevel(String priority_id, String influence_id,String customerId) {

		String selectSql = "SELECT LEVEL_ID,LEVEL_NAME FROM SC_SLA_LEVEL_CONFIG WHERE INFLUENCE_ID = :influence_id AND PRIORITY_ID = :priority_id AND CUSTOMER_ID = :customerId";
		Map paramMap = new HashMap();
		paramMap.put("influence_id", influence_id);
		paramMap.put("priority_id", priority_id);
		paramMap.put("customerId", customerId);
		Map levelMap = baseDao.queryForMap(selectSql,paramMap);
		return levelMap;
	}

	@Override
	public List<Map> getFlueNode(HttpServletRequest request) {
		String flowId = request.getParameter("flowId");
		String customer_id = request.getParameter("customer_id");
		String currentNode = new String();
		if(StringUtil.notEmpty(flowId)) {
			Map node = getCurrentNode(flowId);
			currentNode = ConvertUtil.obj2StrBlank(node.get("NODE_TEMPLATE_ID"));
		} else {
			currentNode = Constants.WTFQ;
		}

		//查询当前节点能发送的节点
		String selectSql = "SELECT * FROM QUESTION_FLOWRULE WHERE CUSTOMER_ID = :customer_id";
		List<Map> list = baseDao.queryForList(selectSql,new SqlParameter("customer_id",customer_id));
		Map prom = new HashMap();
		if(null!=list && list.size()>0) {
			prom = list.get(0);

			String json = ConvertUtil.obj2StrBlank(prom.get(Constants.questionNodeColunm.get(currentNode)));
			List<Map> nodes = JsonUtil.json2List(json);
			return nodes;

		}else{
			String gsSql = "SELECT * FROM QUESTION_FLOWRULE WHERE (CUSTOMER_ID IS NULL OR CUSTOMER_ID = '')";
			List<Map> gslist = baseDao.queryForList(gsSql);
			if(null!=gslist && gslist.size()>0){
				prom = gslist.get(0);

				String json = ConvertUtil.obj2StrBlank(prom.get(Constants.questionNodeColunm.get(currentNode)));
				List<Map> nodes = JsonUtil.json2List(json);
				return nodes;
			}
		}
		return new ArrayList<Map>();
	}

	public Map getCurrentNode(String flowId) {
		String selectSql = "SELECT B.NODE_TEMPLATE_ID FROM WORKFLOW_BASE A,WORKFLOW_NODE B WHERE A.CURRENT_NODE_ID = B.ID AND A.ID = :id";
		return baseDao.queryForMap(selectSql,new SqlParameter("id",flowId));
	}

	@Override
	public List<Map> getZdyGroupList(HttpServletRequest request) {
		String customer_id = request.getParameter("customer_id");
		String user_Id = WebUtil.getLoginedUserId(request);
		String sql = "SELECT * FROM CUSTOM_GROUP WHERE CUSTOMER_ID = :customer_id AND CREATE_USER_ID = :create_user_id ";
		Map paramMap = new HashMap();
		paramMap.put("customer_id", customer_id);
		paramMap.put("create_user_id", user_Id);
		List<Map> groupList = baseDao.queryForList(sql, paramMap);
		for(Map map:groupList){
			if(!StringUtil.isEmpty(ConvertUtil.obj2StrBlank(map.get("USER_JSON")))){
				List<Map> userList = JsonUtil.json2List(ConvertUtil.obj2StrBlank(map.get("USER_JSON")));
				StringBuffer userId = new StringBuffer();
				StringBuffer userName = new StringBuffer();
				for(Map map1:userList){
					if("1".equals(map1.get("IS_MASTER"))){
						userId.append(map1.get("userid")+"-1,") ;
						userName.append(map1.get("username")+"(主负责人),") ;
					}else{
						userId.append(map1.get("userid")+",") ;
						userName.append(map1.get("username")+",") ;
					}
				}
				map.put("userlist", userName.deleteCharAt(userName.lastIndexOf(",")));
				map.put("useridlist", userId.deleteCharAt(userId.lastIndexOf(",")));
			}

		}
		return groupList;
	}

	@Override
	public List<Map> groupuser(String groupId) {
		String usersql = "SELECT * FROM CUSTOM_GROUP WHERE GROUP_ID = :group_id";
		List<Map> groupuser = baseDao.queryForList(usersql, new SqlParameter("group_id",groupId));

		return groupuser;
	}

	@Override
	public Map usersbyGroup(HttpServletRequest request) {
		Map main = new HashMap();
		String groupId = request.getParameter("groupId");
		String customer_id = request.getParameter("customer_id");
		String usersql = "SELECT * FROM CUSTOM_GROUP WHERE ID = :group_id";
		Map group = baseDao.queryForMap(usersql, new SqlParameter("group_id",groupId));
		List<Map> groupuser = JsonUtil.json2List(ConvertUtil.obj2StrBlank(group.get("USER_JSON")));
		Map cacheuser = new HashMap();
		for(Map users:groupuser){
			cacheuser.put(users.get("roleid")+"_"+users.get("userid"), users.get("username"));
			users.put("userid",users.get("roleid")+"_"+users.get("userid"));
			if("1".equals(users.get("IS_MASTER"))){
				main.put("userid", users.get("userid"));
				main.put("username", users.get("username"));
			}
		}
		SqlParameter param = new SqlParameter();
		param.put("customer_id", customer_id);
		StringBuilder sql = new StringBuilder();
		List<Map> cateList = new ArrayList<Map>();
		List<Map> userList = new ArrayList<Map>();

		sql.setLength(0);
		sql.append(" select G.ID ,G.ROLENAME from AC_USER_REF_ROLE U,AC_ROLE G WHERE G.ID = U.JSBH AND G.STATE=1 GROUP BY G.ID ORDER BY G.ID");
		cateList = baseDao.queryForList(sql.toString(),param);

		sql.setLength(0);
		sql.append(" select U.JSBH,G.ROLENAME,D.ID,D.ZSXM from AC_USER_REF_ROLE U,AC_ROLE G,GG_USER D WHERE G.ID = U.JSBH AND U.YHBH = D.ID AND D.ZT = 1 AND G.STATE=1 ORDER BY D.ID");
		userList = baseDao.queryForList(sql.toString(),param);
		List<Map> resList = new ArrayList<Map>();
		for(Map cateMap:cateList){
			List<Map> tempList = new ArrayList<Map>();
			Map tempMap = new HashMap();
			tempMap.put("name", cateMap.get("ROLENAME"));
			tempMap.put("id", cateMap.get("ID"));
			for(Map userMap:userList){

				if(cateMap.get("ID").equals(userMap.get("JSBH"))){
					if(cacheuser.containsKey(cateMap.get("ID")+"_"+userMap.get("ID"))){
						userMap.put("check", 1);
					}
					tempList.add(userMap);
				}

			}
			tempMap.put("dataList", tempList);
			resList.add(tempMap);
		}
		main.put("resList", resList);
		main.put("groupuser", groupuser);
		return main;
	}

	@Override
	public void addGroupUser(HttpServletRequest request) {
		String userid = WebUtil.getLoginedUserId(request);
		String groupId = request.getParameter("groupId");
		String customer_id = request.getParameter("customer_id");
		String groupname = request.getParameter("name");
		//人员
		String[] user = request.getParameterValues("users");
		//主要负责人
		String userMain = request.getParameter("userid");

		String sqluser = "SELECT * FROM GG_USER  ";
		List<Map> userList = baseDao.queryForList(sqluser);
		Map cacheuser = new HashMap();
		for(Map users:userList){
			cacheuser.put(users.get("ID"), users.get("ZSXM"));
		}
        List<Map> list = new ArrayList<Map>();

		Map cacheMap = new HashMap();

		for(int i=0;i<user.length;i++){
			String userId = user[i];
			if(!cacheMap.containsKey(userId)) {

				Map map = new HashMap();
				String[] role_user=user[i].split("_");
				String name = ConvertUtil.obj2StrBlank(cacheuser.get(role_user[1]));
				map.put("roleid", role_user[0]);
				map.put("userid", role_user[1]);
				map.put("username", name);
				if (StringUtils.equals(userMain, userId)) {
					map.put("IS_MASTER", "1");
				}else {
					map.put("IS_MASTER", "2");
				}
				list.add(map);
				cacheMap.put(userId, userId);
			}
		}
		CUSTOM_GROUP group = new CUSTOM_GROUP();
		group.setGroup_name(groupname).setUser_json(JsonUtil.list2Json(list));
		if(!StringUtil.isEmpty(groupId)){
			group.setId(groupId);
		}else{
			group.setCustomer_id(customer_id).setCreate_user_id(userid).setCreate_user(ConvertUtil.obj2StrBlank(cacheuser.get(userid)))
			.setCreate_time(DateUtil.getCurrentDate14());
		}
		group.insertOrUpdate();

	}

	/**
	 * 通过orderid获取流程信息
	 */
	@Override
	public Map getFlowMsg(String flowId,String userId) {
		String selectSql = "SELECT * FROM WORKFLOW_NODE WHERE FLOWID = :flowId AND CURRENT_DEALER_ID = :userId AND FLOWSTATE <> 3 ";
		return baseDao.queryForMap(selectSql,new SqlParameter("flowId",flowId).addValue("userId", userId));
	}

	@Override
	public Map queryQuestionBaseMsg(String orderId) {
		String selectSql = "SELECT A.*,B.WFSTATE,N.ANSWER_TIME,B.BUSINESSTYPE,B.CURRENT_DEALER_ID clr FROM SC_WORKFLOW_QUESTION A LEFT JOIN  WORKFLOW_BASE B ON A.ID = B.BUSINESS_ID LEFT JOIN WORKFLOW_NODE N ON B.CURRENT_NODE_ID = N.ID  WHERE A.ID = :orderId  ";
		Map baseMap =  baseDao.queryForMap(selectSql,new SqlParameter("orderId",orderId));
		if("SJSJ".equals(baseMap.get("SOURCE_ID"))){
			String sqlIncident = "SELECT ID,ORDER_CODE,FLOW_ID FROM SC_WORKFLOW_INCIDENT WHERE QUESTIONID = :orderid";
			Map incident = baseDao.queryForMap(sqlIncident, new SqlParameter("orderid",orderId));
			baseMap.put("incidentId", incident.get("ID"));
			baseMap.put("incode", incident.get("ORDER_CODE"));
			baseMap.put("inflow", incident.get("FLOW_ID"));
		}
		if(!StringUtil.isEmpty(ConvertUtil.obj2StrBlank(baseMap.get("REPEAT_ORDER")))){
			String sqlIncident = "SELECT ID,ORDER_CODE,BUSINESS_ID FROM WORKFLOW_BASE WHERE ID = :orderid";
			Map question = baseDao.queryForMap(sqlIncident, new SqlParameter("orderid",baseMap.get("REPEAT_ORDER")));
			baseMap.put("wtId", question.get("BUSINESS_ID"));
			baseMap.put("wtcode", question.get("ORDER_CODE"));
		}

		String sql="select NODENAME from WORKFLOW_NODE node,WORKFLOW_BASE base where node.FLOWID=base.ID AND FLOWSTATE=2 AND base.BUSINESS_ID=:orderId LIMIT 0,1";
		String note=baseDao.queryForString(sql,new SqlParameter("orderId",orderId));
		baseMap.put("note",note);
		//查询当前节点能是否能关闭工单
		String ruleSql = "SELECT CLOSEJD,GOBACKJD FROM QUESTION_FLOWRULE WHERE CUSTOMER_ID = :customer_id";
		Map jd = baseDao.queryForMap(ruleSql,new SqlParameter("customer_id",baseMap.get("CUSTOMER_ID")));
		if(null!=jd && jd.size()>0) {
			baseMap.put("closejd", jd.get("CLOSEJD"));
			baseMap.put("backjd", jd.get("GOBACKJD"));
		}else{
			String gsSql = "SELECT CLOSEJD,GOBACKJD FROM QUESTION_FLOWRULE WHERE (CUSTOMER_ID IS NULL OR CUSTOMER_ID = '')";
			Map gsmap = baseDao.queryForMap(gsSql);
			if(null!=gsmap && gsmap.size()>0){
				baseMap.put("closejd", gsmap.get("CLOSEJD"));
				baseMap.put("backjd", gsmap.get("GOBACKJD"));
			}
		}
		String gsSql = "select * from GG_FILES where DEL_FLAG =1 AND BUSINESS_ID=(select Id from WORKFLOW_BASE WHERE BUSINESS_ID=:orderId) order by  ORDERNUM";
		Map fjList = baseDao.queryForMap(gsSql,new SqlParameter("orderId",orderId));
		if(null!=fjList && fjList.size()>0){
			baseMap.put("files", fjList);
		}


		return baseMap;
	}

	@Override
    public String anwerSubmit(HttpServletRequest request){

        WORKFLOW_BASE base = new WORKFLOW_BASE(request.getParameter("flowId")).getInstanceById();

        WORKFLOW_NODE node = new WORKFLOW_NODE(request.getParameter("nodeId")).getInstanceById();
        NodeAnswerEntity entity = new NodeAnswerEntity();

        Map user = WebUtil.getLoginUser(request).getLoginUser();
        entity.setUser_id(user.get("ID").toString());
        entity.setUser_name(user.get("ZSXM").toString());
        boolean result = workflowCoreService.answerNode(base, node, entity);
		if(!result) {
			return "2";
		}
		//判断是否是第一次响应，如果是第一次响应的话，则更新事件表中实际响应时间（第一次响应时间）
		String selectSql = "SELECT SHOULI_TIME,CREATE_TIME FROM SC_WORKFLOW_QUESTION WHERE ID = :questionid";
		Map map = baseDao.queryForMap(selectSql,new SqlParameter("questionid",base.getBusiness_id()));
		String shouli_time = ConvertUtil.obj2StrBlank(map.get("SHOULI_TIME"));
		long create_time = ConvertUtil.obj2Long(map.get("CREATE_TIME"));

		Map paramMap = new HashMap();


		if(!StringUtil.notEmpty(shouli_time)) {
			StringBuilder builder = new StringBuilder("UPDATE SC_WORKFLOW_QUESTION SET ");
			long answer_time = DateUtil.getCurrentDate14();

			builder.append(" SHOULI_USERID = :shouli_userid,SHOULI_USERNAME = :shouli_username,SHOULI_TIME = :answerTime,SHOULI_USE_TIME = :answer_user_time ");
			paramMap.put("answerTime",answer_time);
			paramMap.put("shouli_userid",user.get("ID"));
			paramMap.put("shouli_username",user.get("ZSXM"));

			//计算第一次响应时间和创建问题的时间差 将时间差转化为分钟
			long seconds = DateUtil.getSecondsFormDate2Date(create_time, answer_time);
			//将秒转化为分钟
			double sjxysj = NumberUtil.div(ConvertUtil.obj2Double(seconds), ConvertUtil.obj2Double(60), 1);

			paramMap.put("answer_user_time", sjxysj);

			builder.append(" WHERE ID = :questionid");
			paramMap.put("questionid", base.getBusiness_id());
			baseDao.execute(builder.toString(), paramMap);
		}
		return "1";

	}

	@Override
	public void updateQuestion(HttpServletRequest request,
			SC_WORKFLOW_QUESTION sc_workflow_question) {
		String flowId = request.getParameter("flowId");
		String serivceListId = request.getParameter("serivceListId");
		String serivceList = request.getParameter("serivceList");
		String first_category_id = new String();
		String first_category_name = new String();
		String second_category_id = new String();
		String second_category_name = new String();
		String third_category_id = new String();
		String third_category_name = new String();
		if(StringUtil.notEmpty(serivceListId) && StringUtil.notEmpty(serivceList)) {
			String[] serivceListIds = serivceListId.split("-");
			String[] serivceLists = serivceList.split("-");
			first_category_id = serivceListIds[0];
			first_category_name = serivceLists[0];
			second_category_id = serivceListIds[1];
			second_category_name = serivceLists[1];
			third_category_id = serivceListIds[2];
			third_category_name = serivceLists[2];
		}
		String sla_id = request.getParameter("sla_id");
		String sla_name = request.getParameter("sla_name");
		sc_workflow_question.setPri_level_id(sla_id).setPri_level(sla_name);
		sc_workflow_question.setFirst_category_id(first_category_id).setFirst_category_name(first_category_name).setSecond_category_id(second_category_id)
		.setSecond_category_name(second_category_name).setThird_category_id(third_category_id).setThird_category_name(third_category_name);


		sc_workflow_question.update();
		//添加处理记录
		Map userlogin = WebUtil.getLoginUser(request).getLoginUser();
		String createUserId = ConvertUtil.obj2StrBlank(userlogin.get("ID"));
		String createUserName = ConvertUtil.obj2StrBlank(userlogin.get("ZSXM"));
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(flowId,createUserId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));

		//增加问题处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content("修改问题："+createUserName+"修改了问题信息");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id("1");
		record.setDeal_user_name(createUserName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeid).setNode_name(nodeName);
		recordService.addRecord(record);

	}

	@Override
	public List<Map> getZdMsgList(String flowId) {
		String sql = "SELECT * FROM QUESTION_ZD_HISTORY WHERE FLOWID = :flowid ORDER BY CREATE_TIME DESC";

		return baseDao.queryForList(sql, new SqlParameter("flowid",flowId));
	}

	@Override
	public Map getzdmsgbyId(HttpServletRequest request) {
		String id = request.getParameter("id");
		String type = request.getParameter("type");
		String flowId = request.getParameter("flowId");
		Map zdMsg = new HashMap();

		if(!StringUtil.isEmpty(type)){

			if("1".equals(type)){
				SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION(id).getInstanceById();
				zdMsg.put("ID", question.getId());
				zdMsg.put("REASON", question.getTrue_reason());
				zdMsg.put("RESOLVE", question.getResolve());
				zdMsg.put("SUGGEST", question.getSuggest());
				String selsql = "SELECT ID FROM  QUESTION_ZD_HISTORY WHERE FLOWID = :flowid AND ISTHEEND = 1 ";
				String zdid = baseDao.queryForString(selsql, new SqlParameter("flowid",flowId));
				zdMsg.put("ZDID", zdid);
			}else{
				zdMsg = new QUESTION_ZD_HISTORY(id).getBeanMapById();
			}

		}
		return zdMsg;
	}

	@Override
	public void updateZdMsg(HttpServletRequest request) {
		String flowId = request.getParameter("flowId");
		String id = request.getParameter("id");
		String type = request.getParameter("type");


		String resolve = request.getParameter("resolve");
		String suggest = request.getParameter("suggest");
		String reason = request.getParameter("reason");

		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		long resolveTime = DateUtil.getCurrentDate14();
		QUESTION_ZD_HISTORY zd = new QUESTION_ZD_HISTORY();
		if("1".equals(type)){
			 Map param = new HashMap();
		    param.put("reason", reason);
		    param.put("resolve", resolve);
		    param.put("suggest", suggest);
		    param.put("flowid", flowId);
		    param.put("istheend", 1);
			SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION(id);
			question.setTrue_reason(reason).setResolve(resolve).setSuggest(suggest).update();
			String selsql = "SELECT ID FROM  QUESTION_ZD_HISTORY WHERE FLOWID = :flowid AND ISTHEEND = :istheend ";
			String zdid = baseDao.queryForString(selsql, param);
			zd.setId(zdid);
			String sql = "UPDATE QUESTION_ZD_HISTORY SET REASON = :reason ,RESOLVE = :resolve,SUGGEST = :suggest WHERE FLOWID = :flowid AND ISTHEEND = :istheend ";

		    baseDao.execute(sql, param);

		}else{

			if(!StringUtil.isEmpty(id)){
				zd.setId(id);
			}else{
				zd.setFlowid(flowId).setCreate_user_id(userId).setCreate_user_name(userName).setCreate_time(DateUtil.getCurrentDate14());
			}
			zd.setReason(reason).setResolve(resolve).setSuggest(suggest).insertOrUpdate();
		}
		fileService.uploadFile(request, zd.getId(), flowId, null, null);

	}

	@Override
	public String issave(HttpServletRequest request) {
		String nodeId = request.getParameter("nodeId");
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();

		List<Map> nodeList = baseDao.queryForList("select * from WORKFLOW_NODE where FLOWID=:FLOWID and NODE_TEMPLATE_ID=:NODE_TEMPLATE_ID and FLOWSTATE <> 3 and ID <> :NODEID",
				new SqlParameter("FLOWID",node.getFlowid()).addValue("NODEID", nodeId).addValue("NODE_TEMPLATE_ID", node.getNode_template_id()));
		String result="";
		//如果存在其他环节，且当前环节是主负责人，不可以关闭
		if (nodeList.size() > 0 && node.getIs_admin() != null) {
			for(Map map:nodeList){
				String flowstate=ConvertUtil.obj2StrBlank(map.get("FLOWSTATE"));
				String CURRENT_DEALER_NAME=ConvertUtil.obj2StrBlank(map.get("CURRENT_DEALER_NAME"));
				if(StringUtil.isNotBlank(flowstate)) {
					if (flowstate.equals("1")) {
						result=result+CURRENT_DEALER_NAME+"待响应!";
					}else if(flowstate.equals("2")){
						result=result+CURRENT_DEALER_NAME+"进行中!";
					}
				}
			}
			result =result;
		}else if(nodeList.size() == 0 && node.getIs_admin() == 1){
			result = "0";
		}else {
			result = "2";
		}
		return result;
	}

	@Override
	public Map gettempMsg(String id,String userId) {
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(id,userId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		String sql = "SELECT * FROM ORDER_ASSIGN_TEMP WHERE NODE_ID = :node_id ";
		Map msg = baseDao.queryForMap(sql, new SqlParameter("node_id",nodeid));
		return msg;
	}

	@Override
	public Map updateAssign(HttpServletRequest request) {
		Map resultMap = new HashMap();
		resultMap.put("result", 2);
		String savetype = request.getParameter("savetype");
		String id = request.getParameter("flowId");
		String selectUser = request.getParameter("alluserid");
		String saveusername = request.getParameter("saveusername");
		String usertype = request.getParameter("type");
		String nextnodeid = request.getParameter("node");
		String curnodeId = request.getParameter("curnodeId");
		String true_reason = request.getParameter("reason");
		String resolve = request.getParameter("resolve");
		String suggest = request.getParameter("suggest");
		String bz = request.getParameter("bz");

		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		WORKFLOW_BASE base = new WORKFLOW_BASE(id).getInstanceById();
		SC_WORKFLOW_QUESTION myQuestion = new SC_WORKFLOW_QUESTION(base.getBusiness_id()).getInstanceById();

		//获取当前所处的节点
		Map flowMsg = getFlowMsg(id,userId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		if("1".equals(savetype)){
			Map dealuser = new HashMap();
			dealuser.put("userid", selectUser);
			dealuser.put("username", saveusername);
			baseDao.execute("DELETE FROM ORDER_ASSIGN_TEMP WHERE NODE_ID = :node_id ", new SqlParameter("node_id",nodeid));
			ORDER_ASSIGN_TEMP temp = new ORDER_ASSIGN_TEMP();
			temp.setDealer(JsonUtil.map2Json(dealuser)).setNode_id(nodeid)
			.setExtend1(usertype).setExtend2(true_reason).setExtend3(resolve).setExtend4(suggest).setExtend5(bz).insert();

		}else{

			String dealUserId = new String();
			String dealUserName = new String();
			String state = new String();
			String type = new String();

			String node_template_id = Constants.WTFQ;
			if(StringUtil.notEmpty(selectUser)) {
					if(usertype.equals("3")){
						usertype = "1";
					}
					node_template_id = nextnodeid;
					Map param = new HashMap();
					param.put("ID", StringUtil.getUUID());
					param.put("WORKFLOWID", id);
					param.put("PNAME", "处理人");
					param.put("PVALUE", usertype+"@"+selectUser);
					if(nextnodeid.equals(Constants.WTSL)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_SL;
						baseDao.execute("INSERT INTO WORKFLOW_PARAMETER(ID,WORKFLOWID,PNAME,PVALUE) VALUES(:ID,:WORKFLOWID,:PNAME,:PVALUE)", param);
					} else if(nextnodeid.equals(Constants.WTSH)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_SH;
						baseDao.execute("UPDATE WORKFLOW_PARAMETER SET PVALUE=:PVALUE WHERE WORKFLOWID = :WORKFLOWID AND PNAME = :PNAME ", param);
					} else if(nextnodeid.equals(Constants.WTZD)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_WTZD;
					} else if(nextnodeid.equals(Constants.WTFASP)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_FASP;
					} else if(nextnodeid.equals(Constants.WTFASS)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_FASS;
					} else if(nextnodeid.equals(Constants.WTHG)) {
						state = Constants.SC_WORKFLOW_QUESTION_STATE_HG;
					}else{
						state = Constants.SC_WORKFLOW_QUESTION_STATE_YDJ;
					}
			}
			if(StringUtil.notEmpty(selectUser)) {
				//执行分派任务


				NodeDealEntity entity = new NodeDealEntity();
				entity.setDealer_type(3);
				List<Map> dealerList = new ArrayList<Map>();
				if(usertype.equals("1")) {
					entity.setBefore_Dealer_type(2);
					String sqluser = "select * from gg_user ";
					List<Map> userList = baseDao.queryForList(sqluser);
					Map cacheuser = new HashMap();
					for(Map users:userList){
						cacheuser.put(users.get("ID"), users.get("ZSXM"));
					}
					String[] userIdList2 = selectUser.split("&");
					String[] userList2 = userIdList2[0].split(",");
					for(int i=0;i<userList2.length;i++){
						Map map = new HashMap();
						if(userList2[i].split("-").length == 2){
							map.put("USER_ID", userList2[i].split("-")[0]);
							map.put("IS_ADMIN", "1");
							map.put("USER_NAME", cacheuser.get(userList2[i].split("-")[0]));
							dealUserName += cacheuser.get(userList2[i].split("-")[0])+",";
						}else{
							map.put("USER_ID", userList2[i]);
							map.put("USER_NAME", cacheuser.get(userList2[i]));
							dealUserName += cacheuser.get(userList2[i])+",";
						}

						dealerList.add(map);
					}
					dealUserName = dealUserName.substring(0, dealUserName.length()-1);

				} else {
					entity.setBefore_Dealer_type(1);
					entity.setRoleID(selectUser.split("&")[0]);
					entity.setRoleName(selectUser.split("&")[1]);

					//查询改组下面的所有人员信息
					String sqlUser = "SELECT B.ID AS USER_ID ,B.ZSXM AS USER_NAME FROM AC_USER_REF_ROLE A,GG_USER B WHERE A.YHBH = B.ID AND A.JSBH = :groupId ";
					dealerList = baseDao.queryForList(sqlUser,new SqlParameter("groupId",selectUser.split("&")[0]));
					dealUserName = entity.getRoleName();
				}
				entity.setDealerList(dealerList);

				NodeFinishEntity finishEntity = new NodeFinishEntity();
				finishEntity.setDeal_result(1);
				finishEntity.setDeal_note_title("节点转至 ：" + dealUserName);
				finishEntity.setDeal_note(bz);
				WORKFLOW_NODE node = new WORKFLOW_NODE(base.getCurrent_node_id()).getInstanceById();



				boolean canFinish = workflowCoreService.finishNode(base, node, finishEntity);
				if (canFinish) {
					workflowBusinessService.toNode(base, node_template_id, entity);
				}


				//更新问题状态
				Map param = new HashMap();
				param.put("state", state);
				param.put("questionId", base.getBusiness_id());
				String updateIncidentSql = "UPDATE SC_WORKFLOW_QUESTION SET STATE = :state  ";
				if(curnodeId .equals(Constants.WTZD)){

					updateIncidentSql += " ,RESOLVE_USER_ID = :userId,RESOLVE_USER_NAME = :userName,TRUE_REASON = :true_reason ,RESOLVE = :resolve ,SUGGEST = :suggest ";
					param.put("true_reason",true_reason );
					param.put("resolve", resolve);
					param.put("suggest", suggest);
					param.put("userId", userId);
					param.put("userName", userName);
                    String sql="select * from QUESTION_ZD_HISTORY where flowid=:flow_id order by  create_time desc";
                    Map map=new HashMap();
					map.put("flow_id",id);
                   List<Map> list= baseDao.queryForList(sql,map);
                   String businessid="";
                   if(list!=null && list.size()>0){
					   businessid=ConvertUtil.obj2StrBlank(list.get(0).get("ID"));
				   }else{
					   QUESTION_ZD_HISTORY zd = new QUESTION_ZD_HISTORY();
					   zd.setFlowid(id).setIstheend(1).setReason(true_reason).setResolve(resolve).setSuggest(suggest)
							   .setCreate_user_id(userId).setCreate_user_name(userName).setCreate_time(DateUtil.getCurrentDate14()).insert();
					   businessid=zd.getId();
				   }

					fileService.uploadFile(request,businessid, id, null, null);

				}
				updateIncidentSql += " WHERE ID = :questionId ";
				baseDao.execute(updateIncidentSql, param);

				baseDao.execute("DELETE FROM ORDER_ASSIGN_TEMP WHERE NODE_ID = :node_id ", new SqlParameter("node_id",nodeid));

				//增加问题处理记录
				GG_RECORD record = new GG_RECORD();
				record.setDeal_content("指派任务："+userName+"将问题指派给了"+dealUserName);
				record.setDeal_time(DateUtil.getCurrentDate14());
				record.setDeal_user_id("1");
				record.setDeal_user_name(userName);
				record.setBusiness_id(id);
				record.setNode_id(nodeid).setNode_name(nodeName);
				recordService.addRecord(record);
				String wxUrl = WechatConstants.ORDER_INCIDENT_DETAIL_ADDRESS+"?nodeId="+base.getCurrent_node_id()+"&orderId="+base.getBusiness_id()+"&orderType="+Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION;
				//发送消息
				GG_MESSAGE message = new GG_MESSAGE();
				message.setTitle(base.getWfname())
				.setContent(base.getWfname())
				.setSender_id(userId)
				.setSender_name(userName)
				.setSend_time(DateUtil.getCurrentDate14())
				.setBusiness_id(base.getBusiness_id())
				.setWeb_url(Constants.QUESTION_WEB_MSG_URL+"?flowId="+base.getId()+"&orderId="+base.getBusiness_id())
				.setWx_url(wxUrl)
				.setOrder_code(base.getOrder_code())
				.setType(Constants.GG_MESSAGE_TYPE_WTGL);
				messageFacade.doSendMessage(message, dealerList);
				resultMap.put("result", 1);
				type = ConvertUtil.obj2StrBlank(entity.getBefore_Dealer_type());

			}
	        SysInfoMsg msg = new SysInfoMsg(type,dealUserName,Constants.questionNode.get(node_template_id));

			resultMap.put("msg", msg);
		}
		return resultMap;
	}

	@Override
	public void updatefinishnode(HttpServletRequest request) {
	    String nodeId = request.getParameter("nodeId");
	    String note = request.getParameter("note");
		String userName = ConvertUtil.obj2StrBlank(WebUtil.getLoginUser(request).getLoginUser().get("ZSXM"));
		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(1);
		finishEntity.setDeal_note_title(userName+"完成了节点");
		finishEntity.setDeal_note(note);
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		WORKFLOW_BASE base = new WORKFLOW_BASE(node.getFlowid()).getInstanceById();
		//关闭当前节点
		workflowCoreService.finishNode(base, node, finishEntity);
	}

	@Override
	public Map getBeforeNodeMsg(String nodeId) {
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		WORKFLOW_NODE beforenode = new WORKFLOW_NODE(node.getSource_node_instance_id()).getInstanceById();
		String node_template_id = beforenode.getNode_template_id();
		String sql = "SELECT * FROM WORKFLOW_NODE WHERE FLOWID = :flowid AND NODE_TEMPLATE_ID = :node_template_id AND IS_ADMIN = :is_admin ";
		Map param = new HashMap();
		param.put("flowid", beforenode.getFlowid());
		param.put("node_template_id", node_template_id);
		param.put("is_admin", "1");
		Map nodeMap = baseDao.queryForMap(sql, param);
		return nodeMap;
	}


	@Override
	public Map gobackNodeSubmit(HttpServletRequest request) {
		String flowId = request.getParameter("flowId");
		String nodeId = request.getParameter("nodeId");
		String orderId = request.getParameter("orderId");

		WORKFLOW_BASE base = new WORKFLOW_BASE(flowId).getInstanceById();

		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(3);
		finishEntity.setDeal_note_title(userName+"回退了节点");
		finishEntity.setDeal_note(request.getParameter("backReason"));
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		WORKFLOW_NODE beforenode = new WORKFLOW_NODE(node.getSource_node_instance_id()).getInstanceById();
		String node_template_id = beforenode.getNode_template_id();

		Map nodeMap = getBeforeNodeMsg(nodeId);
		List<Map> nodesList = baseDao.queryForList("SELECT * FROM WORKFLOW_NODE WHERE FLOWID = :flowid AND SAME_NODE_KEY = :same_node_key ",new SqlParameter("flowid",flowId).addValue("same_node_key", node.getSame_node_key()));
		//回退时，关闭所有节点
		for(Map nodes:nodesList){
			WORKFLOW_NODE nodeid = new WORKFLOW_NODE(ConvertUtil.obj2StrBlank(nodes.get("ID")));
			nodeid.setDealtime(ConvertUtil.obj2Long(nodes.get("DEALTIME"))).setAnswer_time(ConvertUtil.obj2Long(nodes.get("ANSWER_TIME")));
			workflowCoreService.finishNode(base,nodeid , finishEntity);
		}

		String state = "";
		if(node_template_id.equals(Constants.WTSL)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_SL;
		} else if(node_template_id.equals(Constants.WTSH)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_SH;
		} else if(node_template_id.equals(Constants.WTZD)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_WTZD;
		} else if(node_template_id.equals(Constants.WTFASP)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_FASP;
		} else if(node_template_id.equals(Constants.WTFASS)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_FASS;
		} else if(node_template_id.equals(Constants.WTHG)) {
			state = Constants.SC_WORKFLOW_QUESTION_STATE_HG;
		}else{
			state = Constants.SC_WORKFLOW_QUESTION_STATE_YDJ;
		}

		//更新问题状态
		String updateSql = "UPDATE SC_WORKFLOW_QUESTION SET STATE = :state WHERE ID = :questionId ";
		baseDao.execute(updateSql, new SqlParameter("state",state).addValue("questionId", orderId));

		List<Map> list = new ArrayList<Map>();
		Map map = new HashMap();
		map.put("USER_ID", nodeMap.get("CURRENT_DEALER_ID"));
		map.put("USER_NAME", nodeMap.get("CURRENT_DEALER_NAME"));
		map.put("IS_ADMIN", "1");
		list.add(map);

		NodeDealEntity entity = new NodeDealEntity();
		entity.setBefore_Dealer_type(2);
		entity.setDealer_type(2);
		entity.setDealerList(list);
		entity.setFlow_type(2);
		entity.setSource_node_instance_id(node.getId());
		//回退到上一节点
		workflowCoreService.toNode(base, ConvertUtil.obj2Str(nodeMap.get("NODE_TEMPLATE_ID")), entity);
		String wxUrl = WechatConstants.ORDER_INCIDENT_DETAIL_ADDRESS+"?orderId="+base.getBusiness_id()+"&orderType="+Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION;
		//发送消息
		GG_MESSAGE message = new GG_MESSAGE();
		message.setTitle(base.getWfname())
		.setContent(base.getWfname())
		.setSender_id(userId)
		.setSender_name(userName)
		.setSend_time(DateUtil.getCurrentDate14())
		.setBusiness_id(base.getBusiness_id())
		.setWeb_url(Constants.QUESTION_WEB_MSG_URL+"?flowId="+base.getId()+"&orderId="+base.getBusiness_id())
		.setWx_url(wxUrl)
		.setOrder_code(base.getOrder_code())
		.setType(Constants.GG_MESSAGE_TYPE_WTGL);
		messageFacade.doSendMessage(message, list);
		Map resultMap = new HashMap();
		SysInfoMsg msg = new SysInfoMsg("2",ConvertUtil.obj2Str(nodeMap.get("CURRENT_DEALER_NAME")),Constants.questionNode.get(ConvertUtil.obj2Str(nodeMap.get("NODE_TEMPLATE_ID"))));
		resultMap.put("msg", msg);
		return resultMap;
	}

	@Override
	public Map updateApplyEnd(HttpServletRequest request) {
		Map resultMap = new HashMap();
		resultMap.put("result", 2);
		String orderId = request.getParameter("orderId");
		String flowId = request.getParameter("flowId");
		String nodeId = request.getParameter("nodeId");

		String ssbz = request.getParameter("ssbz");
		String ssjg = request.getParameter("ssjg");
		String ssnote = request.getParameter("ssnote");


		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		long resolveTime = DateUtil.getCurrentDate14();

		String updateSql = "UPDATE SC_WORKFLOW_QUESTION SET STATE = :state,RESOLVE_USER_ID = :userId,RESOLVE_USER_NAME = :userName,RESOLVE_TIME = :resolveTime,FINISH_USE_TIME = :resolve_hs,SSBZ = :ssbz,SSJG = :ssjg,SSNOTE = :ssnote WHERE ID = :questionId ";

		//判断是否是第一次响应，如果是第一次响应的话，则更新事件表中实际响应时间（第一次响应时间）
		String selectSql = "SELECT SHOULI_TIME,CREATE_TIME FROM SC_WORKFLOW_QUESTION WHERE ID = :questionid";
		Map map = baseDao.queryForMap(selectSql,new SqlParameter("questionid",orderId));
		long create_time = ConvertUtil.obj2Long(map.get("CREATE_TIME"));
		//计算第一次响应时间和创建问题的时间差 将时间差转化为分钟
		long seconds = DateUtil.getSecondsFormDate2Date(create_time, resolveTime);
		//将秒转化为分钟
		double sjxysj = NumberUtil.div(ConvertUtil.obj2Double(seconds), ConvertUtil.obj2Double(60), 1);
		Map paramMap = new HashMap();
		paramMap.put("state", Constants.SC_WORKFLOW_QUESTION_STATE_HG);
		paramMap.put("userId", userId);
		paramMap.put("userName", userName);
		paramMap.put("resolveTime", resolveTime);
		paramMap.put("ssbz", ssbz);
		paramMap.put("ssjg", ssjg);
		paramMap.put("ssnote", ssnote);
		paramMap.put("questionId", orderId);
		paramMap.put("resolve_hs", sjxysj);

		baseDao.execute(updateSql, paramMap);
		String dealUserName ="";
		NodeDealEntity entity = new NodeDealEntity();
		entity.setDealer_type(2);
		List<Map> dealerList = new ArrayList<Map>();

		///问题回顾处理人发给问题受理阶段
		entity.setBefore_Dealer_type(2);
		String sql="select * from WORKFLOW_node where FLOWID=:flowid  and  NODE_TEMPLATE_ID=:node_template_id order by CREATETIME desc limit 0,1";
		List<Map> xxList = baseDao.queryForList(sql,new SqlParameter("flowid",flowId).addValue("node_template_id",Constants.WTSL));
		if(xxList!=null && xxList.size()>0){
			entity.setRoleID(ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_ID")));
			entity.setRoleName(ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME")));
			Map dealer = new HashMap();
			dealer.put("USER_ID", ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_ID")));
			dealer.put("USER_NAME", ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME")));
			dealer.put("IS_ADMIN", "1");
			dealerList.add(dealer);
			dealUserName= ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME"));
		}else{
			//如果问题受理阶段为空就发给创建人
				String sql_cj="select * from WORKFLOW_node where FLOWID=:flowid  and  NODE_TEMPLATE_ID=:node_template_id order by CREATETIME desc limit 0,1";
				List<Map> cjList = baseDao.queryForList(sql_cj,new SqlParameter("flowid",flowId).addValue("node_template_id",Constants.WTFQ));
				entity.setRoleID(ConvertUtil.obj2StrBlank(cjList.get(0).get("CURRENT_DEALER_ID")));
				entity.setRoleName(ConvertUtil.obj2StrBlank(cjList.get(0).get("CURRENT_DEALER_NAME")));
				Map dealer = new HashMap();
				dealer.put("USER_ID", ConvertUtil.obj2StrBlank(cjList.get(0).get("CURRENT_DEALER_ID")));
				dealer.put("USER_NAME", ConvertUtil.obj2StrBlank(cjList.get(0).get("CURRENT_DEALER_NAME")));
				dealer.put("IS_ADMIN", "1");
				dealerList.add(dealer);
				dealUserName= ConvertUtil.obj2StrBlank(cjList.get(0).get("CURRENT_DEALER_NAME"));
		}

		/*Map value = baseDao.queryForMap("SELECT * FROM WORKFLOW_PARAMETER WHERE WORKFLOWID = :ID ORDER by pvalue desc limit 0,1", new SqlParameter("ID",flowId));
		String[] uservalues = ConvertUtil.obj2StrBlank(value.get("PVALUE")).split("@");
		if(uservalues[0].equals("1")) {
			entity.setBefore_Dealer_type(2);
			String sqluser = "select * from gg_user  ";
			List<Map> userList = baseDao.queryForList(sqluser);
			Map cacheuser = new HashMap();
			for(Map users:userList){
				cacheuser.put(users.get("ID"), users.get("ZSXM"));
			}
			String[] userIdList2 = uservalues[1].split("&");
			String[] userList2 = userIdList2[0].split(",");
			for(int i=0;i<userList2.length;i++){
				Map map1 = new HashMap();
				if(userList2[i].split("-").length == 2){
					map1.put("USER_ID", userList2[i].split("-")[0]);
					map1.put("IS_ADMIN", "1");
					map1.put("USER_NAME", cacheuser.get(userList2[i].split("-")[0]));
					dealUserName += cacheuser.get(userList2[i].split("-")[0])+",";
				}else{
					map1.put("USER_ID", userList2[i]);
					map1.put("USER_NAME", cacheuser.get(userList2[i]));
					dealUserName += cacheuser.get(userList2[i])+",";
				}

				dealerList.add(map1);
			}
			dealUserName = dealUserName.substring(0, dealUserName.length()-1);

		} else {
			if(uservalues[0].startsWith("1")){
				entity.setBefore_Dealer_type(1);
				Map dealer = new HashMap();
				String dealerId = uservalues[0].split("&")[1].split("-")[0];
				dealer.put("USER_ID", dealerId);
				String dealerName = baseDao.queryForString("select zsxm from gg_user where id = :userId",new SqlParameter("userId",dealerId));
				dealer.put("USER_NAME", dealerName);
				dealer.put("IS_ADMIN", "1");
				dealerList.add(dealer);
				dealUserName = dealerName;
			}else{
				entity.setBefore_Dealer_type(2);
				entity.setRoleID(uservalues[1].split("&")[0]);
				entity.setRoleName(uservalues[1].split("&")[1]);
				String sql="select * from WORKFLOW_node where FLOWID=:flowid  and  NODE_TEMPLATE_ID=:node_template_id order by CREATETIME desc limit 0,1";
				List<Map> xxList = baseDao.queryForList(sql,new SqlParameter("flowid",flowId).addValue("node_template_id",Constants.WTSL));
				if(xxList!=null && xxList.size()>0){
					entity.setRoleID(ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_ID")));
					entity.setRoleName(ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME")));
					Map dealer = new HashMap();
					dealer.put("USER_ID", ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_ID")));
					dealer.put("USER_NAME", ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME")));
					dealer.put("IS_ADMIN", "1");
					dealerList.add(dealer);
					dealUserName= ConvertUtil.obj2StrBlank(xxList.get(0).get("CURRENT_DEALER_NAME"));
				}
			}
		}*/
		entity.setDealerList(dealerList);
		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(1);
		finishEntity.setDeal_note_title("节点转至 ：" + dealUserName);
		finishEntity.setDeal_note("实施结束");
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		WORKFLOW_BASE base = new WORKFLOW_BASE(flowId).getInstanceById();


		boolean canFinish = workflowCoreService.finishNode(base, node, finishEntity);
		if (canFinish) {
			workflowBusinessService.toNode(base, Constants.WTHG, entity);
		}
		//添加处理记录
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(flowId,userId);
		String curnodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		//添加修改信息处理记录
		String id = StringUtil.getUUID();
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content(userName+"完善处理步骤和结果");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id("1");
		record.setDeal_user_name(userName);
		record.setBusiness_id(flowId);
		record.setNode_id(curnodeid).setNode_name(nodeName);

		recordService.addRecord(record);
		fileService.uploadFile(request, id, flowId, null, null);
		String wxUrl = WechatConstants.ORDER_INCIDENT_DETAIL_ADDRESS+"?nodeId="+base.getCurrent_node_id()+"&orderId="+base.getBusiness_id()+"&orderType="+Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION;
		//发送消息
		GG_MESSAGE message = new GG_MESSAGE();
		message.setTitle(base.getWfname())
		.setContent(base.getWfname())
		.setSender_id(userId)
		.setSender_name(userName)
		.setSend_time(DateUtil.getCurrentDate14())
		.setBusiness_id(base.getBusiness_id())
		.setWeb_url(Constants.QUESTION_WEB_MSG_URL+"?flowId="+base.getId()+"&orderId="+base.getBusiness_id())
		.setWx_url(wxUrl)
		.setOrder_code(base.getOrder_code())
		.setType(Constants.GG_MESSAGE_TYPE_WTGL);
		messageFacade.doSendMessage(message, dealerList);
		String type = ConvertUtil.obj2StrBlank(entity.getBefore_Dealer_type());
		resultMap.put("result", 1);
        SysInfoMsg msg = new SysInfoMsg(type,dealUserName,Constants.questionNode.get(Constants.WTHG));

		resultMap.put("msg", msg);
		return resultMap;


	}

	@Override
	public Map getEndMsgById(String orderId) {
		String sql ="SELECT RESOLVE_TYPE_ID,TRUE_REASON,RESOLVE,SUGGEST FROM SC_WORKFLOW_QUESTION WHERE ID = :id ";
		Map faMap = baseDao.queryForMap(sql, new SqlParameter("id",orderId));
		return faMap;
	}

	@Override
	public void updateEndQuestion(HttpServletRequest request) {
		String orderId = request.getParameter("orderId");
		String flowId = request.getParameter("flowId");
		String nodeId = request.getParameter("nodeId");
		String solveWay = request.getParameter("solveWay");
		String solveWayName = request.getParameter("solveWayName");
		String solve = request.getParameter("solve");


		String reason = request.getParameter("reason");


		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String userId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String userName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		long resolveTime = DateUtil.getCurrentDate14();

		String state = "";
		if("1".equals(solve)){
			state = Constants.SC_WORKFLOW_QUESTION_STATE_YWC;
		}else{
			state = Constants.SC_WORKFLOW_QUESTION_STATE_YGB;
		}
		SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION(orderId).getInstanceById();


		StringBuffer updateSql = new StringBuffer("UPDATE SC_WORKFLOW_QUESTION SET STATE = :state , RESOLVE_USER_ID = :userId,RESOLVE_USER_NAME = :userName,RESOLVE_TIME = :resolveTime,RESOLVE_TYPE_ID = :solveWay,RESOLVE_TYPE_NAME = :solveWayName  ");
		Map paramMap = new HashMap();
		if(StringUtil.isEmpty(question.getResolve_user_id())){
			paramMap.put("userId", userId);
			paramMap.put("userName", userName);
		}else{
			paramMap.put("userId", question.getResolve_user_id());
			paramMap.put("userName", question.getResolve_user_name());
		}
		if(StringUtil.isEmpty(question.getResolve())){
			List<Map> zdList = getZdMsgList(flowId);
			if(zdList.size() > 0){
				Map map = zdList.get(0);
				updateSql.append(" ,TRUE_REASON = :true_reason ,RESOLVE = :resolve ,SUGGEST = :suggest ");
				paramMap.put("true_reason", map.get("REASON"));
				paramMap.put("resolve", map.get("RESOLVE"));
				paramMap.put("suggest", map.get("SUGGEST"));
			}

		}
		paramMap.put("state", state);

		paramMap.put("resolveTime", resolveTime);
		paramMap.put("solveWay", solveWay);
		paramMap.put("solveWayName", solveWayName);
		paramMap.put("questionId", orderId);
		updateSql.append(" WHERE ID = :questionId");
		baseDao.execute(updateSql.toString(), paramMap);
		//添加处理记录
		Map userlogin = WebUtil.getLoginUser(request).getLoginUser();
		String createUserId = ConvertUtil.obj2StrBlank(userlogin.get("ID"));
		String createUserName = ConvertUtil.obj2StrBlank(userlogin.get("ZSXM"));
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(flowId,createUserId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		//增加问题处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content("结束问题："+createUserName+"结束了问题工单");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id("1");
		record.setDeal_user_name(createUserName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeid).setNode_name(nodeName);
		recordService.addRecord(record);

		//结束工单
        WORKFLOW_BASE base = new WORKFLOW_BASE(flowId).getInstanceById();

		List<Map> list = new ArrayList<Map>();
		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(1);
		finishEntity.setDeal_note_title(userName+"处理完成");
		finishEntity.setDeal_note(reason);

		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();

		workflowCoreService.finishNode(base, node, finishEntity);
		if("1".equals(solve)){
			workflowCoreService.finishWorkFlow(base);
		}else{
			workflowCoreService.closeWorkFlow(base);
		}
	}

	@Override
	public List queryLinkwtOrder(HttpServletRequest request) {
		String orderCode = request.getParameter("orderCode");
		String orderName = AjaxUtil.decode(request.getParameter("orderName"));
		String customerid = request.getParameter("customerid");
		String orderid = request.getParameter("orderid");
		String reordercode = request.getParameter("reordercode");
		StringBuilder sql = new StringBuilder("SELECT A.ID,A.WFNAME,A.BUSINESSTYPE,A.WFSTATE,A.BUSINESS_ID,A.ORDER_CODE,A.CUSTOMER_NAME,A.CREATETIME ,B.NAME FROM WORKFLOW_BASE A,SC_WORKFLOW_QUESTION B WHERE A.BUSINESS_ID = B.ID AND A.WFSTATE != :wfstate AND A.CUSTOMER_ID = :customerid AND A.BUSINESSTYPE = :businesstype ");
		sql.append(" AND B.ID <> :orderid ");
		SqlParameter param = new SqlParameter();
		param.addValue("customerid", customerid);
		param.addValue("orderid", orderid);
		param.addValue("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DELETE);
		param.addValue("businesstype", Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION);

		if (StringUtils.isNotBlank(reordercode)) {
			sql.append("AND A.ORDER_CODE != :reordercode ");
			param.addValue("reordercode", reordercode);
		}

		if (StringUtils.isNotBlank(orderName)) {
			sql.append("AND B.NAME like :wfname ");
			param.addValue("wfname", "%"+orderName+"%");
		}

		if (StringUtils.isNotBlank(orderCode)) {
			sql.append("AND A.ORDER_CODE like :orderCode ");
			param.addValue("orderCode", "%"+orderCode+"%");
		}

		sql.append("ORDER BY A.WFSTATE ASC,A.CREATETIME DESC");


		List<Map> list = baseDao.queryForList(sql.toString(),param);

		for (Map map2 : list) {
			map2.put("BUSINESSTYPE_TEXT", Constants.mapWORKFLOW_BUSINESS_TYPE_Label(ConvertUtil.obj2Str(map2.get("BUSINESSTYPE"))));
			map2.put("WFSTATE_TEXT", Constants.getWORKFLOW_BASE_WFSTATE_Label(ConvertUtil.obj2Str(map2.get("WFSTATE"))));
			map2.put("CREATE_TIME", DateUtil.format("yyyy-MM-dd HH:mm:ss", map2.get("CREATETIME")));
		}
		return list;
	}

	@Override
	public String getIsOpenQuestion(HttpServletRequest request) {
		String orderId = request.getParameter("orderId");
		String userId = WebUtil.getLoginedUserId(request);
		String sql = "SELECT COUNT(ID) FROM HANG_UP_INFO WHERE BUS_ID = :bus_id AND STATE = 1 AND HANG_UP_USERID = :userId ";
		Map param = new HashMap();
		param.put("bus_id", orderId);
		param.put("userId", userId);

		int count = baseDao.queryForInteger(sql, param);
		if(count > 0){
			return "1";
		}else{
			return "0";
		}
	}

	@Override
	public Map questionInfo(HttpServletRequest request) {
		String questionId=request.getParameter("orderId");
		String flowId=request.getParameter("flowId");
		Map param =new HashMap();
		param.put("questionId", questionId);
		param.put("flowId", flowId);
		StringBuilder sql=new StringBuilder();
		sql.append("SELECT c.*,u.SJHM FROM SC_WORKFLOW_QUESTION c,gg_user u WHERE c.CREATE_USER_ID=u.id AND c.ID=:questionId ");
		Map questionMap=baseDao.queryForMap(sql.toString(), param);
		questionMap.put("STATE", Constants.getmapSC_WORKFLOW_QUESTION_STATE_Label(questionMap.get("STATE").toString()));
		String sql_base="select WFSTATE from WORKFLOW_BASE where id=:flowId";
		String WFSTATE=baseDao.queryForString(sql_base,param);
		questionMap.put("WFSTATE",WFSTATE);
		String note="select deal_note from WORKFLOW_NODE where FLOWID=:flowId order by DEALTIME desc";
		String deal_note=baseDao.queryForString(note,param);
		questionMap.put("DEAL_NOTE",deal_note);
		Map map = new HashMap();
		map.put("questionMap", questionMap);

		//关联工单
		List<Map> orderList=orderService.queryLinkOrders(flowId);
		if(orderList!=null && orderList.size()>0){
			for(Map orderMap:orderList){
				orderMap.put("WFSTATE", Constants.getWORKFLOW_BASE_WFSTATE_Label(orderMap.get("WFSTATE").toString()));
				orderMap.put("BUSINESSTYPE", Constants.mapWORKFLOW_BUSINESS_TYPE_Label(orderMap.get("BUSINESSTYPE").toString()));
			}
		}
		map.put("orderList", orderList);
		//关联设备
		sql.setLength(0);
		sql.append("SELECT * FROM cmdb_ci_ref_order r,cmdb_ci_base b WHERE r.CI_ID=b.ID");
		sql.append(" AND r.FLOW_ID=:flowId");
		List ciList=baseDao.queryForList(sql.toString(),param);
		map.put("ciList", ciList);
		//关联文档
		List<Map> fileList=fileService.getFileList(flowId);
		if(fileList!=null && fileList.size()>0){
			for(Map fileMap:fileList){
				fileMap.put("FILE_SIZE", ConvertUtil.byte2KM(Double.parseDouble(fileMap.get("FILE_SIZE").toString()), 2));
			}
		}
		map.put("fileList", fileList);
		return map;
	}

	@Override
	public void updateResolveType(HttpServletRequest request) {
		String orderId = request.getParameter("orderId");
		String flowId = request.getParameter("flowId");
		String nodeId = request.getParameter("nodeId");
		String solveWay = request.getParameter("solveWay");
		String solveWayName = request.getParameter("solveWayName");
		String repeat_order = request.getParameter("repeat_order");
		String content = request.getParameter("content");
		String bz = request.getParameter("bz");
		//修改问题信息的解决方式
		SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION();
		question.setResolve_type_id(solveWay).setResolve_type_name(solveWayName);
		if("WTCF".equals(solveWay)){
			question.setRepeat_order(repeat_order).setRepeat_mark("1");
		}
		question.setId(orderId).setState(ConvertUtil.obj2Integer(Constants.SC_WORKFLOW_QUESTION_STATE_YGB)).update();
		//添加处理记录
		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String createUserId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String createUserName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(flowId,createUserId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		//增加问题处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content("取消问题："+createUserName+"取消了问题");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id("1");
		record.setDeal_user_name(createUserName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeid).setNode_name(nodeName);
		record = recordService.addRecord(record);
		fileService.uploadFile(request, record.getId(), flowId, null, null);


        WORKFLOW_BASE base = new WORKFLOW_BASE(flowId).getInstanceById();

		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(1);
		finishEntity.setDeal_note_title(createUserName+"结束节点");
		finishEntity.setDeal_note(bz);
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		//关闭当前节点
		workflowCoreService.finishNode(base, node, finishEntity);
		//关闭工单
		workflowCoreService.closeWorkFlow(base);

	}

	@Override
	public void updateQuestiongq(HttpServletRequest request) {
		String orderId = request.getParameter("orderId");
		String flowId = request.getParameter("flowId");
		String nodeId = request.getParameter("nodeId");
		String solveWay = request.getParameter("solveWay");
		String solveWayName = request.getParameter("solveWayName");
		String content = request.getParameter("content");
		//添加处理记录
		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String createUserId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String createUserName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));

		String sql = "INSERT INTO HANG_UP_INFO(ID,BUS_ID,BUS_STATE,STATE,HANG_UP_USERID,HANG_UP_USERNAME,HANG_UP_TIME,HANG_UP_REASONID,HANG_UP_REASON,HANG_UP_NOTE) VALUES(:id,:bus_id,:bus_state,:state,:hang_up_userid,:hang_up_username,:hang_up_time,:hang_up_reasonid,:hang_up_reason,:hang_up_note)";
		Map  param = new HashMap();
		param.put("id", StringUtil.getUUID());
		param.put("bus_id", orderId);
		String bus_state = baseDao.queryForString("SELECT STATE FROM SC_WORKFLOW_QUESTION WHERE ID = :id ", new SqlParameter("id",orderId));
		param.put("bus_state", bus_state);
		param.put("state", "1");
		param.put("hang_up_userid", createUserId);
		param.put("hang_up_username", createUserName);
		param.put("hang_up_time", DateUtil.getCurrentDate14());
		param.put("hang_up_reasonid", solveWay);
		param.put("hang_up_reason", solveWayName);
		param.put("hang_up_note", content);
		baseDao.execute(sql, param);
		//修改问题信息的状态
		SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION();
		question.setId(orderId).setState(ConvertUtil.obj2Integer(Constants.SC_WORKFLOW_QUESTION_STATE_GQ)).update();
		//修改问题流程信息的状态
		WORKFLOW_BASE base = new WORKFLOW_BASE();
		base.setId(flowId).setWfstate(ConvertUtil.obj2Integer(Constants.WORKFLOW_BASE_WFSTATE_UP)).update();
		//获取当前所处的节点
		Map flowMsg = getFlowMsg(flowId,createUserId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
		//增加问题处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content("挂起问题："+createUserName+"挂起了问题");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id("1");
		record.setDeal_user_name(createUserName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeid).setNode_name(nodeName);
		record = recordService.addRecord(record);
		fileService.uploadFile(request, record.getId(), flowId, null, null);

	}

	@Override
	public List queryGqhistoryData(HttpServletRequest request) {
		String orderId = request.getParameter("orderId");
		String sql = "SELECT * FROM HANG_UP_INFO WHERE BUS_ID = :bus_id ORDER BY HANG_UP_TIME DESC ";
		List<Map> gqList = baseDao.queryForList(sql, new SqlParameter("bus_id",orderId));
		for(Map gq:gqList){
			gq.put("BUS_STATE", Constants.getmapSC_WORKFLOW_QUESTION_STATE_Label(ConvertUtil.obj2StrBlank(gq.get("BUS_STATE"))));
			gq.put("HANG_UP_TIME", DateUtil.format("yyyy-MM-dd HH:mm:ss", gq.get("HANG_UP_TIME")));
		    if(ConvertUtil.obj2Integer(gq.get("STATE")) == 1){
		    	gq.put("STATE", "挂起");
		    }else{
		    	gq.put("STATE", "开启");
		    }
		}
		return gqList;
	}

	@Override
	public void updateQuestionOpen(HttpServletRequest request) {
		Map user = WebUtil.getLoginUser(request).getLoginUser();
		String createUserId = ConvertUtil.obj2StrBlank(user.get("ID"));
		String createUserName = ConvertUtil.obj2StrBlank(user.get("ZSXM"));
		String orderId = request.getParameter("orderId");
		String note = request.getParameter("note");
		Map param = new HashMap();
		param.put("bus_id", orderId);
		String sql = "SELECT * FROM HANG_UP_INFO WHERE STATE = 1 AND BUS_ID = :bus_id ";
		Map qgMap = baseDao.queryForMap(sql, param);
		SC_WORKFLOW_QUESTION question = new SC_WORKFLOW_QUESTION();
		question.setId(orderId).setState(ConvertUtil.obj2Integer(qgMap.get("BUS_STATE"))).update();
		String basesql = "UPDATE WORKFLOW_BASE SET WFSTATE = 1 WHERE BUSINESS_ID = :bus_id ";
		baseDao.execute(basesql, param);
		HANG_UP_INFO qg = new HANG_UP_INFO(ConvertUtil.obj2StrBlank(qgMap.get("ID")));
		qg.setState(2).setHang_down_reason(note).update();
	}

	@Override
	public Map querymyQuestionpoolCount(HttpServletRequest request) {
		String userId = WebUtil.getLoginedUserId(request);
		//初始化变量
		int ywc = 0;
		//问题受理
		int wtsl = 0;

		//问题审核
		int wtsh = 0;

		//问题诊断
		int wtzd = 0;

		//方案审批
		int fasp = 0;

		//方案实施
		int fass = 0;

		//问题回顾
		int wthg = 0;
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlall = new StringBuilder();
		Map paramMap = new HashMap();
		paramMap.put("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DELETE);
		sql.append("SELECT COUNT(*) AS  NUM,E.STATE FROM SC_WORKFLOW_QUESTION E, WORKFLOW_BASE D,(SELECT DISTINCT B.JSBH FROM GG_USER A,AC_USER_REF_ROLE B WHERE A.ID = B.YHBH AND A.ID = :userId) C WHERE  D.CURRENT_DEAL_ROLEIDA = C.JSBH AND E.ID = D.BUSINESS_ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' )  AND D.BUSINESSTYPE = :businessType ");
		sqlall.append("SELECT COUNT(G.ID) FROM (SELECT E.ID FROM SC_WORKFLOW_QUESTION E, WORKFLOW_BASE D,(SELECT DISTINCT B.JSBH FROM GG_USER A,AC_USER_REF_ROLE B WHERE A.ID = B.YHBH AND A.ID = :userId) C WHERE  D.CURRENT_DEAL_ROLEIDA = C.JSBH AND E.ID = D.BUSINESS_ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' ) AND D.BUSINESSTYPE = :businessType ");

		String customer_Id = request.getParameter("customerId");
		if(!StringUtil.isEmpty(customer_Id)){
			sql.append(" AND E.CUSTOMER_ID = :customer_Id ");
			sqlall.append(" AND E.CUSTOMER_ID = :customer_Id ");
			paramMap.put("customer_Id", customer_Id);
		}
		sql.append(" GROUP BY E.STATE ");
		sqlall.append(" GROUP BY E.ID) G ");
		paramMap.put("userId", userId);
		paramMap.put("businessType", Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION);
		List<Map> list = baseDao.queryForList(sql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					wtsl += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					wtsh += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					wtzd += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					fasp += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					fass += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					wthg += num;
					continue;
				}

			}
		}
		int all = baseDao.queryForInteger(sqlall.toString(), paramMap);
		Map map = new HashMap();
		map.put("wtsl", wtsl);

		map.put("wtsh", wtsh);

		map.put("wtzd", wtzd);

		map.put("fasp", fasp);

		map.put("fass", fass);

		map.put("wthg", wthg);

		map.put("all", all);
		return map;
	}

	@Override
	public int myquestionpoolCount(Map<String, String> params) {

		String sql = new String();
		params.put("wfstate", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_WFSTATE_DELETE));
		sql = "SELECT COUNT(D.ID) FROM  SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT DISTINCT B.JSBH FROM GG_USER A,AC_USER_REF_ROLE B WHERE A.ID = B.YHBH AND A.ID = :userId) C WHERE  E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.JSBH AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' ) ";


		if(StringUtil.notEmpty(sql)) {
			StringBuilder builder = new StringBuilder(sql);

			builder = getMypoolsql(builder,params);

			int count = baseDao.queryForInteger(builder.toString(),params);

			return count;
		}

		return 0;
	}

	@Override
	public PageInfo myquestionpoolData(PageInfo pageInfo,
			Map<String, String> params) {

		String sql = new String();
		params.put("wfstate", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_WFSTATE_DELETE));
		sql = "SELECT D.* FROM SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT DISTINCT B.JSBH FROM GG_USER A,AC_USER_REF_ROLE B WHERE A.ID = B.YHBH AND A.ID = :userId) C WHERE E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.JSBH AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' ) ";

		if(StringUtil.notEmpty(sql)) {

			StringBuilder builder = new StringBuilder(sql);
			builder = getMypoolsql(builder,params);

			builder.append(" ORDER BY D.CREATETIME DESC ");
			PageInfo result = baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), params);

			return result;
		}
		return new PageInfo();
	}

	@Override
	public Map getLastMonthQuestionCount(Map<String, String> params) {
		Map chartMap = new HashMap();
		Long endDay = DateUtil.getCurrentDate8();
		Long startDay = DateUtil.getDateAdd(endDay,-30,8);

		String userId = params.get("userId");
		params.put("startTime", startDay+"000000");
		params.put("endTime", endDay + "600000");

		StringBuilder builder = new StringBuilder();
		if(StringUtil.isBlank(userId)){
			builder.append(" select count(ID) NUM,DATE_FORMAT(CREATE_TIME,'%Y%m%d') CREATEDAY  from SC_WORKFLOW_QUESTION  where CUSTOMER_ID = :cusId ");
			builder.append(" and CREATE_TIME>=:startTime and CREATE_TIME<=:endTime group by DATE_FORMAT(CREATE_TIME,'%Y%m%d')  ");
		}else{
			builder.append(" select count(q.ID) NUM,DATE_FORMAT(q.CREATE_TIME,'%Y%m%d') CREATEDAY from workflow_base b ,SC_WORKFLOW_QUESTION q ");
			builder.append(" where b.ID = q.FLOW_ID and  EXISTS ( ");
			builder.append(" select FLOWID from workflow_node n where b.ID = n.FLOWID and n.CURRENT_DEALER_ID = :userId ");
			builder.append(" ) and q.CUSTOMER_ID = :cusId and q.CREATE_TIME>=:startTime and q.CREATE_TIME<=:endTime  group by DATE_FORMAT(q.CREATE_TIME,'%Y%m%d') ");
		}

		List<Map> dataList = baseDao.queryForList(builder.toString(),params);
		if(dataList!=null&&dataList.size()>0){

			List<String> categories = DateUtil.getDates(startDay ,endDay);
			categories.add(String.valueOf(DateUtil.getCurrentDate8()));
			List<String> categories_format = new ArrayList<String>();


			Map dataMap = new HashMap();
			Map tempMap = new HashMap();
			List<Map> series = new ArrayList<Map>();
			tempMap.put("name", "问题数量");
			List tempList = new ArrayList();
			for(Map data:dataList){
				dataMap.put(data.get("CREATEDAY").toString(), data);
			}
			for(String day:categories){
				categories_format.add(DateUtil.format("yyyy-MM-dd",day));
				if(dataMap.get(day)!=null){
					tempList.add(((Map)dataMap.get(day)).get("NUM"));
				}else{
					tempList.add(0);
				}
			}
			tempMap.put("data", tempList);
			series.add(tempMap);
			chartMap.put("categories",categories_format);
			chartMap.put("step",Math.ceil(categories.size()/9));
			chartMap.put("series",series);
		}
		return chartMap;
	}

	public StringBuilder getMypoolsql(StringBuilder builder,Map<String, String> params){
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			builder.append(" AND E.STATE = :status ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			builder.append(" AND D.WFNAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}


		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			builder.append(" AND D.ORDER_CODE LIKE :orderCode");
			params.put("orderCode", "%"+orderCode+"%");
		}

		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			builder.append(" AND D.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND D.SUB_CUSTOMER_ID = :subCustomerId ");
		}


		builder.append(" AND D.BUSINESSTYPE = :businessType");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		return builder;
	}

	@Override
	public Map getLastMonthQuestionLv(Map<String, String> params) {
		//dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_PRI,WebUtil.getLoginedPartnerId(request));
		Map chartMap = new HashMap();

		Long endDay = DateUtil.getCurrentDate8();
		Long startDay = DateUtil.getDateAdd(endDay,-30,8);
		String userId = params.get("userId");
		params.put("startTime", startDay+"000000");
		params.put("endTime", endDay + "600000");


		StringBuilder builder = new StringBuilder();
		if(StringUtil.isBlank(userId)){
			builder.append(" SELECT count(ID) NUM,PRI_LEVEL_ID FROM SC_WORKFLOW_QUESTION WHERE ");
			builder.append(" CUSTOMER_ID = :cusId AND CREATE_TIME >= :startTime AND CREATE_TIME <= :endTime ");
			builder.append(" GROUP BY PRI_LEVEL_ID ");
		}else{
			builder.append(" SELECT count(q.ID) NUM,q.PRI_LEVEL_ID FROM SC_WORKFLOW_QUESTION q,WORKFLOW_BASE b ");
			builder.append(" where b.ID = q.FLOW_ID and  EXISTS ( ");
			builder.append(" select FLOWID from workflow_node n where b.ID = n.FLOWID and n.CURRENT_DEALER_ID = :userId ");
			builder.append(" ) and q.CUSTOMER_ID = :cusId and q.CREATE_TIME>=:startTime and q.CREATE_TIME<=:endTime  group by q.PRI_LEVEL_ID ");
		}

		List<Map> dataList = baseDao.queryForList(builder.toString(),params);
		if(dataList!=null&&dataList.size()>0){
			Map dataMap = new HashMap();
			Map tempMap = new HashMap();
			List serieslist = new ArrayList();

			for(Map data : dataList){
				dataMap.put(data.get("PRI_LEVEL_ID").toString(), data);
			}

			builder.setLength(0);
			builder.append(" select ID LEVEL_ID,LEVEL_NAME from SC_SLA where state =1 order by SERIAL ");
			List<Map> catelist = baseDao.queryForList(builder.toString());
			for(Map cate : catelist){
				List tempList = new ArrayList();
				tempList.add(cate.get("LEVEL_NAME").toString());
				if(dataMap.get(cate.get("LEVEL_ID").toString())!=null){
					tempList.add(((Map)dataMap.get(cate.get("LEVEL_ID").toString())).get("NUM"));
				}else{
					tempList.add(0);
				}
				serieslist.add(tempList);
			}
			chartMap.put("seriesData", serieslist);
		}
		return chartMap;
	}

	@Override
	public Map getLastMonthQuestionPri(Map<String, String> params) {
		Map chartMap = new HashMap();
		Long endDay = DateUtil.getCurrentDate8();
		Long startDay = DateUtil.getDateAdd(endDay,-30,8);

		String userId = params.get("userId");
		params.put("startTime", startDay+"000000");
		params.put("endTime", endDay + "600000");

		StringBuilder builder = new StringBuilder();
		if(StringUtil.isBlank(userId)){
			builder.append(" SELECT count(ID) NUM,PRIORITY_ID FROM SC_WORKFLOW_QUESTION WHERE ");
			builder.append(" CUSTOMER_ID = :cusId AND CREATE_TIME >= :startTime AND CREATE_TIME <= :endTime ");
			builder.append(" GROUP BY PRIORITY_ID ");
		}else{
			builder.append(" SELECT count(q.ID) NUM,q.PRIORITY_ID FROM SC_WORKFLOW_QUESTION q,WORKFLOW_BASE b  ");
			builder.append(" where b.ID = q.FLOW_ID and  EXISTS ( ");
			builder.append(" select FLOWID from workflow_node n where b.ID = n.FLOWID and n.CURRENT_DEALER_ID = :userId ");
			builder.append(" ) and q.CUSTOMER_ID = :cusId and q.CREATE_TIME>=:startTime and q.CREATE_TIME<=:endTime  group by q.PRIORITY_ID ");
		}

		List<Map> dataList = baseDao.queryForList(builder.toString(),params);
		if(dataList!=null&&dataList.size()>0){
			Map dataMap = new HashMap();
			Map tempMap = new HashMap();
			List serieslist = new ArrayList();
			for(Map data : dataList){
				dataMap.put(data.get("PRIORITY_ID").toString(), data);
			}
			List<Map> catelist = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_PRI);
			for(Map cate : catelist){
				List tempList = new ArrayList();
				tempList.add(cate.get("DATAVALUE").toString());
				if(dataMap.get(cate.get("DATAKEY").toString())!=null){
					tempList.add(((Map)dataMap.get(cate.get("DATAKEY").toString())).get("NUM"));
				}else{
					tempList.add(0);
				}
				serieslist.add(tempList);
			}
			chartMap.put("seriesData", serieslist);
		}
		return chartMap;
	}

	@Override
	public Map getLastMonthQuestionEffect(Map<String, String> params) {
		Map chartMap = new HashMap();
		Long endDay = DateUtil.getCurrentDate8();
		Long startDay = DateUtil.getDateAdd(endDay,-30,8);

		String userId = params.get("userId");
		params.put("startTime", startDay+"000000");
		params.put("endTime", endDay + "600000");

		StringBuilder builder = new StringBuilder();
		if(StringUtil.isBlank(userId)){
			builder.append(" SELECT count(ID) NUM,INFLUENCE_ID FROM SC_WORKFLOW_QUESTION WHERE ");
			builder.append(" CUSTOMER_ID = :cusId AND CREATE_TIME >= :startTime AND CREATE_TIME <= :endTime ");
			builder.append(" GROUP BY INFLUENCE_ID ");
		}else{
			builder.append(" SELECT count(q.ID) NUM,q.INFLUENCE_ID FROM SC_WORKFLOW_QUESTION q,WORKFLOW_BASE b  ");
			builder.append(" where b.ID = q.FLOW_ID and  EXISTS ( ");
			builder.append(" select FLOWID from workflow_node n where b.ID = n.FLOWID and n.CURRENT_DEALER_ID = :userId ");
			builder.append(" ) and q.CUSTOMER_ID = :cusId and q.CREATE_TIME>=:startTime and q.CREATE_TIME<=:endTime  group by q.INFLUENCE_ID ");
		}

		List<Map> dataList = baseDao.queryForList(builder.toString(),params);
		if(dataList!=null&&dataList.size()>0){
			Map dataMap = new HashMap();
			Map tempMap = new HashMap();
			List serieslist = new ArrayList();
			for(Map data : dataList){
				dataMap.put(data.get("INFLUENCE_ID").toString(), data);
			}
			List<Map> catelist = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_EFFECT_DG);
			if(catelist!=null&&catelist.size()>0){
				for(Map cate : catelist){
					List tempList = new ArrayList();
					tempList.add(cate.get("DATAVALUE").toString());
					if(dataMap.get(cate.get("DATAKEY").toString())!=null){
						tempList.add(((Map)dataMap.get(cate.get("DATAKEY").toString())).get("NUM"));
					}else{
						tempList.add(0);
					}
					serieslist.add(tempList);
				}
			}
			chartMap.put("seriesData", serieslist);
		}
		return chartMap;
	}

	@Override
	public Map getLastMonthQuestionServer(Map<String, String> params) {
		Map chartMap = new HashMap();
		Long endDay = DateUtil.getCurrentDate8();
		Long startDay = DateUtil.getDateAdd(endDay,-30,8);

		StringBuilder builder = new StringBuilder();
		String userId = params.get("userId");
		params.put("startTime", startDay+"000000");
		params.put("endTime", endDay + "600000");
		if(StringUtil.isBlank(userId)){
			builder.append(" select count(ID) NUM,THIRD_CATEGORY_ID SERVER_ID  from SC_WORKFLOW_QUESTION where CUSTOMER_ID = :cusId ");
			builder.append(" and CREATE_TIME>=:startTime and CREATE_TIME<=:endTime group by THIRD_CATEGORY_ID ");
		}else{
			builder.append(" select count(q.ID) NUM,q.THIRD_CATEGORY_ID SERVER_ID  from SC_WORKFLOW_QUESTION q,WORKFLOW_BASE b ");
			builder.append(" where b.ID = q.FLOW_ID and  EXISTS ( ");
			builder.append(" select FLOWID from workflow_node n where b.ID = n.FLOWID and n.CURRENT_DEALER_ID = :userId ");
			builder.append(" ) and q.CUSTOMER_ID = :cusId and q.CREATE_TIME>=:startTime and q.CREATE_TIME<=:endTime  group by q.THIRD_CATEGORY_ID ");
		}




		List<Map> dataList = baseDao.queryForList(builder.toString(),params);
		if(dataList!=null&&dataList.size()>0){
			builder.setLength(0);
			builder.append(" SELECT C.ID SERVER_ID,C.CATEGORY_NAME SERVER_NAME FROM SC_SERVCE_CATEGORY C,SC_SERVCE_CATEGORY_CUSTOMER P   ");
			builder.append(" WHERE C.ID = P.CATEGORY_ID and C.LEVEL = 3 and C.STATE=1  ");
			builder.append(" AND P.STATE = 1 AND P.CUSTOMER_ID = :cusId ORDER BY SERIAL ASC ");
			List<Map> categoriesList = baseDao.queryForList(builder.toString(),params);
			List<String> categories = new ArrayList<String>();
			Map dataMap = new HashMap();
			Map tempMap = new HashMap();
			List<Map> series = new ArrayList<Map>();
			tempMap.put("name", "数量");
			List tempList = new ArrayList();
			for(Map data:dataList){
				dataMap.put(data.get("SERVER_ID").toString(), data);
			}
			for(Map cate:categoriesList){
				categories.add(cate.get("SERVER_NAME").toString());
				if(dataMap.get(cate.get("SERVER_ID").toString())!=null){
					tempList.add(((Map)dataMap.get(cate.get("SERVER_ID").toString())).get("NUM"));
				}else{
					tempList.add(0);
				}
			}
			tempMap.put("data", tempList);
			series.add(tempMap);
			chartMap.put("categories",categories);
			chartMap.put("series",series);
		}
		return chartMap;
	}

	@Override
	public Map getOrderNum(Map<String, String> params) {
		String type = params.get("type");
		//问题池
		int poolcount = 0;
		//问题待响应
		int dxycount = 0;
		//问题进行中
		int jxzcount = 0;
		if("1".equals(type)){
            poolcount = questionpoolCount(params);

			dxycount = queryQuestionOrderNodeCount(params);

			jxzcount = queryQuestionJxzCount(params);
		}else{
			poolcount = myquestionpoolCount(params);
			params.put("type", "1");
			dxycount = querymyQuestionOrderNodeCount(params);
			params.put("type", "2");
			jxzcount = querymyQuestionOrderNodeCount(params);
		}

		Map map = new HashMap();
		map.put("poolcount", poolcount);
		map.put("dxycount", dxycount);
		map.put("jxzcount", jxzcount);
		return map;
	}

	@Override
	public Map querymyQuestionNodeCount(Map<String,String> params ) {
		String type = params.get("type");
		String customerId = params.get("customerId");
		//初始化变量
		int ywc = 0;
		//问题受理
		int wtsl = 0;

		//问题审核
		int wtsh = 0;

		//问题诊断
		int wtzd = 0;

		//方案审批
		int fasp = 0;

		//方案实施
		int fass = 0;

		//问题回顾
		int wthg = 0;

		StringBuffer selectSql = new StringBuffer();
		StringBuffer sql = new StringBuffer();

		Map paramMap = new HashMap();
		paramMap.put("flowstate", type);
		paramMap.put("userId", params.get("userId"));
		selectSql.append( "SELECT COUNT(*) AS NUM,D.STATE FROM (SELECT A.ID,A.STATE FROM SC_WORKFLOW_QUESTION A,WORKFLOW_BASE B , WORKFLOW_NODE C  WHERE B.ID = C.FLOWID AND C.FLOWSTATE = :flowstate  AND C.CURRENT_DEALER_ID = :userId AND A.ID = B.BUSINESS_ID  ");
		sql.append( "SELECT COUNT(D.ID) FROM (SELECT A.ID FROM SC_WORKFLOW_QUESTION  A,WORKFLOW_BASE B , WORKFLOW_NODE C WHERE B.ID = C.FLOWID AND C.FLOWSTATE = :flowstate  AND C.CURRENT_DEALER_ID = :userId AND A.ID = B.BUSINESS_ID ");
		if(!StringUtil.isEmpty(customerId)){
			selectSql.append(" AND A.CUSTOMER_ID = :customerId ");
			sql.append(" AND A.CUSTOMER_ID = :customerId ");
			paramMap.put("customerId", customerId);
		}


		selectSql.append(" GROUP BY A.ID,A.STATE) D  GROUP BY D.STATE ");
		sql.append(" GROUP BY A.ID) D ");

		List<Map> list = baseDao.queryForList(selectSql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					wtsl += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					wtsh += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					wtzd += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					fasp += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					fass += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					wthg += num;
					continue;
				}

			}
		}
		int all = baseDao.queryForInteger(sql.toString(), paramMap);
		Map map = new HashMap();
		map.put("wtsl", wtsl);

		map.put("wtsh", wtsh);

		map.put("wtzd", wtzd);

		map.put("fasp", fasp);

		map.put("fass", fass);

		map.put("wthg", wthg);

		map.put("all", all);

		return map;
	}

	@Override
	public int querymyQuestionEndCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM (SELECT B.ID FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB , WORKFLOW_NODE C   ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID AND  C.FLOWID = WB.ID AND C.CURRENT_DEALER_ID = :userId AND WB.BUSINESSTYPE = :businessType ");

		sqlpart.append( " AND WB.WFSTATE = :state  ");
		params.put("state", params.get("type"));

		sql.append(sqlpart);
		sql.append( " GROUP BY B.ID  ) D");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo querymyQuestionEndList(PageInfo pageInfo,
			Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT B.RESOLVE_TYPE_NAME,B.CREATE_TIME,B.CREATE_USER_NAME,WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME,WB.ENDTIME , ");
		sql.append("WB.CURRENT_NODE_ID,WB.CURRENT_NODE_NAME,WB.CUSTOMER_NAME,WB.SUB_CUSTOMER_NAME,WB.PROJECT_NAME,WB.CURRENT_DEALER_NAME,WB.BUSINESS_ID,WB.WFSTATE,B.STATE ,B.NAME, ");
		sql.append(" D.HANG_UP_USERNAME,D.HANG_UP_TIME,D.HANG_UP_REASON  ");
		sql.append("FROM (SELECT F.* FROM  WORKFLOW_BASE F  WHERE  F.BUSINESSTYPE = :businessType ) WB , WORKFLOW_NODE C ,SC_WORKFLOW_QUESTION B LEFT JOIN HANG_UP_INFO D ON B.ID = D.BUS_ID ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND  C.FLOWID = WB.ID  AND C.CURRENT_DEALER_ID = :userId AND WB.BUSINESSTYPE = :businessType ");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		sqlpart = getMyEndSql(sqlpart,params);

		sqlpart.append( " AND WB.WFSTATE = :state  ");
		params.put("state", params.get("type"));
		sql.append(sqlpart);
		sql.append( " GROUP BY WB.ID,B.RESOLVE_TYPE_NAME, B.CREATE_TIME, B.CREATE_USER_NAME, WB.ORDER_CODE, WB.WFNAME, WB.BUSINESSTYPE, WB.CREATERNAME, WB.CREATETIME, WB.ENDTIME , WB.CURRENT_NODE_ID, WB.CURRENT_NODE_NAME, WB.CUSTOMER_NAME, WB.SUB_CUSTOMER_NAME, WB.PROJECT_NAME, WB.CURRENT_DEALER_NAME, WB.BUSINESS_ID, WB.WFSTATE, B.STATE , B.NAME, D.HANG_UP_USERNAME, D.HANG_UP_TIME, D.HANG_UP_REASON ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

	public StringBuilder getMyEndSql(StringBuilder sqlpart,Map<String, String> params){

		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		return sqlpart;
	}

	@Override
	public int querymyQuestionOrderNodeCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM (SELECT B.ID FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB , WORKFLOW_NODE C   ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID AND  C.FLOWID = WB.ID  AND C.FLOWSTATE = :flowstate AND C.CURRENT_DEALER_ID = :userId AND WB.BUSINESSTYPE = :businessType ");
		params.put("flowstate", params.get("type"));
		sqlpart = getMyNodeSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " GROUP BY B.ID  ) D");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo querymyQuestionOrderNodeList(PageInfo pageInfo,
			Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME,C.FLOWSTATE, ");
		sql.append("WB.CURRENT_NODE_ID,WB.CURRENT_NODE_NAME,WB.CUSTOMER_NAME,WB.SUB_CUSTOMER_NAME,WB.PROJECT_NAME,WB.CURRENT_DEALER_NAME,WB.BUSINESS_ID,WB.WFSTATE,B.STATE ,B.NAME ");
		sql.append("FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB , WORKFLOW_NODE C ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND  C.FLOWID = WB.ID AND C.FLOWSTATE = :flowstate  AND C.CURRENT_DEALER_ID = :userId AND WB.BUSINESSTYPE = :businessType  ");
		params.put("flowstate", params.get("type"));
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		sqlpart = getMyNodeSql(sqlpart,params);
		sql.append(sqlpart);
		sql.append( " GROUP BY WB.ID, WB.ORDER_CODE, WB.WFNAME, WB.BUSINESSTYPE, WB.CREATERNAME, WB.CREATETIME, C.FLOWSTATE, WB.CURRENT_NODE_ID, WB.CURRENT_NODE_NAME, WB.CUSTOMER_NAME, WB.SUB_CUSTOMER_NAME, WB.PROJECT_NAME, WB.CURRENT_DEALER_NAME, WB.BUSINESS_ID, WB.WFSTATE, B.STATE , B.NAME ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

    public StringBuilder getMyNodeSql(StringBuilder sqlpart,Map<String, String> params){
    	String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			sqlpart.append( " AND B.STATE = :state  ");
			params.put("state", status);
		}

    	return sqlpart;
    }

	@Override
	public Map queryQuestionpoolCount(HttpServletRequest request) {
		//初始化变量
		int ywc = 0;
		//问题受理
		int wtsl = 0;

		//问题审核
		int wtsh = 0;

		//问题诊断
		int wtzd = 0;

		//方案审批
		int fasp = 0;

		//方案实施
		int fass = 0;

		//问题回顾
		int wthg = 0;
		StringBuffer sql = new StringBuffer();
		StringBuffer sqlall = new StringBuffer();
		Map paramMap = new HashMap();
		paramMap.put("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DELETE);
		//查询该人员所属的项目
		sql.append("SELECT COUNT(*) AS NUM,E.STATE FROM SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT B.ID,B.ROLENAME FROM AC_ROLE B WHERE B.STATE = 1   ");
		sqlall.append("SELECT COUNT(F.ID) FROM (SELECT E.ID FROM SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT B.ID,B.ROLENAME FROM AC_ROLE B WHERE B.STATE = 1   ");

		sql.append(") C WHERE E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' )");
		sqlall.append(") C WHERE E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' )");

		String customer_Id = request.getParameter("customerId");
		if(!StringUtil.isEmpty(customer_Id)){
			sql.append(" AND E.CUSTOMER_ID = :customer_Id ");
			sqlall.append(" AND E.CUSTOMER_ID = :customer_Id ");
			paramMap.put("customer_Id", customer_Id);
		}

		sql.append(" GROUP BY E.STATE ");
		sqlall.append(" GROUP BY E.ID) F ");
		List<Map> list = baseDao.queryForList(sql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					wtsl += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					wtsh += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					wtzd += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					fasp += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					fass += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					wthg += num;
					continue;
				}

			}
		}
		int all = baseDao.queryForInteger(sqlall.toString(), paramMap);
		Map map = new HashMap();
		map.put("wtsl", wtsl);

		map.put("wtsh", wtsh);

		map.put("wtzd", wtzd);

		map.put("fasp", fasp);

		map.put("fass", fass);

		map.put("wthg", wthg);

		map.put("all", all);
		return map;
	}

	@Override
	public int questionpoolCount(Map<String, String> params) {
		/**
		 * 查询我的工单池规则
		 * 如果是一二三线或者驻场工程师桌面,则直接查询工单表中 所属分组是当前工程师所在组的
		 * 如果是项目服务台，则直接查询工单表中所属分组是当前工程师所在组的 （同上）
		 * 如果是客户服务台，查询我的工单池  则查询工单表中分组是 （查询该客户下所有的项目的服务台分组）
		 * 如果是总服务台，则查询所有客户下（加盟商下所有项目的服务台分组）
		 */

		StringBuffer sql = new StringBuffer();
		params.put("wfstate", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_WFSTATE_DELETE));

		sql.append("SELECT COUNT(D.ID) FROM SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT B.ID,B.ROLENAME FROM AC_ROLE B WHERE B.STATE = 1 ");

		String customer_Id = params.get("customer_Id");
		if(!StringUtil.isEmpty(customer_Id)){
			sql.append(" AND B.CUSTOMER_ID = :customer_Id ");
		}

		sql.append(") C WHERE  E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' )");
		StringBuilder builder = new StringBuilder(sql);
		builder = getPoolSql(builder,params);
		builder.append(" AND D.BUSINESSTYPE = :businessType");
		params.put("businessType",ConvertUtil.obj2StrBlank( Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		int count = baseDao.queryForInteger(builder.toString(),params);

		return count;
	}

	@Override
	public PageInfo questionpoolData(PageInfo pageInfo,
			Map<String, String> params) {
		/**
		 * 查询我的工单池规则
		 * 如果是项目服务台，则直接查询工单表
		 * 如果是客户服务台，查询我的工单池  则查询工单表中分组是 （查询该客户下所有的项目的分组）
		 * 如果是总服务台，则查询所有客户下（加盟商下所有项目的分组）
		 */

		StringBuffer sql = new StringBuffer();
		params.put("wfstate", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_WFSTATE_DELETE));
		//查询该人员所属的项目
		sql.append("SELECT D.* FROM SC_WORKFLOW_QUESTION E,WORKFLOW_BASE D,(SELECT B.ID,B.ROLENAME FROM AC_ROLE B WHERE B.STATE = 1   ");

		String customer_Id = params.get("customer_Id");
		if(!StringUtil.isEmpty(customer_Id)){
			sql.append(" AND B.CUSTOMER_ID = :customer_Id ");
		}
		sql.append(") C WHERE E.ID = D.BUSINESS_ID AND D.CURRENT_DEAL_ROLEIDA = C.ID AND D.WFSTATE != :wfstate AND (D.CURRENT_DEALER_ID IS NULL OR D.CURRENT_DEALER_ID = '' )");
		StringBuilder builder = new StringBuilder(sql);
		builder = getPoolSql(builder,params);

		builder.append(" AND D.BUSINESSTYPE = :businessType");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		builder.append(" ORDER BY D.CREATETIME DESC ");
		PageInfo result = baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), params);

		return result;
	}

	public StringBuilder getPoolSql(StringBuilder builder,Map<String, String> params){
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			builder.append(" AND E.STATE = :status ");
		}
		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			builder.append(" AND D.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND D.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			builder.append(" AND D.WFNAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}


		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			builder.append(" AND D.ORDER_CODE LIKE :orderCode");
			params.put("orderCode", "%"+orderCode+"%");
		}

		String customerName = params.get("customerName");
		if(StringUtil.notEmpty(customerName)) {
			builder.append(" AND D.CUSTOMER_NAME LIKE :customerName ");
			params.put("customerName", "%"+customerName+"%");
		}
		return builder;
	}

	@Override
	public Map queryQuestionNodeCount(HttpServletRequest request) {
		//初始化变量
		int ywc = 0;
		//问题受理
		int wtsl = 0;

		//问题审核
		int wtsh = 0;

		//问题诊断
		int wtzd = 0;

		//方案审批
		int fasp = 0;

		//方案实施
		int fass = 0;

		//问题回顾
		int wthg = 0;


		//只有服务台和管理人员才可以看到所有的工单，（所以查询当前的用户属于那种服务台）
		StringBuffer selectSql = new StringBuffer();
		StringBuffer sql = new StringBuffer();

		Map paramMap = new HashMap();
		selectSql.append( "SELECT COUNT(*) AS NUM,D.STATE FROM (SELECT A.ID,a.STATE FROM SC_WORKFLOW_QUESTION A,WORKFLOW_BASE B , WORKFLOW_NODE C  WHERE B.ID = C.FLOWID AND C.FLOWSTATE = 1  AND C.CURRENT_DEALER_ID IS NOT  NULL AND A.ID = B.BUSINESS_ID  ");
		sql.append( "SELECT COUNT(D.ID) FROM (SELECT A.ID  FROM SC_WORKFLOW_QUESTION  A,WORKFLOW_BASE B , WORKFLOW_NODE C WHERE  B.ID = C.FLOWID AND C.FLOWSTATE = 1  AND C.CURRENT_DEALER_ID IS NOT NULL AND A.ID = B.BUSINESS_ID ");
		String customer_Id = request.getParameter("customerId");
		if(!StringUtil.isEmpty(customer_Id)){
			selectSql.append(" AND A.CUSTOMER_ID = :customer_Id ");
			sql.append(" AND A.CUSTOMER_ID = :customer_Id ");
			paramMap.put("customer_Id", customer_Id);
		}
		selectSql.append(" GROUP BY A.ID,a.STATE) D  GROUP BY D.STATE ");
		sql.append(" GROUP BY A.ID) D ");

		List<Map> list = baseDao.queryForList(selectSql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					wtsl += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					wtsh += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					wtzd += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					fasp += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					fass += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					wthg += num;
					continue;
				}

			}
		}
		int all = baseDao.queryForInteger(sql.toString(), paramMap);
		Map map = new HashMap();
		map.put("wtsl", wtsl);

		map.put("wtsh", wtsh);

		map.put("wtzd", wtzd);

		map.put("fasp", fasp);

		map.put("fass", fass);

		map.put("wthg", wthg);

		map.put("all", all);

		return map;
	}

	@Override
	public int queryQuestionOrderNodeCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM (SELECT B.ID FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB , WORKFLOW_NODE C   ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID AND  C.FLOWID = WB.ID  AND C.FLOWSTATE = 1 AND C.CURRENT_DEALER_ID IS NOT NULL AND WB.BUSINESSTYPE = :businessType ");
		sqlpart = getNodeSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " GROUP BY B.ID  ) D");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo queryQuestionOrderNodeList(PageInfo pageInfo,
			Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME, ");
		sql.append("WB.CURRENT_NODE_ID,WB.CURRENT_NODE_NAME,WB.CUSTOMER_NAME,WB.SUB_CUSTOMER_NAME,WB.PROJECT_NAME,WB.CURRENT_DEALER_NAME,WB.BUSINESS_ID,WB.WFSTATE,B.STATE ,B.NAME ");
		sql.append("FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB , WORKFLOW_NODE C ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND  C.FLOWID = WB.ID AND C.FLOWSTATE = 1  AND C.CURRENT_DEALER_ID IS NOT NULL AND WB.BUSINESSTYPE = :businessType ");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		sqlpart = getNodeSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " GROUP BY WB.ID, WB.ORDER_CODE, WB.WFNAME, WB.BUSINESSTYPE, WB.CREATERNAME, WB.CREATETIME, WB.CURRENT_NODE_ID, WB.CURRENT_NODE_NAME, WB.CUSTOMER_NAME, WB.SUB_CUSTOMER_NAME, WB.PROJECT_NAME, WB.CURRENT_DEALER_NAME, WB.BUSINESS_ID, WB.WFSTATE, B.STATE , B.NAME ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

	public StringBuilder getNodeSql(StringBuilder sqlpart,Map<String, String> params){
		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}

		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			sqlpart.append( " AND B.STATE = :state  ");
			params.put("state", status);

		}
		return sqlpart;
	}

	@Override
	public int queryQuestionJxzCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM (SELECT B.ID FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB   ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND WB.BUSINESSTYPE = :businessType  AND  (\n" +
				"\tB.STATE != '9'\n" +
				"\tAND B.STATE != '10'\n" +
				"\tAND B.STATE != '7'\n" +
				") ");
		sqlpart = getJxzSql(sqlpart,params);
		sql.append(sqlpart);
		sql.append( " GROUP BY B.ID  ) D");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo queryQuestionJxzList(PageInfo pageInfo,
			Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT  WB.ID,WB.WFNAME,WB.BUSINESSTYPE,WB.WFSTATE,WB.WORKFLOWTYPE,WB.CREATERNAME,WB.CREATERID,WB.CREATETIME,WB.ENDTIME,WB.MAINFLOWID,WB.CURRENT_NODE_NAME,WB.CURRENT_NODE_ID,WB.DEAL_TYPE,WB.CURRENT_DEALER_ID,WB.CURRENT_DEALER_NAME,WB.CURRENT_DEAL_ROLEIDA,WB.CURRENT_DEAL_ROLENAME,WB.WF_TEMPLATE_ID,WB.BUSINESS_ID,WB.ORDER_CODE,WB.CUSTOMER_ID,WB.CUSTOMER_NAME,WB.PROJECT_ID,WB.PROJECT_NAME,WB.SUB_CUSTOMER_NAME,WB.SUB_CUSTOMER_ID, B.STATE , B.NAME  ");
		sql.append("FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB LEFT JOIN WORKFLOW_NODE C ON C.FLOWID = WB.ID\n" +
				"AND WB.CURRENT_NODE_ID = C.ID ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND WB.BUSINESSTYPE = :businessType AND (\n" +
				"\tB.STATE != '9'\n" +
				"\tAND B.STATE != '10'\n" +
				"\tAND B.STATE != '7'\n" +
				") ");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));
		sqlpart = getJxzSql(sqlpart,params);
		sql.append(sqlpart);
		sql.append( " GROUP BY  WB.ID,WB.WFNAME,WB.BUSINESSTYPE,WB.WFSTATE,WB.WORKFLOWTYPE,WB.CREATERNAME,WB.CREATERID,WB.CREATETIME,WB.ENDTIME,WB.MAINFLOWID,WB.CURRENT_NODE_NAME,WB.CURRENT_NODE_ID,WB.DEAL_TYPE,WB.CURRENT_DEALER_ID,WB.CURRENT_DEALER_NAME,WB.CURRENT_DEAL_ROLEIDA,WB.CURRENT_DEAL_ROLENAME,WB.WF_TEMPLATE_ID,WB.BUSINESS_ID,WB.ORDER_CODE,WB.CUSTOMER_ID,WB.CUSTOMER_NAME,WB.PROJECT_ID,WB.PROJECT_NAME,WB.SUB_CUSTOMER_NAME,WB.SUB_CUSTOMER_ID, B.STATE , B.NAME  ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

	public  StringBuilder getJxzSql(StringBuilder sqlpart,Map<String, String> params){
		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId = params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName = params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode = params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract = params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri = params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg = params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source = params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String sl = params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		String status = params.get("status");
		if(StringUtil.notEmpty(status)) {
			sqlpart.append( " AND B.STATE = :state  ");
			params.put("state", status);
		}
		return sqlpart;
	}

	@Override
	public Map queryQuestionJxzNodeCount(HttpServletRequest request) {
		//初始化变量
		int ywc = 0;
		//问题受理
		int wtsl = 0;

		//问题审核
		int wtsh = 0;

		//问题诊断
		int wtzd = 0;

		//方案审批
		int fasp = 0;

		//方案实施
		int fass = 0;

		//问题回顾
		int wthg = 0;


		//只有服务台和管理人员才可以看到所有的工单，（所以查询当前的用户属于那种服务台）
		StringBuffer selectSql = new StringBuffer();
		StringBuffer sql = new StringBuffer();

		Map paramMap = new HashMap();
		selectSql.append( "SELECT COUNT(*) AS NUM,A.STATE FROM  SC_WORKFLOW_QUESTION A,WORKFLOW_BASE B  LEFT JOIN WORKFLOW_NODE C ON B.ID = C.FLOWID\n" +
				"AND B.CURRENT_NODE_ID = C.ID\n" +
				"AND C.FLOWSTATE <> 3 WHERE A.ID = B.BUSINESS_ID AND B.WFSTATE = 1  AND C.FLOWSTATE is not null");
		sql.append( "SELECT COUNT(A.ID)  FROM SC_WORKFLOW_QUESTION  A,WORKFLOW_BASE B  WHERE   A.ID = B.BUSINESS_ID");

		String customer_Id = request.getParameter("customerId");
		if(!StringUtil.isEmpty(customer_Id)){
			selectSql.append(" AND A.CUSTOMER_ID = :customer_Id ");
			sql.append(" AND A.CUSTOMER_ID = :customer_Id ");
			paramMap.put("customer_Id", customer_Id);
		}
		selectSql.append("  GROUP BY A.STATE ");

		List<Map> list = baseDao.queryForList(selectSql.toString(),paramMap);
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String state = ConvertUtil.obj2StrBlank(map.get("STATE"));
				int num = ConvertUtil.obj2Int(map.get("NUM"));
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SL)) {
					wtsl += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_SH)) {
					wtsh += num;
					continue;
				}
				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_WTZD)) {
					wtzd += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASP)) {
					fasp += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_FASS)) {
					fass += num;
					continue;
				}

				if(state.equals(Constants.SC_WORKFLOW_QUESTION_STATE_HG)) {
					wthg += num;
					continue;
				}

			}
		}
		sql.append(" AND A.STATE != '9' AND A.STATE !='7' AND A.STATE != '10'");
		int all = baseDao.queryForInteger(sql.toString(), paramMap);
		Map map = new HashMap();
		map.put("wtsl", wtsl);

		map.put("wtsh", wtsh);

		map.put("wtzd", wtzd);

		map.put("fasp", fasp);

		map.put("fass", fass);

		map.put("wthg", wthg);

		map.put("all", all);

		return map;
	}

	@Override
	public int queryQuestionEndCount(Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT COUNT(D.ID) FROM (SELECT B.ID FROM SC_WORKFLOW_QUESTION B,WORKFLOW_BASE WB   ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND WB.BUSINESSTYPE = :businessType  AND WB.WFSTATE = :type ");
		params.put("type", params.get("type"));

		sqlpart = getEndSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " GROUP BY B.ID  ) D");
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		return baseDao.queryForInteger(sql.toString(),params);
	}

	@Override
	public PageInfo queryQuestionEndList(PageInfo pageInfo,
			Map<String, String> params) {
		StringBuilder sql = new StringBuilder();
		StringBuilder sqlpart = new StringBuilder();
		sql.append("SELECT B.RESOLVE_TYPE_NAME,B.CREATE_TIME,B.CREATE_USER_NAME,WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME, WB.ENDTIME , ");
//		sql.append("SELECT B.RESOLVE_TYPE_NAME,B.CREATE_TIME,B.CREATE_USER_NAME,WB.ID,WB.ORDER_CODE,WB.WFNAME,WB.BUSINESSTYPE,WB.CREATERNAME,WB.CREATETIME,WB.WFNOTE ,WB.ENDTIME , ");
		sql.append("WB.CURRENT_NODE_ID,WB.CURRENT_NODE_NAME,WB.CUSTOMER_NAME,WB.SUB_CUSTOMER_NAME,WB.PROJECT_NAME,WB.CURRENT_DEALER_NAME,WB.BUSINESS_ID,WB.WFSTATE,B.STATE ,B.NAME ,");
		sql.append(" D.HANG_UP_USERNAME,D.HANG_UP_TIME,D.HANG_UP_REASON ,WB.SCORE ");
		sql.append("FROM (SELECT F.*,E.SCORE FROM  WORKFLOW_BASE F LEFT JOIN ORDER_SATIS_INFO E ON F.ID = E.BUSINESS_ID WHERE  F.BUSINESSTYPE = :businessType ) WB, WORKFLOW_NODE C ,SC_WORKFLOW_QUESTION B LEFT JOIN HANG_UP_INFO D ON B.ID = D.BUS_ID ");
		sqlpart.append(" WHERE WB.BUSINESS_ID = B.ID  AND  C.FLOWID = WB.ID AND WB.WFSTATE = :type ");
		params.put("type", params.get("type"));
		params.put("businessType", ConvertUtil.obj2StrBlank(Constants.WORKFLOW_BASE_BUSINESS_TYPE_QUESTION));

		sqlpart = getEndSql(sqlpart,params);

		sql.append(sqlpart);
		sql.append( " GROUP BY WB.ID,B.RESOLVE_TYPE_NAME, B.CREATE_TIME, B.CREATE_USER_NAME, WB.ID, WB.ORDER_CODE, WB.WFNAME, WB.BUSINESSTYPE, WB.CREATERNAME, WB.CREATETIME, WB.ENDTIME , WB.CURRENT_NODE_ID, WB.CURRENT_NODE_NAME, WB.CUSTOMER_NAME, WB.SUB_CUSTOMER_NAME, WB.PROJECT_NAME, WB.CURRENT_DEALER_NAME, WB.BUSINESS_ID, WB.WFSTATE, B.STATE , B.NAME , D.HANG_UP_USERNAME, D.HANG_UP_TIME, D.HANG_UP_REASON , WB.SCORE ORDER BY WB.CREATETIME DESC ");

		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), params);
	}

	public StringBuilder getEndSql(StringBuilder sqlpart,Map<String, String> params){
		String customerId = params.get("customerId");
		if(StringUtil.notEmpty(customerId)) {
			sqlpart.append(" AND B.CUSTOMER_ID = :customerId ");
		}
		String subCustomerId =  params.get("subCustomerId");
		if(StringUtil.notEmpty(subCustomerId)) {
			sqlpart.append(" AND B.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		String orderName =  params.get("orderName");
		if(StringUtil.notEmpty(orderName)) {
			sqlpart.append(" AND B.NAME LIKE :orderName ");
			params.put("orderName", "%"+orderName+"%");
		}

		String orderCode =  params.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			sqlpart.append(" AND B.ORDER_CODE LIKE :orderCode ");
			params.put("orderCode", "%"+orderCode+"%");
		}


		String contract =  params.get("contract");
		if(StringUtil.notEmpty(contract)) {
			sqlpart.append(" AND B.CONTACT_NAME LIKE :contract ");
			params.put("contract", "%"+contract+"%");
		}


		String pri =  params.get("pri");
		if(StringUtil.notEmpty(pri)) {
			String[] pris = pri.split(",");
			if(pris.length==1) {
				sqlpart.append(" AND B.PRIORITY_ID = :priority_id");
				params.put("priority_id", pris[0]);
			} else {
				sqlpart.append(" AND B.PRIORITY_ID IN (");
				for(int i=0; i<pris.length; i++) {
					sqlpart.append(" :pri"+i);
					sqlpart.append(",");
					params.put("pri"+i, pris[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}



		String dg =  params.get("dg");
		if(StringUtil.notEmpty(dg)) {
			String[] dgs = dg.split(",");
			if(dgs.length==1) {
				sqlpart.append(" AND B.INFLUENCE_ID = :influence_id");
				params.put("influence_id", dgs[0]);
			} else {
				sqlpart.append(" AND B.INFLUENCE_ID IN (");
				for(int i=0; i<dgs.length; i++) {
					sqlpart.append(" :dg"+i);
					sqlpart.append(",");
					params.put("dg"+i, dgs[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String source =  params.get("source");
		if(StringUtil.notEmpty(source)) {
			String[] sources = source.split(",");
			if(sources.length==1) {
				sqlpart.append(" AND B.SOURCE_ID = :type_id");
				params.put("type_id", sources[0]);
			} else {
				sqlpart.append(" AND B.SOURCE_ID IN (");
				for(int i=0; i<sources.length; i++) {
					sqlpart.append(" :type"+i);
					sqlpart.append(",");
					params.put("type"+i, sources[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}


		String sl =  params.get("sl");
		if(StringUtil.notEmpty(sl)) {
			String[] sls = sl.split(",");
			if(sls.length==1) {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID = :third_category_id");
				params.put("third_category_id", sls[0]);
			} else {
				sqlpart.append(" AND B.THIRD_CATEGORY_ID IN (");
				for(int i=0; i<sls.length; i++) {
					sqlpart.append(" :third_category_id"+i);
					sqlpart.append(",");
					params.put("third_category_id"+i, sls[i]);
				}
				sqlpart.deleteCharAt(sqlpart.lastIndexOf(","));
				sqlpart.append(")");
			}
		}
		String status =  params.get("status");
		if(StringUtil.notEmpty(status)) {
			sqlpart.append( " AND B.STATE = :state  ");
			params.put("state", status);
		}
		return sqlpart;
	}

	@Override
	public String queryQuestionGroupDealer(HttpServletRequest request) {
		String group_Id = request.getParameter("group_id");
		String sql = "SELECT B.ZSXM FROM AC_USER_REF_ROLE A,GG_USER B WHERE A.JSBH = :group_id AND A.YHBH = B.ID AND B.ZT = 1  ";
		List<Map> userList = baseDao.queryForList(sql, new SqlParameter("group_id",group_Id));
		StringBuffer userName = new StringBuffer();
		if(userList.size() > 0){
			for(Map map1:userList){
				userName.append(map1.get("ZSXM"));
				userName.append(",");
			}
			userName.deleteCharAt(userName.lastIndexOf(","));
		}else{
			String groupusersql = "SELECT B.ZSXM FROM AC_ROLE_GROUP_USER A,GG_USER B WHERE A.USER_ID = B.ID AND A.GROUP_ID = :groupId AND A.STATE = 1 ";
			userList = baseDao.queryForList(groupusersql,new SqlParameter("groupId",group_Id));
			for(Map map1:userList){
				userName.append(map1.get("ZSXM"));
				userName.append(",");
			}
			userName.deleteCharAt(userName.lastIndexOf(","));
		}
		return userName.toString();
	}

	@Override
	public String queryQuestionDealer(HttpServletRequest request) {
		StringBuffer userName = new StringBuffer();
		String node_Id = request.getParameter("node_id");
		WORKFLOW_NODE node = new WORKFLOW_NODE(node_Id).getInstanceById();
		String sql = "SELECT * FROM WORKFLOW_NODE WHERE SAME_NODE_KEY = :same_node_key ORDER BY IS_ADMIN DESC";
		List<Map> userList = baseDao.queryForList(sql,new SqlParameter("same_node_key",node.getSame_node_key()));
		for(Map map1:userList){
			userName.append(map1.get("CURRENT_DEALER_NAME"));
			if(!StringUtil.isEmpty(ConvertUtil.obj2StrBlank(map1.get("IS_ADMIN")))){
				userName.append("(主负责人)");
			}
			userName.append(",");
		}
		userName.deleteCharAt(userName.lastIndexOf(","));
		return userName.toString();
	}



}