package cn.ksource.web.facade.customerconfig.slacustomer;

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

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.ksource.beans.CI_DAILY_PATROL_ITEM;
import cn.ksource.beans.CMDB_CI_CATEGORY;
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.JsonUtil;
import cn.ksource.core.util.StringUtil;
import cn.ksource.core.web.WebUtil;
@Service("slaCustomerFacade")
public class SlaCustomerFacadeImpl implements SlaCustomerFacade{
	@Autowired
	private BaseDao baseDao;
	/**
	 * 查询已经适用于客户的指标项
	 */
	@Override
	public PageInfo queryItems(PageInfo pageInfo,Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql =new StringBuilder("SELECT B.*,A.USING_STATE,A.ID AS PROJECT_ITEM_ID FROM CI_DAILY_PATROL_CUSTOMER_ITEM A,CI_DAILY_PATROL_ITEM B WHERE A.ITEM_ID = B.ID AND A.CUSTOMER_ID = :customerId ");
		if(StringUtil.notEmpty(cate)){
			selectSql.append(" AND B.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND B.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND B.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND B.STATE = :state");
		}
		selectSql.append(" ORDER BY A.USING_STATE,B.ITEM_TYPE ASC");
		param.put("customerId", customerId);
		param.put("cate", cate);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		
		
		return baseDao.queryforSplitPageInfo(pageInfo, selectSql.toString(), param);
	}
	/**
	 * 查询已经适用于客户的指标项总数
	 */
	@Override
	public Integer queryItemsCount(Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql =new StringBuilder("SELECT count(*) FROM CI_DAILY_PATROL_CUSTOMER_ITEM A,CI_DAILY_PATROL_ITEM B WHERE A.ITEM_ID = B.ID AND A.CUSTOMER_ID = :customerId ");
		if(StringUtil.notEmpty(cate)){
			selectSql.append(" AND B.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND B.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND B.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND B.STATE = :state");
		}
		param.put("customerId", customerId);
		param.put("cate", cate);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		return baseDao.queryForInteger(selectSql.toString(),param);
	}
	/**
	 * 获取设备分类树
	 */
	@Override
	public List<Map> getCiCategoryTree(String pid) {
		String sql = " SELECT ID as id,PID as pid,NAME as name,LV as jb FROM CMDB_CI_CATEGORY WHERE STATE=1 AND CATE_TYPE=1 ";
		SqlParameter param = new SqlParameter();
		if(StringUtil.isNotBlank(pid)){
			sql += " AND PID=:pid ";
			param.addValue("pid", pid);
		}else{
			sql += " AND LV=1 ";
		}
		sql += " ORDER BY STATE,SERIAL ";
		List<Map> list = baseDao.queryForList(sql,param);
		for(Map map:list){
			String lv = ConvertUtil.obj2StrBlank(map.get("jb"));
			if(lv.equals("3")) {
				map.put("isParent", false);
			} else {
				map.put("isParent", true);
			}
		}
		return list;
	}
	/**
	 * 修改客户的指标项
	 */
	@Override
	public boolean updateCustomerItem(Map<String, String> param,CI_DAILY_PATROL_ITEM item) {
		String[] cateIds = param.get("full_cate_id").split("-");
		String[] cateNames = param.get("full_cate_name").split("-");
		if (cateIds.length == 3) {
			param.put("business_id", cateIds[2]);
			param.put("business_name", cateNames[2]);
			param.put("p_id", cateIds[1]);
		} else {
			param.put("business_id", cateIds[1]);
			param.put("business_name", cateNames[1]);
			param.put("p_id", cateIds[0]);
		}
		String thirdCateId = param.get("business_id");
		String thirdCateName = param.get("business_name");
		String p_id = param.get("p_id");
		item.setBusiness_id(thirdCateId).setBusiness_name(thirdCateName)
		.setP_id(p_id).update();
		return true;
	}
	/**
	 * 保存客户的指标性
	 */
	@Override
	public boolean saveCustomerItem(Map<String, String> param,CI_DAILY_PATROL_ITEM item) {
		String id = StringUtil.getUUID();
		String customerId=param.get("customerId");
		String[] cateIds = param.get("full_cate_id").split("-");
		String[] cateNames = param.get("full_cate_name").split("-");
		if (cateIds.length == 3) {
			param.put("business_id", cateIds[2]);
			param.put("business_name", cateNames[2]);
			param.put("p_id", cateIds[1]);
		} else {
			param.put("business_id", cateIds[1]);
			param.put("business_name", cateNames[1]);
			param.put("p_id", cateIds[0]);
		}
		String thirdCateId = param.get("business_id");
		String thirdCateName = param.get("business_name");
		String p_id = param.get("p_id");
		
		item.setId(id).setState(1).setItem_type(2).setBusiness_id(thirdCateId).setBusiness_name(thirdCateName)
		.setP_id(p_id).setCustomer_id(customerId).insert();
		
		String insertSql = "INSERT INTO CI_DAILY_PATROL_CUSTOMER_ITEM(ID,CUSTOMER_ID,ITEM_ID,USING_STATE) VALUES (:id,:customerId,:itemId,1)";
		param.put("id", StringUtil.getUUID());
		param.put("itemId", id);
		param.put("customerId", customerId);
		baseDao.execute(insertSql, param);
		return true;
	}
	/**
	 * 启用或者禁用指标项
	 * @param request
	 * @return
	 */
	@Override
	public boolean updateUseState(Map<String, String> param) {
		String id = param.get("id");
		String type = param.get("type");
		String updateSql = "UPDATE CI_DAILY_PATROL_CUSTOMER_ITEM SET USING_STATE = :type WHERE ID = :id";
		param.put("id", id);
		param.put("type", type);
		baseDao.execute(updateSql, param);
		return true;
	}
	
	/**
	 * 查询项目可以增加的指标项
	 */
	@Override
	public PageInfo queryCustomerItems(PageInfo pageInfo,Map<String, String> param) {
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql =new StringBuilder("SELECT * FROM CI_DAILY_PATROL_ITEM A WHERE  A.STATE = 1 AND A.ITEM_TYPE = 1  AND NOT EXISTS (SELECT ITEM_ID FROM CI_DAILY_PATROL_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.CUSTOMER_ID = :customerId )");
		if(StringUtil.notEmpty(cate)){
			String cates[]=cate.split("-");
			param.put("cate", cates[cates.length-1]);
			selectSql.append(" AND A.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND A.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND A.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND A.STATE = :state");
		}
		selectSql.append(" ORDER BY A.ORDER_NUM");
		param.put("itemName", "%"+itemName+"%");
		return baseDao.queryforSplitPageInfo(pageInfo, selectSql.toString(), param);
	}
	/**
	 * 查询项目可以增加的指标项总数量
	 */
	@Override
	public Integer queryCustomerItemscount(Map<String, String> param){
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql =new StringBuilder("SELECT count(*) FROM CI_DAILY_PATROL_ITEM A WHERE  A.STATE = 1 AND A.ITEM_TYPE = 1  AND NOT EXISTS (SELECT ITEM_ID FROM CI_DAILY_PATROL_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.CUSTOMER_ID = :customerId )");
		if(StringUtil.notEmpty(cate)){
			String cates[]=cate.split("-");
			param.put("cate", cates[cates.length-1]);
			selectSql.append(" AND A.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND A.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND A.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND A.STATE = :state");
		}
		selectSql.append(" ORDER BY A.ORDER_NUM");
		param.put("itemName", "%"+itemName+"%");
		return baseDao.queryForInteger(selectSql.toString(),param);
	}
	
	/**
	 * 保存选择的指标项
	 */
	@Override
	public String saveSelItems(Map<String, String> param) {
		String customerId = param.get("customerId");
		String item = param.get("item");
		if(StringUtil.notEmpty(customerId) && StringUtil.notEmpty(item)) {
			String[] items = item.split(",");
			String insertSql = "INSERT INTO CI_DAILY_PATROL_CUSTOMER_ITEM(ID,CUSTOMER_ID,ITEM_ID,USING_STATE) VALUES (:id,:customerId,:itemId,1)";
			List<SqlParameter> paramList = new ArrayList<SqlParameter>();
			for(String str : items) {
				if(StringUtil.notEmpty(str)) {
					SqlParameter sqlParameter = new SqlParameter();
					sqlParameter.put("id", StringUtil.getUUID());
					sqlParameter.put("customerId", customerId);
					sqlParameter.put("itemId", str);
					paramList.add(sqlParameter);
				}
			}
			baseDao.executeBatch(insertSql, paramList);
			return "1";
		}
		return "2";
	}
	/**
	 * 日常巡检设备数据
	 *
	 */
	@Override
	public PageInfo queryDailyDevices(PageInfo pageInfo,String customerId,String subCustomerId,String categoryId,String ciName) {
		StringBuilder builder = new StringBuilder("SELECT B.ID CI_ID,B.LV3_ID,B.LV3_NAME,A.ID,B.SEARCHCODE,B.CINAME,B.POSITION,B.SUB_CUS_NAME " +
				"FROM CI_DAILY_PATROL_CI A,CMDB_CI_BASE B WHERE A.CI_ID = B.ID AND B.STATE = 1 AND A.CUSTOMER_ID = :customerId");
		Map paramMap = new HashMap();
		paramMap.put("customerId", customerId);
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND A.SUB_CUSTOMER_ID = :subCustomerId ");
			paramMap.put("subCustomerId", subCustomerId);
		}
		
		if(StringUtil.notEmpty(categoryId)) {
			builder.append(" AND B.LV3_ID = :categoryId ");
			paramMap.put("categoryId", categoryId);
		}
		
		if(StringUtil.notEmpty(ciName)) {
			builder.append(" AND B.CINAME LIKE :ciName ");
			paramMap.put("ciName", "%"+ciName+"%");
		}
		
		builder.append("  ORDER BY B.CREATE_TIME DESC ");
		
		PageInfo info = baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), paramMap);
		return info;
	}
	
	/**
	 * 日常巡检设备数量
	 */
	@Override
	public int queryDailyDeviceCount(String customerId,String subCustomerId,String categoryId,String ciName) {
		StringBuilder builder = new StringBuilder("SELECT COUNT(A.ID) FROM CI_DAILY_PATROL_CI A,CMDB_CI_BASE B WHERE A.CI_ID = B.ID AND B.STATE = 1 AND A.CUSTOMER_ID = :customerId");
		
		Map paramMap = new HashMap();
		paramMap.put("customerId", customerId);
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND A.SUB_CUSTOMER_ID = :subCustomerId ");
			paramMap.put("subCustomerId", subCustomerId);
		}
		if(StringUtil.notEmpty(categoryId)) {
			builder.append(" AND B.LV3_ID = :categoryId ");
			paramMap.put("categoryId", categoryId);
		}
		
		if(StringUtil.notEmpty(ciName)) {
			builder.append(" AND B.CINAME LIKE :ciName ");
			paramMap.put("ciName", "%"+ciName+"%");
		}
		
		int count = baseDao.queryForInteger(builder.toString(),paramMap);
		return count;
	}
	
	@Override
	public List queryAddDailyDevice(String customerId,String subCustomerId,String ciName,String cateId,String sub_customer_id) {
		StringBuilder builder = new StringBuilder("SELECT A.ID,A.SEARCHCODE,A.CINAME,A.LV3_NAME,A.POSITION,A.CUS_ID,A.SUB_CUS_ID,A.SUB_CUS_NAME " +
				"FROM CMDB_CI_BASE A LEFT JOIN CMDB_CI_FLOW B ON A.ID = B.CFG_ID WHERE A.STATE = 1 AND A.CUS_ID = :customerId ");
		Map paramMap = new HashMap();
		paramMap.put("customerId", customerId);
		paramMap.put("cateId", cateId);
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND A.SUB_CUS_ID = :subCustomerId ");
			paramMap.put("subCustomerId", subCustomerId);
		}else if(StringUtil.notEmpty(sub_customer_id)){
			builder.append(" AND A.SUB_CUS_ID = :subCustomerId ");
			paramMap.put("subCustomerId", sub_customer_id);
		}
		if(StringUtil.notEmpty(ciName)) {
			builder.append(" AND A.CINAME LIKE :ciName ");
			paramMap.put("ciName", "%"+ciName+"%");
		}
		if(StringUtil.notEmpty(cateId)) {
			builder.append(" AND A.LV3_ID = :cateId ");
			paramMap.put("cateId", cateId);
		}
		
		builder.append(" AND NOT EXISTS (SELECT B.ID FROM CI_DAILY_PATROL_CI B WHERE A.ID = B.CI_ID AND B.CUSTOMER_ID = :customerId ) ORDER BY A.CREATE_TIME DESC ");
		List devices = baseDao.queryForList(builder.toString(),paramMap);
		return devices;
	}
	
	@Override
	public Integer queryAddDailyDeviceCount(String customerId,
			String subCustomerId, String ciName, String cateId,
			String sub_customer_id) {
		StringBuilder builder = new StringBuilder("SELECT COUNT(A.ID)" +
				"FROM CMDB_CI_BASE A LEFT JOIN CMDB_CI_FLOW B ON A.ID = B.CFG_ID WHERE A.STATE = 1 AND A.CUS_ID = :customerId ");
		Map paramMap = new HashMap();
		paramMap.put("customerId", customerId);
		paramMap.put("cateId", cateId);
		if(StringUtil.notEmpty(subCustomerId)) {
			builder.append(" AND A.SUB_CUS_ID = :subCustomerId ");
			paramMap.put("subCustomerId", subCustomerId);
		}else if(StringUtil.notEmpty(sub_customer_id)){
			builder.append(" AND A.SUB_CUS_ID = :subCustomerId ");
			paramMap.put("subCustomerId", sub_customer_id);
		}
		if(StringUtil.notEmpty(ciName)) {
			builder.append(" AND A.CINAME LIKE :ciName ");
			paramMap.put("ciName", "%"+ciName+"%");
		}
		if(StringUtil.notEmpty(cateId)) {
			builder.append(" AND A.LV3_ID = :cateId ");
			paramMap.put("cateId", cateId);
		}
		
		builder.append(" AND NOT EXISTS (SELECT B.ID FROM CI_DAILY_PATROL_CI B WHERE A.ID = B.CI_ID AND B.CUSTOMER_ID = :customerId ) ORDER BY A.CREATE_TIME DESC ");
		Integer i = baseDao.queryForInteger(builder.toString(),paramMap);
		return i;
	}	
	/**
	 * 添加项目需巡检设备
	 * @param request
	 * @return
	 */
	@Override
	public boolean saveDailyDevice(Map<String, String> param) {
		String ciAryStr = param.get("ciAryStr");
		if(StringUtil.isNotBlank(ciAryStr)){
			List<Map> list = JsonUtil.json2List(ciAryStr);
			if(list!=null&&list.size()>0){
				String insertSql = "INSERT INTO CI_DAILY_PATROL_CI(ID,CUSTOMER_ID,CI_ID,SUB_CUSTOMER_ID) VALUES (:id,:customerId,:ciId,:subCustomerId)";
				List<SqlParameter> plist = new ArrayList<SqlParameter>();
				for(Map ci:list){
					SqlParameter p = new SqlParameter();
					p.put("id", StringUtil.getUUID());
					p.put("ciId", ci.get("id"));
					p.put("customerId", ci.get("cus_id"));
					p.put("subCustomerId", ci.get("sub_cus_id"));
					plist.add(p);
				}
				baseDao.executeBatch(insertSql,plist);
				return true;
			}
		}
		return false;
	}
	/**
	 *  删除项目需巡检设备
	 */
	@Override
	public boolean deleteDailyDevice(String id) {
		String deleteSql = "DELETE FROM CI_DAILY_PATROL_CI WHERE ID = :id ";
		baseDao.execute(deleteSql, new SqlParameter("id",id));
		return true;
	}
	
	
    /**
     * 查询健康检查指标项配置
     * @param request
     * @return
     */
	@Override
	public PageInfo queryHealthItem(PageInfo pageInfo,Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql=new StringBuilder("SELECT B.*, A.USING_STATE,A.ID AS HEALTH_ITEM_ID " +
				"FROM CI_HEALTH_CUSTOMER_ITEM A,CI_HEALTH_ITEM B WHERE A.ITEM_ID = B.ID AND A.CUSTOMER_ID=:customerId ");
		if(StringUtil.notEmpty(cate)){
			selectSql.append(" AND B.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND B.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND B.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND B.STATE = :state");
		}
		selectSql.append(" ORDER BY A.USING_STATE,B.ITEM_TYPE ASC");
		param.put("customerId", customerId);
		param.put("cate", cate);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		return baseDao.queryforSplitPageInfo(pageInfo, selectSql.toString(), param);
	}
	/**
	 * 查询健康检查指标项配置总数
	 * @param request
	 * @return
	 */
	@Override
	public Integer queryHealthItemCount(Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql=new StringBuilder("SELECT count(*) FROM CI_HEALTH_CUSTOMER_ITEM A,CI_HEALTH_ITEM B WHERE A.ITEM_ID = B.ID AND A.CUSTOMER_ID=:customerId ");
		if(StringUtil.notEmpty(cate)){
			selectSql.append(" AND B.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND B.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND B.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND B.STATE = :state");
		}
		param.put("customerId", customerId);
		param.put("cate", cate);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		return baseDao.queryForInteger(selectSql.toString(), param);
	}
	/**
	 * 查询能选择的健康检查项
	 * @param request
	 * @return
	 */
	@Override
	public PageInfo queryCustomerHealthItems(PageInfo pageInfo,Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql = new StringBuilder("SELECT * FROM CI_HEALTH_ITEM A WHERE  A.STATE = 1 AND A.BUSINESS_ID IS NOT NULL AND A.ITEM_TYPE = 1  AND NOT EXISTS (SELECT ITEM_ID FROM CI_HEALTH_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.CUSTOMER_ID = :customerId ) ");
		if(StringUtil.notEmpty(cate)){
			String cates[]=cate.split("-");
			param.put("cate", cates[cates.length-1]);
			selectSql.append(" AND A.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND A.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND A.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND A.STATE = :state");
		}
		selectSql.append(" ORDER BY A.BUSINESS_ID , A.ORDER_NUM ASC");
		param.put("customerId", customerId);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		return baseDao.queryforSplitPageInfo(pageInfo, selectSql.toString(), param);
	}
	/**
	 * 查询能选择的健康检查项总数
	 * @param request
	 * @return
	 */
	@Override
	public Integer queryCustomerHealthItemsCount(Map<String, String> param) {
		String customerId = param.get("customerId");
		String cate = param.get("cate");
		String itemName=param.get("itemName");
		String itemType=param.get("itemType");
		String state=param.get("state");
		StringBuilder selectSql = new StringBuilder("SELECT count(*) FROM CI_HEALTH_ITEM A WHERE A.STATE = 1 AND A.ITEM_TYPE = 1  AND NOT EXISTS (SELECT ITEM_ID FROM CI_HEALTH_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.CUSTOMER_ID = :customerId ) ");
		if(StringUtil.notEmpty(cate)){
			String cates[]=cate.split("-");
			param.put("cate", cates[cates.length-1]);
			selectSql.append(" AND A.BUSINESS_ID = :cate");
		}
		if(StringUtil.notEmpty(itemName)){
			selectSql.append(" AND A.ITEM_NAME LIKE :itemName");
		}
		if(StringUtil.notEmpty(itemType)){
			selectSql.append(" AND A.ITEM_TYPE = :itemType");
		}
		if(StringUtil.notEmpty(state)){
			selectSql.append(" AND A.STATE = :state");
		}
		param.put("customerId", customerId);
		param.put("itemName", "%"+itemName+"%");
		param.put("itemType", itemType);
		param.put("state", state);
		return baseDao.queryForInteger(selectSql.toString(), param);
	}
	/**
	 * 保存选择的健康检查项
	 * @param request
	 * @return
	 */
	@Override
	public String saveHealthItems(Map<String, String> param) {
		String customerId = param.get("customerId");
		String item = param.get("item");
		if(StringUtil.notEmpty(customerId) && StringUtil.notEmpty(item)) {
			String[] items = item.split(",");
			String insertSql = "INSERT INTO CI_HEALTH_CUSTOMER_ITEM(ID,CUSTOMER_ID,ITEM_ID,USING_STATE) VALUES (:id,:customerId,:itemId,1)";
			List<SqlParameter> paramList = new ArrayList<SqlParameter>();
			for(String str : items) {
				if(StringUtil.notEmpty(str)) {
					SqlParameter sqlParameter = new SqlParameter();
					sqlParameter.put("id", StringUtil.getUUID());
					sqlParameter.put("customerId", customerId);
					sqlParameter.put("itemId", str);
					paramList.add(sqlParameter);
				}
			}
			baseDao.executeBatch(insertSql, paramList);
			return "1";
		}
		return "2";
	}
	/**
	 * 执行添加健康检查指标项
	 * @param request
	 * @return
	 */
	@Override
	public boolean saveCustomerHealthItem(Map<String, String> param) {
		String customerId = param.get("customerId");
		String item_name = param.get("item_name");
		String priority_level_id = param.get("priority_level_id");
		String priority_level_name = param.get("priority_level_name");
		String item_note = param.get("item_note");
		String steps=param.get("steps");
		String expect_value=param.get("expect_value");
		String order_num = param.get("order_num");
		
		String[] cateIds = param.get("full_cate_id").split("-");
		String[] cateNames = param.get("full_cate_name").split("-");
		if (cateIds.length == 3) {
			param.put("business_id", cateIds[2]);
			param.put("business_name", cateNames[2]);
			param.put("p_id", cateIds[1]);
		} else {
			param.put("business_id", cateIds[1]);
			param.put("business_name", cateNames[1]);
			param.put("p_id", cateIds[0]);
		}
		
		String id = StringUtil.getUUID();
		
		String insertSql = "INSERT INTO CI_HEALTH_ITEM(ID,ITEM_NAME,PRIORITY_LEVEL_ID,PRIORITY_LEVEL_NAME,ITEM_NOTE,ORDER_NUM,STATE,BUSINESS_ID,BUSINESS_NAME,ITEM_TYPE,CUSTOMER_ID,STEPS,EXPECT_VALUE,P_ID,FULL_CATE_ID,FULL_CATE_NAME) VALUES " +
				"(:id,:item_name,:priority_level_id,:priority_level_name,:item_note,:order_num,1,:business_id,:business_name,2,:customerId,:steps,:expect_value,:pId,:full_cate_id,:full_cate_name)";
		param.put("id", id);
		param.put("item_name", item_name);
		param.put("priority_level_id", priority_level_id);
		param.put("priority_level_name", priority_level_name);
		param.put("item_note", item_note);
		param.put("order_num", order_num);
		param.put("business_id",  param.get("business_id"));
		param.put("business_name",  param.get("business_name"));
		param.put("customerId", customerId);
		param.put("steps", steps);
		param.put("expect_value", expect_value);
		param.put("pId", param.get("p_id"));
		
		baseDao.execute(insertSql, param);
		
		String saveProjectItemSql = "INSERT INTO CI_HEALTH_CUSTOMER_ITEM(ID,CUSTOMER_ID,ITEM_ID,USING_STATE) VALUES (:id,:customerId,:item_id,1)";
		Map params = new HashMap();
		String projectItemId = StringUtil.getUUID();
		params.put("id", projectItemId);
		params.put("customerId", customerId);
		params.put("item_id", id);
		baseDao.execute(saveProjectItemSql, params);
		return true;
	}
	/**
	 * 查询健康检查项详细信息
	 * @param id
	 * @return
	 */
	@Override
	public Map queryHealthItemDetail(String id) {
		String selectSql = "SELECT A.ID,A.ITEM_NAME,A.PRIORITY_LEVEL_ID,A.STEPS,A.EXPECT_VALUE,A.PRIORITY_LEVEL_NAME,A.ITEM_NOTE,A.ORDER_NUM,A.STATE,A.BUSINESS_ID,A.BUSINESS_NAME,A.ITEM_TYPE,B.ID AS CUSTOMER_ITEM_ID,B.CUSTOMER_ID FROM CI_HEALTH_ITEM A,CI_HEALTH_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND A.ID = :id ";
		Map item = baseDao.queryForMap(selectSql,new SqlParameter("id",id));
		return item;
	}
	/**
	 * 启用或者禁用健康检查指标项
	 * @param request
	 * @return
	 */
	@Override
	public boolean updateHealthUseState(Map<String, String> param) {
		String id = param.get("id");
		String type = param.get("type");
		String updateSql = "UPDATE CI_HEALTH_CUSTOMER_ITEM SET USING_STATE = :type WHERE ID = :id";
		param.put("id", id);
		param.put("type", type);
		baseDao.execute(updateSql, param);
		return true;
	}
	
	/**
	 * 查询通用巡检项分类
	 */
	@Override
	public List queryCommonItemCate(String customerId,String name,String state) {
		String selectSql = "SELECT * FROM CI_DAILY_PATROL_CUSTOMER_COMMONS_CATEGORY WHERE CUSTOMER_ID = :customerId ";
		Map paramMap = new HashMap();
		paramMap.put("customerId", customerId);
		paramMap.put("state", state);
		if(StringUtil.notEmpty(name)) {
			selectSql += " AND CATEGORY_NAME LIKE :name ";
			paramMap.put("name", "%"+name+"%");
		}
		selectSql += " ORDER BY USING_STATE,ORDERNUM ";
		List<Map> commons = baseDao.queryForList(selectSql,paramMap);
		if(commons!=null && commons.size()>0){
			for(Map map :commons){
				String sql="SELECT * FROM CI_DAILY_PATROL_CUSTOMER_COMMONS_ITEM WHERE CATEGORY_ID=:id  ";
				if(StringUtil.isNotBlank(state)){
					sql = sql + " AND USING_STATE = :state ";
				}
				sql = sql + " ORDER BY  USING_STATE,ORDERNUM ASC ";
				List<Map> itemList=baseDao.queryForList(sql,new SqlParameter().addValue("id", map.get("ID"))
																			.addValue("state", state));
				map.put("itemList", itemList);
			}
		}
		return commons;
	}
	/**
	 * 添加通用巡检项分类
	 * @param request
	 * @return
	 */
	@Override
	public boolean saveCommonCate(Map<String, String> param) {
		String category_name = param.get("category_name");
		String ordernum = param.get("ordernum");
		String id = StringUtil.getUUID();
		String customerId = param.get("customerId");
		param.put("id", id);
		param.put("category_name", category_name);
		param.put("ordernum", ordernum);
		param.put("customerId", customerId);
		String insertSql = "INSERT INTO CI_DAILY_PATROL_CUSTOMER_COMMONS_CATEGORY(ID,CATEGORY_NAME,ORDERNUM,USING_STATE,CUSTOMER_ID) VALUES (:id,:category_name,:ordernum,1,:customerId)";
		baseDao.execute(insertSql, param);
		return true;
	}
	/**
	 * 修改通用巡检项分类
	 * @param request
	 * @return
	 */
	@Override
	public boolean updateCommonCate(Map<String, String> param) {
		String category_name = param.get("category_name");
		String ordernum = param.get("ordernum");
		String id = param.get("id");
		String updateSql = "UPDATE CI_DAILY_PATROL_CUSTOMER_COMMONS_CATEGORY SET CATEGORY_NAME = :category_name,ORDERNUM = :ordernum WHERE ID = :id ";
		param.put("id", id);
		param.put("category_name", category_name);
		param.put("ordernum", ordernum);
		baseDao.execute(updateSql, param);
		return true;
	}
	/**
	 * 新增巡检项
	 * @param request
	 * @return
	 */
	@Override
	public boolean saveItem(Map<String, String> param) {
		String item_name = param.get("item_name");
		String ordernum = param.get("ordernum");
		String note = param.get("note");
		String category_id = param.get("category_id");
		String id = StringUtil.getUUID();
		param.put("id", id);
		param.put("item_name", item_name);
		param.put("ordernum", ordernum);
		param.put("note", note);
		param.put("category_id", category_id);
		String insertSql = "INSERT INTO CI_DAILY_PATROL_CUSTOMER_COMMONS_ITEM(ID,ITEM_NAME,CATEGORY_ID,ORDERNUM,USING_STATE,NOTE) VALUES (:id,:item_name,:category_id,:ordernum,1,:note)";
		baseDao.execute(insertSql, param);
		return true;
	}
	/**
	 * 修改巡检项
	 * @param request
	 * @return
	 */
	@Override
	public boolean updateItem(Map<String, String> param) {
		String item_name = param.get("item_name");
		String ordernum = param.get("ordernum");
		String note = param.get("note");
		String id = param.get("id");
		String updateSql = "UPDATE CI_DAILY_PATROL_CUSTOMER_COMMONS_ITEM SET ITEM_NAME = :item_name,ORDERNUM = :ordernum,NOTE = :note WHERE ID = :id ";
		param.put("id", id);
		param.put("item_name", item_name);
		param.put("ordernum", ordernum);
		param.put("note", note);
		baseDao.execute(updateSql, param);
		return true;
	}
	
	/**
	 * 启用或者禁用通用巡检项分类
	 */
	@Override
	public boolean updateCommonItemState(Map<String, String> param) {
		String id = param.get("id");
		String type = param.get("type");
		String updateSql = "UPDATE CI_DAILY_PATROL_CUSTOMER_COMMONS_CATEGORY SET USING_STATE = :type WHERE ID = :id ";
		param.put("id", id);
		param.put("type", type);
		baseDao.execute(updateSql, param);
		return true;
	}
	
	/**
	 * 启用或者禁用通用巡检项
	 */
	@Override
	public boolean updateItemState(Map<String, String> param) {
		String id = param.get("id");
		String type = param.get("type");
		String updateSql = "UPDATE CI_DAILY_PATROL_CUSTOMER_COMMONS_ITEM SET USING_STATE = :type WHERE ID = :id ";
		param.put("id", id);
		param.put("type", type);
		baseDao.execute(updateSql, param);
		return true;
	}
	
	/**
	 * 获取设备分类树
	 */
	@Override
	public List<Map> getCiCategoryTree(String pid,String type) {
		String sql = " SELECT ID as id,PID as pid,NAME as name,LV as jb FROM CMDB_CI_CATEGORY WHERE STATE=1 ";
		SqlParameter param = new SqlParameter();
		if(StringUtil.notEmpty(type)){
			sql+=" and cate_type=:type";
			param.addValue("type", type);
		}else{
			sql+=" and cate_type=1";
		}
		if(StringUtil.isNotBlank(pid)){
			sql += " AND PID=:pid ";
			param.addValue("pid", pid);
		}else{
			sql += " AND LV=1 ";
		}
		if(StringUtil.isBlank(pid) && type.equals("2")){
			sql="";
			sql="select DISTINCT LV1_ID as id,\"0\" as pid ,LV1_name as name,\"1\" as lv from CMDB_CI_CATEGORY where STATE=1  and lv=3 and CATE_TYPE=2 ";
		}else if(StringUtil.isNotBlank(pid) && type.equals("2")){
			CMDB_CI_CATEGORY cmdb_ci_category=new CMDB_CI_CATEGORY(pid).getInstanceById();
			Integer lv=cmdb_ci_category.getLv();
			if(lv==1){
				sql="";
				sql="select DISTINCT LV2_ID as id,LV1_ID as pid ,LV2_name as name,\"2\" as lv from CMDB_CI_CATEGORY where STATE=1  and lv=3 and CATE_TYPE=2  and LV1_ID=:pid ";
				param.addValue("pid", pid);
			}
			
		}
		sql += " ORDER BY STATE,SERIAL ";
		List<Map> list = baseDao.queryForList(sql,param);
		for(Map map:list){
			String lv = ConvertUtil.obj2StrBlank(map.get("jb"));
			if(lv.equals("3")) {
				map.put("isParent", false);
			} else {
				map.put("isParent", true);
			}
		}
		return list;
	}


}