package cn.ksource.web.facade.ciremind;

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.ConvertUtil;
import cn.ksource.core.util.DateUtil;
import cn.ksource.core.util.JsonUtil;
import cn.ksource.core.util.StringUtil;
import cn.ksource.core.web.SysInfoMsg;
import cn.ksource.core.workflow.NodeAnswerEntity;
import cn.ksource.core.workflow.NodeFinishEntity;
import cn.ksource.core.workflow.WorkflowCoreService;
import cn.ksource.web.Constants;
import cn.ksource.web.entity.WorkFlowSupportEntity;
import cn.ksource.web.service.order.OrderService;
import cn.ksource.web.service.record.RecordService;
import cn.ksource.web.service.workFlowSupport.WorkFlowSupportService;
import cn.ksource.web.util.DateParepareUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service("ciRemindFacade")
public class CiRemindFacadeImpl implements CiRemindFacade {
	@Autowired
	private BaseDao baseDao;
	@Autowired
	private WorkflowCoreService workflowCoreService;
	@Autowired
	private WorkFlowSupportService workFlowSupportService;
	@Autowired
	private OrderService orderService;
	@Autowired
	private RecordService recordService;

	@Override
	public PageInfo queryMyRemindData(PageInfo pageInfo,Map<String, String> param) {
		String userId=param.get("userId");
		String flowState = param.get("flowState");
		String nodeState = param.get("nodeState");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");
		String orderCode = param.get("orderCode");


		param.put("userId", userId);
		param.put("nodeState", nodeState);
		param.put("flowState", flowState);
		param.put("customerId", customerId);
		param.put("subCustomerId", subCustomerId);
		param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
		param.put("orderCode", "%"+orderCode+"%");

		StringBuilder builder = getMyRemindSql(param);
		return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), param);

	}

	@Override
	public int queryMyRemindCount(Map<String, String> param) {
		String userId=param.get("userId");
		String flowState = param.get("flowState");
		String nodeState = param.get("nodeState");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");
		String orderCode = param.get("orderCode");


		param.put("userId", userId);
		param.put("nodeState", nodeState);
		param.put("flowState", flowState);
		param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
		param.put("orderCode", "%"+orderCode+"%");
		param.put("customerId", customerId);
		param.put("subCustomerId", subCustomerId);


		StringBuilder builder = getMyRemindSql(param);
		String sql = "select count(*) from ( " + builder.toString() + " ) t";
		return baseDao.queryForInteger(sql,param);
	}

	/**
	 * 获取我的工单
	 * @param request
	 * @return
	 */
	private StringBuilder getMyRemindSql(Map<String, String> param){
		String userId=param.get("userId");
		String flowState = param.get("flowState");
		String nodeState = param.get("nodeState");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");


		StringBuilder builder = new StringBuilder();
		builder.append(" select n.*,b.WFNAME,b.CREATERNAME,b.CREATETIME,b.CURRENT_NODE_NAME,b.BUSINESSTYPE, ");
		builder.append(" t.PLAN_EXECUTION_DATE, r.ORDER_CODE,r.ID ORDERID,r.SERVICE_CONTENT,b.CUSTOMER_NAME,b.SUB_CUSTOMER_NAME,B.WFSTATE  ");
		builder.append(" from SC_WORKFLOW_CI_REMIND r  ");
		builder.append(" inner join WORKFLOW_BASE B on r.FLOW_ID = b.ID ");
		builder.append(" inner join CI_REMIND_TIMERTASK t on r.FLOW_ID = t.FLOW_ID ");
		builder.append(" inner join  ");
		builder.append(" ( ");
		builder.append(" 	select * from ( ");
		builder.append(" 	select ID NODEID, CREATETIME NODETIME,FLOWSTATE NODESTATE,FLOWID from WORKFLOW_NODE  ");
		builder.append(" 	where CURRENT_DEALER_ID = :userId  ");
				//环节状态
				if(StringUtil.isNotBlank(nodeState)){
					builder.append("and FLOWSTATE =:nodeState ");

				}
		builder.append(" 	order by FLOWSTATE asc  ");
		builder.append(" 	) t  ");
		builder.append(" 	group by FLOWID,NODEID,NODETIME,NODESTATE ");
		builder.append(" ) n  ");
		builder.append("  on b.ID = n.FLOWID ");
		//工单类型
		builder.append(" where b.BUSINESSTYPE = :businessType");
		//工单状态
		if(StringUtil.notEmpty(flowState)) {
			builder.append(" AND b.WFSTATE =:flowState ");

		}

		//客户
		if(StringUtil.isNotBlank(customerId)) {
			builder.append(" AND b.CUSTOMER_ID = :customerId ");
		}
		//下属单位
		if(StringUtil.isNotBlank(subCustomerId)) {
			builder.append(" AND b.SUB_CUSTOMER_ID = :subCustomerId ");
		}

		//工单编号
		String orderCode = param.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			builder.append(" AND r.ORDER_CODE LIKE :orderCode");

		}
		builder.append(" order by n.NODESTATE ASC,n.NODETIME desc,b.CREATETIME desc ");
		return builder;
	}
	/**
	 * 例行巡检基本信息
	 */
	@Override
	public Map queryRemindInfo(String orderId) {
		String sql = " select b.WFSTATE,h.*,t.PLAN_EXECUTION_DATE from SC_WORKFLOW_CI_REMIND h ,CI_REMIND_TIMERTASK t, WORKFLOW_BASE b " +
					" where h.FLOW_ID = t.FLOW_ID and b.ID=h.FLOW_ID  and h.id = :orderId ";
		return baseDao.queryForMap(sql,new SqlParameter("orderId",orderId));
	}
	/**
	 * 工单响应
	 * @param request
	 * @return
	 */
	@Override
	public boolean answerSubmit(Map<String, String> param) {
		String orderId = param.get("orderId");
		SC_WORKFLOW_CI_REMIND remind = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
		String nodeId = param.get("nodeId");
		WORKFLOW_BASE base = new WORKFLOW_BASE(remind.getFlow_id()).getInstanceById();
        WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
        NodeAnswerEntity entity = new NodeAnswerEntity();

        entity.setUser_id(param.get("ID"));
        entity.setUser_name(param.get("ZSXM"));

		boolean flag = workflowCoreService.answerNode(base, node, entity);
		return flag;
	}

	/**
	 * 关闭流程
	 */
	public void closeWorkFlowSubmit(Map<String, String> param){
		String orderId = param.get("orderId");

		String closeNote = param.get("closeNote");
		String nodeId = param.get("nodeId");

		String userName = param.get("userName");

		SC_WORKFLOW_CI_REMIND order = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
		WORKFLOW_BASE base = new WORKFLOW_BASE(order.getFlow_id()).getInstanceById();
		NodeFinishEntity finishEntity = new NodeFinishEntity();
		finishEntity.setDeal_result(1);
		finishEntity.setDeal_note_title(userName+"关闭了工单");
		finishEntity.setDeal_note(closeNote);
		WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
		workflowCoreService.finishNode(base, node, finishEntity);
		workflowCoreService.closeWorkFlow(base);
	}
	/**
	 * 服务台调度 提交
	 */
	@Override
	public SysInfoMsg doServerDispatch(Map<String, String> param,SC_WORKFLOW_CI_REMIND remind,String[] ciIdAry) {
		String orderId =param.get("orderId");
		String nodeId =param.get("nodeId");
		String executorIds = param.get("executorIds");
		String executorNames = param.get("executorNames");
		String main_executorId = param.get("main_executorId");
		String flowNote = param.get("flowNote");
		String dealUserName = "";

		String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();
		//更新业务表数据
		remind.setId(orderId).update();
		//设定执行人
		List<Map> userList = new ArrayList<Map>();
		String[] executorIdAry =  executorIds.split(",");
		String[] executorNameAry =  executorNames.split(",");

		Map cacheuser = new HashMap();

		for(int i=0;i<executorIdAry.length;i++){
			Map tempMap = new HashMap();
			tempMap.put("USER_ID", executorIdAry[i]);
			tempMap.put("USER_NAME", executorNameAry[i]);
			if(executorIdAry[i].equals(main_executorId)){
				tempMap.put("IS_ADMIN", "1");
				dealUserName=executorNameAry[i];

			}
			userList.add(tempMap);
		}



		String userId=param.get("ID");
		String userName=param.get("ZSXM");


		Map flowMsg = getFlowMsg(flowId,userId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));

		//增加处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content(nodeName+"："+userName+",将问题指派给了,"+dealUserName);
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id(userId);
		record.setDeal_user_name(userName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeId).setNode_name(nodeName);
		recordService.addRecord(record);

		//环节流转
		WorkFlowSupportEntity support = new WorkFlowSupportEntity();
		support.setFlowId(flowId);
		support.setNodeId(nodeId);
		support.setNote(flowNote);
		support.setUserName(userName);
		support.setUserId(userId);
		support.setNextNodeTemplateId(Constants.REMIND_DEAL);
		support.setNextUserList(userList);
		support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
		SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
		addPatrolCi(orderId,ciIdAry);
		return msg;
	}

	/**
	 * 通过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 void addPatrolCi(String orderId, String[] ciIdAry) {
		baseDao.execute("delete from SC_WORKFLOW_CI_REMIND_DETAIL where order_id = :orderId", new SqlParameter("orderId",orderId));
		if(ciIdAry!=null&&ciIdAry.length>0){
			ArrayList<SqlParameter> paramList = new ArrayList<SqlParameter>();
			for(int i=0;i<ciIdAry.length;i++){
				SqlParameter param = new SqlParameter();
				param.addValue("id", StringUtil.getUUID())
					.addValue("ciId", ciIdAry[i])
					.addValue("orderId", orderId);
				paramList.add(param);
			}
			String sql = " insert into SC_WORKFLOW_CI_REMIND_DETAIL (ID,CI_ID,ORDER_ID,DEAL_STATE) " +
					" values (:id,:ciId,:orderId,3)";
			baseDao.executeBatch(sql, paramList);
		}
	}
	/**
	 * 获取例行巡检设备列表
	 */
	@Override
	public List<Map> getRemindCiList(String orderId) {
		StringBuilder sql = new StringBuilder();
		sql.append(" select b.ID CIID,r.USER_NAME,r.DEAL_STATE,r.ID,c.NAME CATENAME,c.ID CATEID,b.CINAME,b.SEARCHCODE,b.POSITION from SC_WORKFLOW_CI_REMIND_DETAIL r  ");
		sql.append(" inner join cmdb_ci_base b   ");
		sql.append(" on r.CI_ID = b.ID   ");
		sql.append(" inner join cmdb_ci_category c   ");
		sql.append(" on b.LV3_ID  = c.ID   ");
		sql.append(" where r.ORDER_ID = :orderId  ");
		return baseDao.queryForList(sql.toString(),new SqlParameter("orderId",orderId));
	}

	@Override
	public List<Map> getRemindCiList(Map param) {
		String sql = " select c.business_id cateId from ci_remind_timertask a , ci_remind_customer_item b, ci_remind_item c "
				+ " where a.customer_item_id=b.id and b.item_id = c.id and a.flow_id = :flowId ";
		String cateId = baseDao.queryForString(sql,param);
		param.put("cateId",cateId);

		String ciIds = ConvertUtil.obj2Str(param.get("ciIds"));
		sql = " select b.*,c.NAME CATENAME from cmdb_ci_base b " +
				" inner join cmdb_ci_category c on b.LV3_ID = c.ID " +
				" inner join CI_REMIND_CILIST r on r.CI_ID = b.id " +
				" where b.CUS_ID = :customerId and b.SUB_CUS_ID=:subCustomerId  " ;
		if(StringUtil.isNotBlank(ciIds)){
			sql = sql +	" and b.ID not in (:ciIds) ";
			param.put("ciIds", Arrays.asList(ciIds.split(",")));
		}
		if (StringUtil.notEmpty(cateId)) {
			sql = sql +	" and ( b.lv3_id=:cateId OR b.lv2_id=:cateId )";
		}
		sql = sql +	" and b.STATE=1 group by b.id ";
		return baseDao.queryForList(sql,param);
	}

	@Override
	public Map getPatrolInfo(String patrolId) {
		String sql = " select * from SC_WORKFLOW_CI_REMIND_DETAIL where id = :patrolId";
		SqlParameter param = new SqlParameter();
		param.addValue("patrolId", patrolId);
		return baseDao.queryForMap(sql, param);
	}

	@Override
	public SysInfoMsg doEngineerPatrol(Map<String, String> param) {
		String orderId = ConvertUtil.obj2StrBlank(param.get("orderId"));
		String nodeId = ConvertUtil.obj2StrBlank(param.get("nodeId"));
		String note = ConvertUtil.obj2StrBlank(param.get("flowNote"));
		String summary = ConvertUtil.obj2StrBlank(param.get("summary"));


		String userName = param.get("ZSXM");
		String userId = param.get("Id");

		new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().setOrder_note(summary).update();
		String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();

		Map flowMsg = getFlowMsg(flowId,userId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));

		//增加处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content(nodeName+"："+userName+",已处理维护执行");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id(userId);
		record.setDeal_user_name(userName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeId).setNode_name(nodeName);
		recordService.addRecord(record);

		//环节流转
		WorkFlowSupportEntity support = new WorkFlowSupportEntity();
		support.setFlowId(flowId);
		support.setNodeId(nodeId);
		support.setNote(note);
		support.setUserName(userName);
		support.setUserId(userId);
		support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
		Integer is_admin = new WORKFLOW_NODE(nodeId).getInstanceById().getIs_admin();
		if(is_admin!=null&&is_admin==1){
			support.setNextNodeTemplateId(Constants.REMIND_APPROVE);
			support.setEverDealflag(true);
			support.setEverNodeTemplateId(Constants.REMIND_DISPATCH);
		}
		SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
		return msg;
	}
	/**
	 * 回退
	 */
	@Override
	public void doSendback(Map<String, String> param) {
		String orderId = param.get("orderId");
		String nodeId = param.get("nodeId");
		String lastNodeTemplateId = param.get("lastNodeTemplateId");
		String note = param.get("backNote");

		String userName = ConvertUtil.obj2StrBlank(param.get("ZSXM"));
		String userId = ConvertUtil.obj2StrBlank(param.get("ID"));

		String flowId = param.get("flowId");

		WorkFlowSupportEntity support = new WorkFlowSupportEntity();
		support.setFlowId(flowId);
		support.setNodeId(nodeId);
		support.setUserName(userName);
		support.setUserId(userId);
		support.setNote(note);
		support.setEverNodeTemplateId(lastNodeTemplateId);
		support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
		SysInfoMsg msg = workFlowSupportService.doOrderSendback(support);
	}
	/**
	 * 结束流程
	 */
	@Override
	public SysInfoMsg doEndRemindFlow(Map<String, String> param) {
		String orderId = ConvertUtil.obj2StrBlank(param.get("orderId"));
		String nodeId = ConvertUtil.obj2StrBlank(param.get("nodeId"));
		String note = ConvertUtil.obj2StrBlank(param.get("flowNote"));
		String userName = param.get("ZSXM").toString();
		String userId = param.get("Id").toString();
		String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();

		Map flowMsg = getFlowMsg(flowId,userId);
		String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
		String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));

		//增加处理记录
		GG_RECORD record = new GG_RECORD();
		record.setDeal_content(nodeName+"："+userName+",已审核");
		record.setDeal_time(DateUtil.getCurrentDate14());
		record.setDeal_user_id(userId);
		record.setDeal_user_name(userName);
		record.setBusiness_id(flowId);
		record.setNode_id(nodeId).setNode_name(nodeName);
		recordService.addRecord(record);


		//环节流转
		WorkFlowSupportEntity support = new WorkFlowSupportEntity();
		support.setFlowId(flowId);
		support.setNodeId(nodeId);
		support.setNote(note);
		support.setUserName(userName);
		support.setUserId(userId);
		support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
		support.setFlowEndflag(true);
		SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
		Long endTime = DateUtil.getCurrentDate14();
		new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().setFinish_time(endTime).update();
		return msg;
	}

	@Override
	public Map getRemindeItem(Map<String, String> param) {
		String flowId= param.get("flowId");
		param.put("flowId",flowId);
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT * FROM SC_WORKFLOW_CI_REMIND c ");
		sql.append(" WHERE  c.FLOW_ID=:flowId");
		Map remindMap=baseDao.queryForMap(sql.toString(), param);
		Map map =new HashMap();
		if(remindMap!=null && remindMap.size()>0){
			//服务工程师
			StringBuilder selSql=new StringBuilder();
			selSql.append("SELECT A.CURRENT_DEALER_NAME,B.SJHM FROM workflow_node A,GG_USER B WHERE A.CURRENT_DEALER_ID=B.ID AND A.FLOWID=:flowId AND A.IS_ADMIN=1 AND A.NODE_TEMPLATE_ID=:nodeId");
			Map dealerMap=baseDao.queryForMap(selSql.toString(),new SqlParameter().addValue("flowId", flowId).addValue("nodeId", Constants.REMIND_DEAL));
			System.out.println(dealerMap);
			map.put("dealerMap", dealerMap);
			//应维护配置数量
			sql.setLength(0);
			param.put("orderId",String.valueOf(remindMap.get("ID")));
			sql.append("SELECT ID FROM SC_WORKFLOW_CI_REMIND_DETAIL WHERE ORDER_ID=:orderId");
			List detailCountList=baseDao.queryForList(sql.toString(),param);
			map.put("detailCount", detailCountList.size());
			if(detailCountList==null || detailCountList.size()==0)map.put("detailCount", 0);
			//实际维护配置数量
			sql.setLength(0);
			param.put("state",String.valueOf(Constants.CI_REMIND_DETAIL_STATE_ONE));
			sql.append("SELECT ID FROM SC_WORKFLOW_CI_REMIND_DETAIL WHERE ORDER_ID=:orderId AND DEAL_STATE=:state");
			List detailStateCountList=baseDao.queryForList(sql.toString(),param);
			map.put("detailStateCount", detailStateCountList.size());
			if(detailStateCountList==null || detailStateCountList.size()==0)map.put("detailStateCount", 0);
			//审核人
			sql.setLength(0);
			sql.append("SELECT * FROM WORKFLOW_NODE WHERE NODE_TEMPLATE_ID=:templateId AND FLOWID=:flowId ORDER BY CREATETIME DESC");
			param.put("templateId", "04e5ae6861fd4ef6bbc521e30b4d11bc");
			param.put("flowId", flowId);
			List<Map> nodeList=baseDao.queryForList(sql.toString(), param);
			if(nodeList!=null && nodeList.size()>0){
				map.put("node", nodeList.get(0));
			}
			//文档列表
			String fileSql = "select * from GG_FILES where EXTEND1=:BUSINESS_ID AND DEL_FLAG = 1 order by  ORDERNUM";
			List<Map> fileList = baseDao.queryForList(fileSql,new SqlParameter("BUSINESS_ID",flowId));
			map.put("fileList", fileList);
			//涉及工单列表
			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()));
				}
			}
			map.put("orderList", orderList);
		}
		map.put("remindMap", remindMap);
		return map;
	}

	@Override
	public Map getRemindDetail(Map<String, String> param) {
		String orderId=param.get("orderId");
		param.put("orderId", orderId);
		StringBuilder sql=new StringBuilder();
		sql.append("SELECT c.USER_NAME,c.ORDER_NOTE,b.CINAME,b.POSITION,c.FINISH_TIME,c.DEAL_STATE FROM SC_WORKFLOW_CI_REMIND_DETAIL c,CMDB_CI_BASE b ");
		sql.append(" WHERE c.CI_ID=b.ID AND c.ORDER_ID=:orderId");
		List<Map> detailList=baseDao.queryForList(sql.toString(),param);
		if(detailList!=null && detailList.size()>0){
			for(Map map :detailList){
				map.put("DEAL_STATE", Constants.getmapCI_REMIND_DETAIL_STATE(Integer.parseInt(map.get("DEAL_STATE").toString())));
			}
		}
		SC_WORKFLOW_CI_REMIND remind = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
		Map map = new HashMap();
		map.put("remind", remind);
		map.put("detailList", detailList);
		return map;
	}

	//例行维护管理


	@Override
	public int queryJxzRemindOrderCount(Map<String, String> param) {
		StringBuilder buffer = new StringBuilder("SELECT COUNT(b.ID) FROM WORKFLOW_BASE b WHERE b.BUSINESSTYPE = :businessType AND b.WFSTATE = :wfstate ");

		return baseDao.queryForInteger(buffer.toString(),new SqlParameter("businessType",Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND).addValue("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DOING));
	}

	@Override
	public Map queryNodeCount(Map<String, String> param) {
		StringBuilder buffer = new StringBuilder("SELECT  n.NODE_TEMPLATE_ID,COUNT(n.NODE_TEMPLATE_ID) AS num FROM WORKFLOW_NODE n, WORKFLOW_BASE b WHERE b.CURRENT_NODE_ID = n.ID and b.BUSINESSTYPE = :businessType AND b.WFSTATE = :wfstate ");

		buffer.append(" GROUP BY n.NODE_TEMPLATE_ID ");
		List<Map> list =  baseDao.queryForList(buffer.toString(),new SqlParameter("businessType",Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND).addValue("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DOING));
		Map resultMap = new HashMap();
		if(null != list && list.size()>0) {
			for(Map map : list) {
				resultMap.put(map.get("NODE_TEMPLATE_ID"), map.get("num"));
			}
		}
		return resultMap;
	}

	@Override
	public PageInfo queryRemindOrderList(PageInfo pageInfo,Map<String, String> param) {

		StringBuilder builder = new StringBuilder();
		String flowState = param.get("flowState");
		String orderCode = param.get("orderCode");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");

		String nodeTempId = param.get("nodeTempId");

		param.put("customerId", customerId);
		param.put("subCustomerId", subCustomerId);
		param.put("flowState", flowState);
		param.put("orderCode", "%"+orderCode+"%");
		param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
		param.put("nodeTempId", nodeTempId);

		builder = getAllRemindSql(param);
		return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), param);
	}


	@Override
	public int queryRemindOrderCount(Map<String, String> param) {
		StringBuilder builder = new StringBuilder();
		String flowState = param.get("flowState");
		String orderCode = param.get("orderCode");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");

		param.put("flowState", flowState);
		param.put("customerId", customerId);
		param.put("subCustomerId", subCustomerId);
		param.put("orderCode", "%"+orderCode+"%");
		param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
		String nodeTempId = param.get("nodeTempId");
		param.put("nodeTempId", nodeTempId);

		builder = getAllRemindSql(param);
		String sql = "select count(*) from ( " + builder.toString() + " ) t" ;
		return baseDao.queryForInteger(sql.toString(),param);
	}

	/**
	 * 服务台工单列表
	 * @param request
	 * @return
	 */
	private StringBuilder getAllRemindSql(Map<String, String> param){
		String flowState = param.get("flowState");
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");
		String nodeTempId = param.get("nodeTempId");


		StringBuilder builder = new StringBuilder();
		builder.append(" select b.ID FLOWID,b.WFNAME,b.CREATERNAME,b.CREATETIME,b.CURRENT_NODE_NAME,b.BUSINESSTYPE, ");
		builder.append(" t.PLAN_EXECUTION_DATE,r.ORDER_CODE,r.ID ORDERID,r.SERVICE_CONTENT,b.CUSTOMER_NAME,b.SUB_CUSTOMER_NAME,B.WFSTATE  ");
		builder.append(" from SC_WORKFLOW_CI_REMIND r  ");
		builder.append(" inner join WORKFLOW_BASE b on r.FLOW_ID = b.ID ");
		builder.append(" inner join CI_REMIND_TIMERTASK t on r.FLOW_ID = t.FLOW_ID ");

		//工单类型
		builder.append(" where b.BUSINESSTYPE = :businessType");
		//工单状态
		if(StringUtil.notEmpty(flowState)) {
			builder.append(" AND b.WFSTATE =:flowState ");
		}


		//客户
		if(StringUtil.isNotBlank(customerId)) {
			builder.append(" AND b.CUSTOMER_ID = :customerId ");
		}
		//下属单位
		if(StringUtil.isNotBlank(subCustomerId)) {
			builder.append(" AND b.SUB_CUSTOMER_ID = :subCustomerId ");

		}
		//工单编号
		String orderCode = param.get("orderCode");
		if(StringUtil.notEmpty(orderCode)) {
			builder.append(" AND r.ORDER_CODE LIKE :orderCode");
		}

		if(StringUtil.notEmpty(nodeTempId)) {
			builder.append(" AND EXISTS (SELECT n.ID FROM WORKFLOW_NODE n WHERE b.CURRENT_NODE_ID = n.ID AND n.NODE_TEMPLATE_ID = :nodeTempId ) ");
		}

		builder.append(" order by b.CREATETIME desc,t.PLAN_EXECUTION_DATE desc ");
		return builder;
	}

	@Override
	public Map getRemindItemSubTimerTaskData(String customerId, String month) {
		//查询该客户下的所有下属单位
		String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
		List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));

		Map currentCustomer = new HashMap();
		currentCustomer.put("ID", customerId);
		currentCustomer.put("CUSTOMER_NAME", new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById().getCustomer_name());
		subList.add(0, currentCustomer);


		if(!StringUtil.notEmpty(month)) {
			month = DateUtil.getCurrentDate6().toString();
		}

		String monthBeginDay = month+"01";
		//查询当月的所有天数
		String monthLastDay = DateParepareUtil.lastDayMonth(month, "yyyyMM", "yyyyMMdd");


		List<String> days = DateUtil.getBetweenTwoDateCycleList(monthBeginDay, monthLastDay, 2,1, "yyyyMMdd","yyyyMMdd");
		if(subList!=null && subList.size()>0){
			for(Map subMap:subList){
				//查询执行计划
				StringBuilder taskSql=new StringBuilder("SELECT A.PLAN_EXECUTION_DATE,A.STATE,A.FLOW_ID,A.SUB_CUSTOMER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B WHERE A.CUSTOMER_ITEM_ID=B.ID ");
				taskSql.append(" AND A.CUSTOMER_ID=:customerId  AND A.SUB_CUSTOMER_ID=:subId AND A.PLAN_EXECUTION_DATE>:beginDate AND A.PLAN_EXECUTION_DATE<:endDate");
				List<Map> taskList=baseDao.queryForList(taskSql.toString(), new SqlParameter().addValue("customerId", customerId).addValue("subId", subMap.get("ID"))
						.addValue("beginDate", monthBeginDay).addValue("endDate", monthLastDay));
				List<Map> isMarkList = new ArrayList<Map>();
				for(String day:days){
					Map markMap=new HashMap();

					markMap.put("day", day);



					int zjh = 0;
					int yzx = 0;
					if(taskList!=null && taskList.size()>0){
						List<Map> plans = new ArrayList<Map>();
						for(Map map:taskList){
							Map plan = new HashMap();



							Integer task=2;
							Integer mark=0;
							String orderId = new String();
							String plan_execution_date = ConvertUtil.obj2StrBlank(map.get("PLAN_EXECUTION_DATE"));
							if(plan_execution_date.equals(day)){
								task=1;
								if(String.valueOf(map.get("STATE")).equals("1")){
									mark=1;
								}else if(String.valueOf(map.get("STATE")).equals("2")){
									yzx++;
									mark=2;
									orderId = ConvertUtil.obj2StrBlank(map.get("FLOW_ID"));
								}
								zjh++;
							}
							plan.put("task", String.valueOf(task));
							plan.put("mark", String.valueOf(mark));
							plan.put("orderId", orderId);
							plans.add(plan);
						}
						markMap.put("plans", plans);
					}
					markMap.put("zjh", zjh);
					markMap.put("yzx", yzx);
					isMarkList.add(markMap);
				}
				subMap.put("isMarkList", isMarkList);
			}
		}
		System.out.println(subList);
		Map map = new HashMap();
		map.put("subList", subList);
		map.put("days", days);
		return map;
	}

	@Override
	public List<Map> querySubCustomerRemindPlanForDay(Map<String, String> param) {
		String customerId = param.get("customerId");
		String subCustomerId = param.get("subCustomerId");
		String day = param.get("day");
		String selectSql = "SELECT A.*,C.ITEM_NAME,C.ITEM_NOTE ,W.ID ORDER_ID FROM " +
				" CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_ITEM C ,SC_WORKFLOW_CI_REMIND W " +
				" WHERE A.CUSTOMER_ITEM_ID = B.ID AND B.ITEM_ID = C.ID AND A.FLOW_ID=W.FLOW_ID " +
				" AND A.CUSTOMER_ID = :customerId AND A.SUB_CUSTOMER_ID = :subCustomerId " +
				" AND A.PLAN_EXECUTION_DATE = :day  AND B.USING_STATE = 1 " +
				" ORDER BY A.PLAN_EXECUTION_DATE DESC ";
		//Map paramMap = new HashMap();
		param.put("customerId", customerId);
		param.put("subCustomerId", subCustomerId);
		param.put("day", day);

		List<Map> plans = baseDao.queryForList(selectSql,param);
		return plans;
	}

	@Override
	public PageInfo getRemindItemData(PageInfo pageInfo,Map<String, String> param) {
		String customerId=param.get("customerId");
		String itemName=param.get("itemName");
		String subId=param.get("subId");
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT A.*,B.ID AS PROJECT_ITEM_ID,S.CUSTOMER_NAME " +
				" FROM (SELECT D.ID,D.CUSTOMER_NAME FROM SC_PARTNER_CUSTOMER_SUB D UNION ALL SELECT E.ID,E.CUSTOMER_NAME FROM SC_PARTNER_CUSTOMER_INFO E) S, CI_REMIND_ITEM A ," +
				" CI_REMIND_CUSTOMER_ITEM B LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE C ON C.PROJECT_ITEM_ID=B.ID " +
				" WHERE A.ID=B.ITEM_ID AND S.ID=C.SUB_CUSTOMER_ID AND B.USING_STATE=1 ");
		if(StringUtil.notEmpty(itemName)){
			sql.append(" AND A.ITEM_NAME LIKE :itemName");
		}

		if(StringUtil.notEmpty(subId)){
			sql.append(" AND C.SUB_CUSTOMER_ID=:subId");
		}

		sql.append(" AND B.CUSTOMER_ID=:customerId ");
		sql.append(" ORDER BY A.ITEM_TYPE,ORDER_NUM ASC");
		//SqlParameter paramMap = new SqlParameter();
		param.put("itemName", "%"+itemName+"%");
		param.put("subId", subId);
		param.put("customerId", customerId);
		return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
	}

	@Override
	public Integer getRemindItemCount(Map<String, String> param) {
		String customerId=param.get("customerId");
		String itemName=param.get("itemName");
		String subId=param.get("subId");
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT count(*) FROM CI_REMIND_ITEM A ,CI_REMIND_CUSTOMER_ITEM B LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE C ON C.PROJECT_ITEM_ID=B.ID WHERE A.ID=B.ITEM_ID AND B.USING_STATE=1 ");
		if(StringUtil.notEmpty(itemName)){
			sql.append(" AND A.ITEM_NAME LIKE:itemName");
		}
		if(StringUtil.notEmpty(subId)){
			sql.append(" AND C.SUB_CUSTOMER_ID=:subId");
		}
		sql.append(" AND B.CUSTOMER_ID=:customerId ");
		//SqlParameter paramMap = new SqlParameter();
		param.put("customerId", customerId);
		param.put("itemName", "%"+itemName+"%");
		param.put("subId", subId);
		return baseDao.queryForInteger(sql.toString(), param);
	}

	@Override
	public Map queryRemind(String customerItemId) {
		String selectSql = "SELECT A.ID,A.ITEM_NAME,A.CYCLE,A.PRIORITY_LEVEL_ID,A.PRIORITY_LEVEL_NAME," +
				" A.ITEM_NOTE,A.ORDER_NUM,A.STATE,A.BUSINESS_ID,A.BUSINESS_NAME,A.ITEM_TYPE,B.ID AS PROJECT_ITEM_ID,B.CUSTOMER_ID " +
				" FROM CI_REMIND_ITEM A,CI_REMIND_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.ID = :id ";
		Map item = baseDao.queryForMap(selectSql,new SqlParameter("id",customerItemId));
		return item;
	}

	/**
	 * 查询执行计划
	 * @param customerItemId
	 * @param customerId
	 * @param subCustomerId
	 * @return
	 */
	@Override
	public List queryItemPlan(String customerItemId,String customerId,String subCustomerId) {
		List result = new ArrayList();
		if(StringUtil.notEmpty(customerId)) {
			SC_PARTNER_CUSTOMER_INFO customer = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();

			long beginTime = customer.getValid_begin_date();
			long endTime = customer.getValid_end_date();


			Map paramMap = new HashMap();
			//查询所有已经生成的计划
			String selectSql = "SELECT A.*,W.ID ORDER_ID " +
					" FROM CI_REMIND_TIMERTASK A LEFT JOIN SC_WORKFLOW_CI_REMIND W ON A.FLOW_ID=W.FLOW_ID " +
					" WHERE A.CUSTOMER_ITEM_ID = :customerItemId AND A.CUSTOMER_ID = :customerId ";
			paramMap.put("customerId", customerId);
			paramMap.put("customerItemId", customerItemId);
			selectSql += " AND A.SUB_CUSTOMER_ID = :subId ";
			if(StringUtil.notEmpty(subCustomerId)) {
				paramMap.put("subId", subCustomerId);
			} else {
				paramMap.put("subId", customerId);
			}

			selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";


			List<Map> plans = baseDao.queryForList(selectSql,paramMap);

			Map<String,Map> cacheMap = new HashMap<String,Map>();
			if(null!=plans && plans.size()>0) {
				for(Map plan : plans) {
					String day = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
					cacheMap.put(day, plan);
				}
			}


			//求出所有月份的集合
			List<String> months = DateUtil.getBetweenTwoDateCycleList(ConvertUtil.obj2StrBlank(beginTime), ConvertUtil.obj2StrBlank(endTime), 1,1, "yyyyMMdd","yyyyMM");
			if(null!=months && months.size()>0) {
				for(int i=0; i<months.size();i++) {
					String month = months.get(i);

					String beginDay = month+"01";
					//得到当月的最后一天
					String lastDay = DateParepareUtil.lastDayMonth(month,"yyyyMM","yyyyMMdd");

					List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");





					List<Map> newList = new ArrayList<Map>();
					for(String str : days) {
						Map map = new HashMap();

						if(cacheMap.containsKey(str)) {
							map = cacheMap.get(str);
							map.put("day", str);
							map.put("check", 1);
						} else {
							map.put("day",str);
							map.put("check", 2);
						}

						//是否显示复选框
						long date = ConvertUtil.obj2Long(str);
						if(date>=beginTime && date<=endTime) {
							map.put("showbox", 1);
						} else {
							map.put("showbox", 2);
						}

						//今天之前的复选框不可用
						long today = DateUtil.getCurrentDate8();
						if(date>today) {
							map.put("isUse", 1);
						} else {
							map.put("isUse", 2);
						}

						newList.add(map);
					}

					Map map = new HashMap();
					map.put("month", month);
					map.put("days", newList);
					result.add(map);
				}
			}

		}
		System.out.println(JsonUtil.list2Json(result));
		return result;
	}

	@Override
	public PageInfo getRemindOrderList(PageInfo pageInfo,Map<String, String> param) {
		String customerId=param.get("customerId");
		String subId=param.get("subId");
		String beginDate=param.get("beginDay");
		String endDate=param.get("endDay");
		StringBuilder sql = new StringBuilder();
		sql.append(" SELECT A.SUB_CUSTOMER_ID SUB_CUS_ID,A.FLOW_ID,B.*,D.ITEM_NAME,A.PLAN_EXECUTION_DATE,A.STATE AS TIMESTATE,A.CUSTOMER_ITEM_ID FROM CI_REMIND_TIMERTASK A LEFT JOIN  SC_WORKFLOW_CI_REMIND  B ON A.FLOW_ID=B.FLOW_ID  ");
		sql.append(" LEFT JOIN CI_REMIND_CUSTOMER_ITEM  C ON A.CUSTOMER_ITEM_ID=C.ID LEFT JOIN CI_REMIND_ITEM D ON C.ITEM_ID=D.ID");
		sql.append(" WHERE A.STATE != 3 ");

		//SqlParameter paramMap = new SqlParameter();


		if(StringUtil.notEmpty(customerId)) {
			sql.append("AND A.CUSTOMER_ID=:customerId  ");
			param.put("customerId", customerId);
		}


		if(StringUtil.notEmpty(subId)) {
			sql.append("AND A.SUB_CUSTOMER_ID=:subId  ");
			param.put("subId", subId);
		}


		if(StringUtil.notEmpty(beginDate) && StringUtil.notEmpty(endDate)){
			sql.append(" AND A.PLAN_EXECUTION_DATE>=:beginDate AND A.PLAN_EXECUTION_DATE<=:endDate");
			param.put("beginDate", beginDate);
			param.put("endDate", endDate);
		}
		sql.append(" ORDER BY A.PLAN_EXECUTION_DATE DESC");
		param.put("customerId", customerId);

		PageInfo list=baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);

		if(list!=null && list.getDatas().size()>0){
			for(Map map :list.getDatas()){
				map.put("TIMESTATE_LABEL", Constants.getmapCI_REMIND_TIMERTASK_STATE_Label(Integer.parseInt(map.get("TIMESTATE").toString())));
			}
		}
		return list;
	}

	@Override
	public Integer getRemindOrderCount(Map<String, String> param){
		String customerId=param.get("customerId");
		String subId=param.get("subId");
		String beginDate=param.get("beginDay");
		String endDate=param.get("endDay");
		StringBuilder sql = new StringBuilder();
		sql.append(" SELECT COUNT(A.ID) FROM CI_REMIND_TIMERTASK A LEFT JOIN  SC_WORKFLOW_CI_REMIND  B ON A.FLOW_ID=B.FLOW_ID  ");
		sql.append(" LEFT JOIN CI_REMIND_CUSTOMER_ITEM  C ON A.CUSTOMER_ITEM_ID=C.ID LEFT JOIN CI_REMIND_ITEM D ON C.ITEM_ID=D.ID");
		sql.append(" WHERE A.STATE != 3 ");

		//SqlParameter paramMap = new SqlParameter();


		if(StringUtil.notEmpty(customerId)) {
			sql.append("AND A.CUSTOMER_ID=:customerId  ");
			param.put("customerId", customerId);
		}

		if(StringUtil.notEmpty(subId)) {
			sql.append("AND A.SUB_CUSTOMER_ID=:subId  ");
			param.put("subId", subId);
		}


		if(StringUtil.notEmpty(beginDate) && StringUtil.notEmpty(endDate)){
			sql.append(" AND A.PLAN_EXECUTION_DATE>=:beginDate AND A.PLAN_EXECUTION_DATE<=:endDate");
			param.put("beginDate", beginDate);
			param.put("endDate", endDate);
		}
		param.put("customerId", customerId);
		param.put("subId", subId);
		param.put("beginDate", beginDate);
		param.put("endDate", endDate);
		return baseDao.queryForInteger(sql.toString(),param);
	}

	@Override
	public List getSubRemindCiList(Map<String, String> param) {
		StringBuilder sql =new StringBuilder();
		if(StringUtil.isBlank(param.get("flowId"))){
			sql.append("SELECT A.*,B.STATE,B.PROJECT_ITEM_ID FROM cmdb_ci_base A ,CI_REMIND_CILIST B ,CI_REMIND_CUSTOMER_ITEM C");
			sql.append(" WHERE A.ID=B.CI_ID AND B.PROJECT_ITEM_ID=C.ID  AND B.PROJECT_ITEM_ID=:itemId");
			if(StringUtil.isNotBlank(param.get("subCusId"))){
				sql.append(" AND A.SUB_CUS_ID=:subCusId");
			}
		}else{
			sql.append(" select a.* from cmdb_ci_base a, sc_workflow_ci_remind_detail b,sc_workflow_ci_remind c ");
			sql.append(" where a.id = b.ci_id and b.order_id = c.id and c.flow_id = :flowId ");
		}
		return baseDao.queryForList(sql.toString(), param);
	}

	@Override
	public int queryProItemCount(Map<String, String> param) {
		String customerId = param.get("customerId");
		param.put("customerId", customerId);
		String sql = "SELECT COUNT(A.ID) FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";
		int count = baseDao.queryForInteger(sql, param);
		return count;
	}


	@Override
	public PageInfo queryProItemsData(PageInfo pageInfo,Map<String, String> param) {
		String customerId = param.get("customerId");
		String sql = "SELECT A.*,B.ITEM_NAME,B.ITEM_NOTE,B.PRIORITY_LEVEL_NAME,B.BUSINESS_NAME " +
				" FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID " +
				" AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";

		param.put("customerId", customerId);
		PageInfo info = baseDao.queryforSplitPageInfo(pageInfo, sql, param);
		return info;
	}


	@Override
	public Map queryItemSubCustomerPlan(String customerId,String itemId,String mon) {
		//查询该客户下的所有下属单位
		String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
		List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));


		Map currentCustomer = new HashMap();
		currentCustomer.put("ID", customerId);
		currentCustomer.put("CUSTOMER_NAME", new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById().getCustomer_name());
		subList.add(0, currentCustomer);

		String year = DateUtil.format("yyyy", mon);

		String mm = DateUtil.format("MM", mon);
		String[] time = DateParepareUtil.queryFirstLastDate(year,mm);

		String beginDay = time[0].replaceAll("-", "");
		//得到当月的最后一天
		String lastDay = time[1].replaceAll("-", "");

		List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");

		Map resultMap = new HashMap();
		resultMap.put("month", mon);
		resultMap.put("days", days);

		List result = new ArrayList();
		if(StringUtil.notEmpty(customerId)) {
			SC_PARTNER_CUSTOMER_INFO customer = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();

			long beginTime = customer.getValid_begin_date();
			long endTime = customer.getValid_end_date();


			Map paramMap = new HashMap();
			//查询该客户下所有已经生成的计划
			String selectSql = "SELECT A.*,W.ID ORDER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B ,SC_WORKFLOW_CI_REMIND W " +
					" WHERE A.CUSTOMER_ITEM_ID = B.ID AND A.FLOW_ID=W.FLOW_ID " +
					" AND A.CUSTOMER_ITEM_ID = :projectItemId " +
					" AND B.CUSTOMER_ID = :customerId AND B.USING_STATE = 1 ";
			paramMap.put("projectItemId", itemId);
			paramMap.put("customerId", customerId);



			selectSql += "AND A.PLAN_EXECUTION_DATE >= :beginTime AND A.PLAN_EXECUTION_DATE <= :endTime ";
			paramMap.put("beginTime", beginDay);
			paramMap.put("endTime",  lastDay);

			selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";
			List<Map> plans = baseDao.queryForList(selectSql,paramMap);

			Map<String,Map> cacheMap = new HashMap<String,Map>();
			if(null!=plans && plans.size()>0) {
				for(Map plan : plans) {
					String subCustomerId = ConvertUtil.obj2StrBlank(plan.get("SUB_CUSTOMER_ID"));
					String plan_execution_date = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
					cacheMap.put(subCustomerId+"-"+plan_execution_date, plan);
				}
			}


			if(null!=subList && subList.size()>0) {
				for(Map cus : subList) {



					String cusId = ConvertUtil.obj2StrBlank(cus.get("ID"));
					String cusName = ConvertUtil.obj2StrBlank(cus.get("CUSTOMER_NAME"));

					List<Map> newList = new ArrayList<Map>();
					for(String str : days) {
						Map map = new HashMap();

						String unitKey = cusId+"-"+str;
						if(cacheMap.containsKey(unitKey)) {
							map = cacheMap.get(unitKey);
						}
						newList.add(map);
					}

					Map map = new HashMap();
					map.put("cusName", cusName);
					map.put("msgs", newList);
					result.add(map);
				}
			}

		}
		resultMap.put("rs", result);

		return resultMap;
	}

	@Override
	public String queryZbName(String itemId) {
		String selectSql = "SELECT B.ITEM_NAME FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID AND A.ID = :itemId ";
		return baseDao.queryForString(selectSql,new SqlParameter("itemId",itemId));
	}

	@Override
	public List queryCustomers(Map<String, String> param) {
		String customerId = param.get("customerId");
		//查询该客户下的所有下属单位
		String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
		List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));


		Map currentCustomer = new HashMap();
		currentCustomer.put("ID", customerId);
		SC_PARTNER_CUSTOMER_INFO mainCus = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
		currentCustomer.put("CUSTOMER_NAME", mainCus.getCustomer_name());
		currentCustomer.put("CONTACT", mainCus.getContact());
		currentCustomer.put("PHONE", mainCus.getPhone());

		subList.add(0, currentCustomer);
		return subList;
	}

	@Override
	public Map queryCusItemPlanReport(String customerId,String subCustomerId, String mon) {
		//查询该客户下的所有指标
		String sql="SELECT A.*,B.ITEM_NAME,B.ITEM_NOTE,B.PRIORITY_LEVEL_NAME,B.BUSINESS_NAME " +
				" FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B " +
				" WHERE A.ITEM_ID = B.ID AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";
		List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));



		String year = DateUtil.format("yyyy", mon);

		String mm = DateUtil.format("MM", mon);
		String[] time = DateParepareUtil.queryFirstLastDate(year,mm);

		String beginDay = time[0].replaceAll("-", "");
		//得到当月的最后一天
		String lastDay = time[1].replaceAll("-", "");

		List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");

		Map resultMap = new HashMap();
		resultMap.put("month", mon);
		resultMap.put("days", days);

		List result = new ArrayList();
		if(StringUtil.notEmpty(customerId)) {
			SC_PARTNER_CUSTOMER_INFO project = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();

			long beginTime = project.getValid_begin_date();
			long endTime = project.getValid_end_date();


			Map paramMap = new HashMap();
			//查询该客户下所有已经生成的计划
			String selectSql = "SELECT A.*,W.ID ORDER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B,SC_WORKFLOW_CI_REMIND W " +
					" WHERE A.CUSTOMER_ITEM_ID = B.ID AND A.FLOW_ID=W.FLOW_ID AND B.CUSTOMER_ID = :customerId " +
					" AND A.SUB_CUSTOMER_ID = :subCustomerId AND B.USING_STATE = 1 ";
			paramMap.put("customerId", customerId);

			selectSql += "AND A.PLAN_EXECUTION_DATE >= :beginTime AND A.PLAN_EXECUTION_DATE <= :endTime ";
			paramMap.put("beginTime", beginDay);
			paramMap.put("endTime",  lastDay);
			paramMap.put("subCustomerId", subCustomerId);

			selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";
			List<Map> plans = baseDao.queryForList(selectSql,paramMap);

			Map<String,Map> cacheMap = new HashMap<String,Map>();
			if(null!=plans && plans.size()>0) {
				for(Map plan : plans) {
					String project_item_id = ConvertUtil.obj2StrBlank(plan.get("CUSTOMER_ITEM_ID"));
					String plan_execution_date = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
					cacheMap.put(project_item_id+"-"+plan_execution_date, plan);
				}
			}


			if(null!=subList && subList.size()>0) {
				for(Map zb : subList) {
					String zbId = ConvertUtil.obj2StrBlank(zb.get("ID"));
					String zbName = ConvertUtil.obj2StrBlank(zb.get("ITEM_NAME"));

					List<Map> newList = new ArrayList<Map>();
					for(String str : days) {
						Map map = new HashMap();

						String unitKey = zbId+"-"+str;
						if(cacheMap.containsKey(unitKey)) {
							map = cacheMap.get(unitKey);
						}
						newList.add(map);
					}

					Map map = new HashMap();
					map.put("zbName", zbName);
					map.put("msgs", newList);
					result.add(map);
				}
			}

		}
		resultMap.put("rs", result);

		return resultMap;
	}

	@Override
	public String queryNodeId(String flowId,String userId) {
		String selectSql = "SELECT ID FROM WORKFLOW_NODE WHERE FLOWID=:flowId  AND CURRENT_DEALER_ID=:userId AND (FLOWSTATE=1 OR FLOWSTATE =2) ";
		return baseDao.queryForString(selectSql,new SqlParameter("flowId",flowId).addValue("userId", userId));
	}

	@Override
	public PageInfo remindPlanData(PageInfo pageInfo,Map<String, String> param) {
		String ciId=param.get("ciId");
		String selectSql = "SELECT C.* FROM CI_REMIND_CILIST A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_TIMERTASK C WHERE A.PROJECT_ITEM_ID = B.ID AND B.ID = C.CUSTOMER_ITEM_ID AND A.CI_ID = :ciId AND A.STATE = 1 AND C.STATE = 2 ORDER BY C.PLAN_EXECUTION_DATE DESC ";
		param.put("ciId", ciId);
		PageInfo plans=baseDao.queryforSplitPageInfo(pageInfo, selectSql, param);
		return plans;
	}

	@Override
	public int remindPlanCount(Map<String, String> param) {
		String ciId=param.get("ciId");
		String selectSql = "SELECT COUNT(C.ID) FROM CI_REMIND_CILIST A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_TIMERTASK C WHERE A.PROJECT_ITEM_ID = B.ID AND B.ID = C.CUSTOMER_ITEM_ID AND A.CI_ID = :ciId AND A.STATE = 1 AND C.STATE = 2 ORDER BY C.PLAN_EXECUTION_DATE DESC ";
		int count = baseDao.queryForInteger(selectSql, new SqlParameter("ciId",ciId));
		return count;
	}




}