package cn.ksource.web.facade.servicelist;

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

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import cn.ksource.beans.SC_PARTNER_CUSTOMER_INFO;
import cn.ksource.beans.SC_SERVCE_CATEGORY;
import cn.ksource.beans.SC_SLA;
import cn.ksource.beans.SC_SLA_CONFIG;
import cn.ksource.beans.SC_WORKFLOW_CHANGE;
import cn.ksource.beans.SC_WORKFLOW_INCIDENT;
import cn.ksource.beans.SC_WORKFLOW_INCIDENT_TEMPLATE;
import cn.ksource.beans.SC_WORKFLOW_QUESTION;
import cn.ksource.core.dao.BaseDao;
import cn.ksource.core.dao.SqlParameter;
import cn.ksource.core.page.PageInfo;
import cn.ksource.core.util.AjaxUtil;
import cn.ksource.core.util.ConvertUtil;
import cn.ksource.core.util.FileUtil;
import cn.ksource.core.util.JsonUtil;
import cn.ksource.core.util.MyFileUploadException;
import cn.ksource.core.util.StringUtil;
import cn.ksource.core.web.WebUtil;
import cn.ksource.web.Constants;
import cn.ksource.web.service.DataDictionaryService;
import cn.ksource.web.service.sl.sla.SLALevel;

@Service("slaPartnerFacade")
@SuppressWarnings("unchecked")
public class SlaPartnerFacadeImpl implements SlaPartnerFacade {
	
	@Autowired
	private BaseDao baseDao;
	
	@Autowired
	private DataDictionaryService dataDictionaryService;

	@Override
	public List<Map> checkForTitle(String sjbh, String category_name) {
		String sql = "select * from SC_SERVCE_CATEGORY  WHERE  CATEGORY_NAME=:category_name ";
		if(StringUtil.isBlank(sjbh)||"0".equals(sjbh)){
			//sql = sql + " AND( P_ID is null OR P_ID = 0 OR P_ID = '' )";
			sql = sql + " AND P_ID is null ";
		}else{
			sql = sql + " AND P_ID=:sjbh ";
		}
		return baseDao.queryForList(sql,new SqlParameter("sjbh",sjbh).addValue("category_name", category_name));
	}

	@Override
	public boolean checkcode(HttpServletRequest request) {
		String id = request.getParameter("id");
		String categoryCode = request.getParameter("category_code");
		String pId = request.getParameter("pId");
		String selectSql = "SELECT COUNT(ID) FROM SC_SERVCE_CATEGORY WHERE CATEGORY_CODE = :categoryCode ";
		if(StringUtil.notEmpty(pId)) {
			selectSql += " AND P_ID = :pId ";
		} else {
			selectSql += " AND P_ID IS NULL ";
		}
		Map paramMap = new HashMap();
		paramMap.put("categoryCode", categoryCode);
		paramMap.put("pId", pId);
		if(StringUtil.notEmpty(id)) {
			selectSql += " AND ID != :id";
			paramMap.put("id", id);
		}
		int count = baseDao.queryForInteger(selectSql,paramMap);
		if(count > 0) {
			return false;
		}
		return true;
	}

	@Override
	public List<Map> partnerServiceCateTree(HttpServletRequest request) {
		Map paramMap = new HashMap();
		String selectSubSql = "SELECT * FROM SC_SERVCE_CATEGORY WHERE STATE = 1  ORDER BY LEVEL,SERIAL,CATEGORY_NAME ";
		List<Map> cates = baseDao.queryForList(selectSubSql,paramMap);
        Map result = new HashMap();
		
		List<Map> resultList = new LinkedList<Map>();
		
		Map<String, Map> yjgnCache = new HashMap<String, Map>();
		Map<String, Map> ejgnCache = new HashMap<String, Map>();
		Map<String, Map> sjgnCache = new HashMap<String, Map>();
		
		for (Map map : cates) {
			
			//一级树
			if (map.get("LEVEL").toString().equalsIgnoreCase("1")) {
				yjgnCache.put(map.get("ID").toString(), map);
				List<Map> ejgnList = new LinkedList<Map>();
				map.put("ejTree", ejgnList);
				resultList.add(map);
				continue;
			}
			//二级树
			if (map.get("LEVEL").toString().equalsIgnoreCase("2")) {
				String pId = map.get("P_ID").toString();
				if(yjgnCache.containsKey(pId)) {
					Map yjgnMap = yjgnCache.get(pId);
					List<Map> list = (List<Map>)yjgnMap.get("ejTree");
					map.put("sjTree", new LinkedList<Map>());
					list.add(map);
					
					ejgnCache.put(map.get("ID").toString(), map);
				}
				continue;
			}
			//三级树
			if (map.get("LEVEL").toString().equalsIgnoreCase("3")) {
				if(null!=map.get("P_ID")){
					String pId = map.get("P_ID").toString();
					if(ejgnCache.containsKey(pId)) {
						Map ejgnMap = ejgnCache.get(map.get("P_ID").toString());
						List<Map> list = (List<Map>)ejgnMap.get("sjTree");
						list.add(map);
					}
				}
			}
		}
		System.out.println(JsonUtil.list2Json(resultList));
		return resultList;
	}

	@Override
	public int partnerServiceCount(HttpServletRequest request) {
		String pId = request.getParameter("pId");
		StringBuilder builder = new StringBuilder("SELECT COUNT(ID) FROM SC_SERVCE_CATEGORY WHERE 1=1 ");
		Map paramMap = new HashMap();
		if(StringUtil.notEmpty(pId)) {
			builder.append(" AND P_ID = :pId ");
			paramMap.put("pId", pId);
		} else {
			builder.append(" AND P_ID IS NULL ");
		}
		
		return baseDao.queryForInteger(builder.toString(),paramMap);
	}

	@Override
	public PageInfo partnerServiceData(HttpServletRequest request,PageInfo pageInfo) {
		String pId = request.getParameter("pId");
		StringBuilder builder = new StringBuilder("SELECT * FROM SC_SERVCE_CATEGORY WHERE 1=1 ");
		Map paramMap = new HashMap();
		if(StringUtil.notEmpty(pId)) {
			builder.append(" AND P_ID = :pId ");
			paramMap.put("pId", pId);
		} else {
			builder.append(" AND P_ID IS NULL ");
		}
		
		
		builder.append(" ORDER BY SERIAL ");
		
		return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), paramMap);
	}

	@Override
	public Map queryForMapById(String id) {
		SC_SERVCE_CATEGORY service_category = new SC_SERVCE_CATEGORY();
		Map service_categoryMap = service_category.setId(id).getBeanMapById();
		return service_categoryMap;
	}

	@Override
	public Map save(HttpServletRequest request) {
		Map result = new HashMap();
		String firstCate = "";
		String secondCate = "";
		String id = request.getParameter("id");
		String categoryid = request.getParameter("categoryid");
		
		String category_name = request.getParameter("category_name");
		String category_code = request.getParameter("category_code");
		String serial = request.getParameter("serial");
		String note = request.getParameter("note"); 
		
		String photoPath = new String();
			String[] allowType =  new String[]{"gif","jpg","jpeg","png"};
			try {
				photoPath = FileUtil.uploadFile4SpringMVC(request, "photopathurl", "/upload", allowType);
			} catch (MyFileUploadException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
		SC_SERVCE_CATEGORY service_category = new SC_SERVCE_CATEGORY();
		if(StringUtil.notEmpty(categoryid)){
			SC_SERVCE_CATEGORY pCate = new SC_SERVCE_CATEGORY(categoryid).getInstanceById();
			int level = ConvertUtil.obj2Integer(pCate.getLevel());
			service_category.setP_id(categoryid);
			service_category.setLevel(level+1);
			
			if(level==2) {
				firstCate = pCate.getP_id();
				secondCate = pCate.getId();
			} else {
				firstCate = pCate.getId();
			}
			
		} else {
			service_category.setP_id(null);
			service_category.setLevel(1);
		}
			
			
		if(StringUtils.isBlank(id)){
			
			service_category.setCategory_name(category_name).setCategory_code(category_code)
			.setSerial(ConvertUtil.obj2Integer(serial))
			.setNote(note);
 			
			
 			service_category
			.setPhotopath(photoPath)
			.setState(1)
			.setType(2)
			.insert();
		}else{
			if(null == photoPath||"".equals(photoPath)){
				photoPath = request.getParameter("photopath");
				
			}
			new SC_SERVCE_CATEGORY(id)
			.setCategory_name(category_name)
			.setCategory_code(category_code)
			.setSerial(ConvertUtil.obj2Integer(serial))
			.setNote(note)
			.setPhotopath(photoPath).update();
			SC_SERVCE_CATEGORY sc=new SC_SERVCE_CATEGORY(id).getInstanceById();
			Map param=new HashMap();
			param.put("name", sc.getCategory_name());
			param.put("id", id);
			if("1".equals(ConvertUtil.obj2StrBlank(sc.getLevel()))){
				String sqla="update SC_WORKFLOW_INCIDENT_TEMPLATE set FIRST_CATEGORY_NAME=:name  where FIRST_CATEGORY_ID=:id";
				String sqlb="update SC_WORKFLOW_INCIDENT set FIRST_CATEGORY_NAME=:name  where FIRST_CATEGORY_ID=:id";
				String sqlc="update SC_WORKFLOW_QUESTION set FIRST_CATEGORY_NAME=:name  where FIRST_CATEGORY_ID=:id";
				baseDao.execute(sqla, param);
				baseDao.execute(sqlb, param);
				baseDao.execute(sqlc, param);
			}else if("2".equals(ConvertUtil.obj2StrBlank(sc.getLevel()))){
				String sqla="update SC_WORKFLOW_INCIDENT_TEMPLATE set SECOND_CATEGORY_NAME=:name  where SECOND_CATEGORY_ID=:id";
				String sqlb="update SC_WORKFLOW_INCIDENT set SECOND_CATEGORY_NAME=:name  where SECOND_CATEGORY_ID=:id";
				String sqlc="update SC_WORKFLOW_QUESTION set SECOND_CATEGORY_NAME=:name  where SECOND_CATEGORY_ID=:id";
				baseDao.execute(sqla, param);
				baseDao.execute(sqlb, param);
				baseDao.execute(sqlc, param);
			}else if("3".equals(ConvertUtil.obj2StrBlank(sc.getLevel()))){
				String sqla="update SC_WORKFLOW_INCIDENT_TEMPLATE set THIRD_CATEGORY_NAME=:name  where THIRD_CATEGORY_ID=:id";
				String sqlb="update SC_WORKFLOW_INCIDENT set THIRD_CATEGORY_NAME=:name  where THIRD_CATEGORY_ID=:id";
				String sqlc="update SC_WORKFLOW_QUESTION set THIRD_CATEGORY_NAME=:name  where THIRD_CATEGORY_ID=:id";
				baseDao.execute(sqla, param);
				baseDao.execute(sqlb, param);
				baseDao.execute(sqlc, param);
			}
		}
		
		
		
		result.put("firstCate", firstCate);
		result.put("secondCate", secondCate);
		return result;
	}

	@Override
	public Map updateFwmlState(HttpServletRequest request) {
		String result = "1";
		String id = request.getParameter("id");
		String state = request.getParameter("state");
		SC_SERVCE_CATEGORY category = new SC_SERVCE_CATEGORY(id).getInstanceById();
		String pId = category.getP_id();
		SC_SERVCE_CATEGORY pCate = null;
		if(state.equals("1")) {
			//执行启用操作，判断该分类的上级是否已经启用
			if(StringUtil.notEmpty(pId)) {
				pCate = new SC_SERVCE_CATEGORY(pId).getInstanceById();
				int pstate = pCate.getState();
				if(pstate == 2) {
					result = "2";
				}else{
					String updateSql = "UPDATE SC_SERVCE_CATEGORY SET STATE = :state WHERE ID = :id ";
					baseDao.execute(updateSql, new SqlParameter("state",state).addValue("id", id));
				}
			}else{
				String updateSql = "UPDATE SC_SERVCE_CATEGORY SET STATE = :state WHERE ID = :id ";
				baseDao.execute(updateSql, new SqlParameter("state",state).addValue("id", id));
			}
		}else{
			//执行禁用操作，判断该服务目录下是否有启用服务目录
			String selectSql = "SELECT COUNT(ID) FROM SC_SERVCE_CATEGORY WHERE P_ID = :id AND STATE = 1 ";
			int count = baseDao.queryForInteger(selectSql,new SqlParameter("id",id));
			if(count>0) {
				result = "2";
			}else{
				String updateSql = "UPDATE SC_SERVCE_CATEGORY SET STATE = :state WHERE ID = :id ";
				baseDao.execute(updateSql, new SqlParameter("state",state).addValue("id", id));
			}
		}
		String firstCate = new String();
		String secondCate = new String();
		
		if(StringUtil.notEmpty(pId)) {
			if(null == pCate) {
				pCate = new SC_SERVCE_CATEGORY(pId).getInstanceById();
			}
			int level = pCate.getLevel();
			if(level==2) {
				firstCate = pCate.getP_id();
				secondCate = pCate.getId();
			} else {
				firstCate = pCate.getId();
			}
		}
		
		Map resultMap = new HashMap();
		resultMap.put("firstCate", firstCate);
		resultMap.put("secondCate", secondCate);
		resultMap.put("result", result);
		
		return resultMap;
	}

	@Override
	public int slacategoryListCount(HttpServletRequest request) {
		String level_name = AjaxUtil.decode(request.getParameter("level_name"));
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT COUNT(ID) FROM SC_SLA A  WHERE A.STATE = 1 ");
		SqlParameter param = new SqlParameter();
		if (StringUtils.isNotBlank(level_name)) {
			sql.append(" AND A.LEVEL_NAME like :level_name ");
			param.addValue("level_name", "%"+level_name+"%");
		}
		return baseDao.queryForInteger(sql.toString(), param);
	}

	@Override
	public PageInfo slacategoryListData(HttpServletRequest request,PageInfo pageInfo) {
		String level_name = AjaxUtil.decode(request.getParameter("level_name"));
		StringBuilder sql = new StringBuilder();
		sql.append("SELECT A.*,B.RESPONSE_TIME,B.RESOLVE_TIME FROM SC_SLA A LEFT JOIN SC_SLA_CONFIG B ON A.ID = B.LEVEL_ID AND B.CUSTOMER_ID IS NULL AND B.CATEGORY_ID IS NULL WHERE A.STATE = 1 ");
		SqlParameter param = new SqlParameter();
		if (StringUtils.isNotBlank(level_name)) {
			sql.append(" AND A.LEVEL_NAME like :level_name ");
			param.addValue("level_name", "%"+level_name+"%");
		}
		sql.append(" ORDER BY A.SERIAL ");
		return baseDao.queryforSplitPageInfo(pageInfo,sql.toString(),param);
	}

	@Override
	public Map getCateSla(HttpServletRequest request) {
		String cateid = request.getParameter("id");
		String sql = "SELECT * FROM SC_SLA  WHERE ID = :id AND STATE = :state";
		Map param = new HashMap();
		param.put("id", cateid);
		param.put("state", 1);
		return baseDao.queryForMap(sql, param);
	}

	@Override
	public void saveSlacategory(HttpServletRequest request) {
		String id = request.getParameter("id");
		String level_name = request.getParameter("level_name");
		String serial = request.getParameter("serial");
		SC_SLA info = new SC_SLA();
		if(StringUtil.isEmpty(id)){
    		info.setState(1);
    	}else{
    		info.setId(id);
    	}
    	info.setLevel_name(level_name).setSerial(ConvertUtil.obj2Integer(serial)).setType(2).insertOrUpdate();
	}

	@Override
	public int checkLevel_name(String id, String level_name) {
		StringBuffer sql = new StringBuffer("SELECT COUNT(ID) FROM SC_SLA WHERE STATE = 1 ");
		if(StringUtil.isEmpty(id)){
			sql.append(" AND LEVEL_NAME = :level_name");
		}else{
			sql.append(" AND LEVEL_NAME = :level_name AND ID <> :id ");
		}
		SqlParameter param = new SqlParameter();
		param.addValue("level_name", level_name);
		param.addValue("id",id);
		int count = baseDao.queryForInteger(sql.toString(),param );
		return count;
	}

	@Override
	public List queryPnLevels(HttpServletRequest request) {
		String sql = "SELECT * FROM SC_SLA WHERE STATE = :state ORDER BY SERIAL";
		return baseDao.queryForList(sql,new SqlParameter("state",Constants.SC_SLA_TEMPLATE_STATE_OPEN));
	}

	@Override
	public Map querySlapnLink(HttpServletRequest request) {
		Map resultMap = new HashMap();
		//查询紧急程度数据字典
		List<Map> eventPri = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_PRI);
		if(null==eventPri || eventPri.size()==0) {
			return resultMap;
		}
		//查询事件影响度数据字典
		List<Map> eventDg = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_EFFECT_DG);
		if(null==eventDg || eventDg.size()==0) {
			return resultMap;
		}
		
		//查询所有的优先级设置
		String selectSql = "SELECT * FROM SC_SLA_LEVEL_CONFIG WHERE CUSTOMER_ID IS NULL ";
		List<Map> list = baseDao.queryForList(selectSql);
		Map cacheMap = new HashMap();
		
		
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String priId = ConvertUtil.obj2Str(map.get("PRIORITY_ID"));
				String effId = ConvertUtil.obj2Str(map.get("INFLUENCE_ID"));
				cacheMap.put(priId+"-"+effId, map);
			}
		}
		
		
		for(Map dg : eventDg) {
			List levels = new ArrayList();
			String effId = ConvertUtil.obj2Str(dg.get("DATAKEY"));
			for(Map pri : eventPri) {
				String priId = ConvertUtil.obj2Str(pri.get("DATAKEY"));
				String key = priId+"-"+effId;
				Map m = new HashMap();
				if(cacheMap.containsKey(key)) {
					m = (Map)cacheMap.get(key);
					m.put("unitkey", key);
				} else {
					m.put("unitkey", key);
				}
				levels.add(m);
			}
			dg.put("levels", levels);
		}
		
		
		resultMap.put("pri", eventPri);
		resultMap.put("dg", eventDg);
		return resultMap;
	}

	@Override
	public String saveLink(HttpServletRequest request) {
		String[] links = request.getParameterValues("level");
		
		Map<String,String> priMap = new HashMap<String,String>();
		//查询紧急程度数据字典
		List<Map> eventPri = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_PRI);
		for(Map m : eventPri) {
			String key = ConvertUtil.obj2StrBlank(m.get("DATAKEY"));
			String value = ConvertUtil.obj2StrBlank(m.get("DATAVALUE"));
			priMap.put(key, value);
		}
		
		Map<String,String> dgMap = new HashMap<String,String>();
		//查询事件影响度数据字典
		List<Map> eventDg = dataDictionaryService.getDataDictionaryByCategoryKey(Constants.EVENT_EFFECT_DG);
		for(Map m : eventDg) {
			String key = ConvertUtil.obj2StrBlank(m.get("DATAKEY"));
			String value = ConvertUtil.obj2StrBlank(m.get("DATAVALUE"));
			dgMap.put(key, value);
		}
		
		Map<String,String> levelMap = new HashMap<String,String>();
		//查询所有的优先级设置
		List<Map> levels = queryPnLevels(request);
		for(Map m : levels) {
			String key = ConvertUtil.obj2StrBlank(m.get("ID"));
			String value = ConvertUtil.obj2StrBlank(m.get("LEVEL_NAME"));
			levelMap.put(key, value);
		}
		
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		for(String s : links) {
			SqlParameter sqlParameter = new SqlParameter();
			String[] keys = s.split("-");
			String priId = keys[0];
			String dgId = keys[1];
			String levelId = keys[2];
			sqlParameter.put("id", StringUtil.getUUID());
			sqlParameter.put("influence_id", dgId);
			sqlParameter.put("influence_name", dgMap.get(dgId));
			sqlParameter.put("priority_id", priId);
			sqlParameter.put("priority_name", priMap.get(priId));
			sqlParameter.put("level_id", levelId);
			sqlParameter.put("level_name", levelMap.get(levelId));
			paramList.add(sqlParameter);
		}
		
		String deleteSql = "DELETE FROM SC_SLA_LEVEL_CONFIG WHERE CUSTOMER_ID IS NULL ";
		String insertSql = "INSERT INTO SC_SLA_LEVEL_CONFIG(ID,INFLUENCE_ID,INFLUENCE_NAME,PRIORITY_ID,PRIORITY_NAME,LEVEL_ID,LEVEL_NAME,TYPE) VALUES (:id,:influence_id,:influence_name,:priority_id,:priority_name,:level_id,:level_name,2)";
		baseDao.execute(deleteSql, new SqlParameter());
		baseDao.executeBatch(insertSql, paramList);
		return "1";
	}

	@Override
	public void saveSlaTab(HttpServletRequest request) {
		String levelid = request.getParameter("levelid");
		String id = request.getParameter("id");
		String isSelf = request.getParameter("isSelf");
		
		String levelName = ConvertUtil.obj2Str(new SC_SLA(levelid).getBeanMapById().get("LEVEL_NAME"));
		String cateId = request.getParameter("cateId");
		SC_SERVCE_CATEGORY cate = new SC_SERVCE_CATEGORY(cateId).getInstanceById();
		String cateName = ConvertUtil.obj2Str(cate.getCategory_name());
		String response_time = request.getParameter("response_time");
		String resolve_time = request.getParameter("resolve_time");
		
		
		String user1 = request.getParameter("user1");
		String userName1 = request.getParameter("userName1");
		
		SC_SLA_CONFIG config = new SC_SLA_CONFIG();
		config.setCategory_id(cateId).setCategory_name(cateName).setLevel_id(levelid).setLevel_name(levelName)
		.setResolve_time(ConvertUtil.obj2Integer(resolve_time))
		.setResponse_time(ConvertUtil.obj2Integer(response_time))
		.setDealer_type(2).setGroup_id("").setGroup_name("").setUser_id(user1).setUser_name(userName1);
		if("1".equals(isSelf)){
			config.setId(id).update();
		}else{
			config.setState(1).setType(2).insert();
		}
		
		String configId = config.getId();
		
		baseDao.execute("DELETE FROM SC_SLA_USER WHERE LEVEL_ID = :level_id", new SqlParameter("level_id",config.getId()));
		
		
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		for(int i=2; i<=7; i++) {
			
			String time = request.getParameter("time"+i);
				String user = request.getParameter("user"+i);
				String userName = request.getParameter("userName"+i);
				SqlParameter param = new SqlParameter();
				param.put("id", StringUtil.getUUID());
				param.put("level_id",configId );
				if(i>4) {
					param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_RESOLVE_OVERTIME);
				} else {
					param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME);
				}
				if(StringUtil.notEmpty(time)) {
					param.put("over_time", time);
				}else{
					param.put("over_time", null);
				}
				
				param.put("user_id", user);
				param.put("user_name", userName);
				param.put("type", "2");
				param.put("dealer_type", "2");
				param.put("group_id", "");
				param.put("group_name", "");
				paramList.add(param);
		}
		
		if(paramList.size()>0) {
			String sql = "INSERT INTO SC_SLA_USER(ID,LEVEL_ID,NOTICE_TYPE,OVER_TIME,USER_ID,USER_NAME,TYPE,DEALER_TYPE,GROUP_ID,GROUP_NAME) VALUES(:id,:level_id,:notice_type,:over_time,:user_id,:user_name,:type,:dealer_type,:group_id,:group_name)";
			baseDao.executeBatch(sql, paramList);
		}
		
		//二级等级协议修改，对应三级等级协议清空
		if(cate.getLevel() == 2){
			String catesql = "SELECT * FROM SC_SERVCE_CATEGORY WHERE P_ID = :p_id ";
			List<Map> cateList = baseDao.queryForList(catesql, new SqlParameter("p_id",cate.getId()));
			List<SqlParameter> paramsList = new ArrayList<SqlParameter>();
			for(Map map:cateList){
				SqlParameter param = new SqlParameter();
				param.put("category_id", map.get("ID"));
				param.put("level_id", levelid);
				paramsList.add(param);
			}
			String del = "DELETE FROM SC_SLA_USER WHERE LEVEL_ID = (SELECT ID FROM SC_SLA_CONFIG WHERE CATEGORY_ID = :category_id AND CUSTOMER_ID IS NULL AND LEVEL_ID = :level_id )";
			String delcfg = "DELETE FROM SC_SLA_CONFIG WHERE CATEGORY_ID = :category_id AND CUSTOMER_ID IS NULL AND LEVEL_ID = :level_id ";
			baseDao.executeBatch(del, paramsList);
			baseDao.executeBatch(delcfg, paramsList);
		}
		
	}

	@Override
	public Map getSlaList(HttpServletRequest request) {
		String cateid = request.getParameter("cateId");
		String levelid = request.getParameter("levelid");
		String sql = "SELECT * FROM SC_SLA_CONFIG  WHERE CATEGORY_ID = :category_id AND LEVEL_ID = :level_id AND STATE = :state";
		Map param = new HashMap();
		param.put("category_id", cateid);
		param.put("level_id", levelid);
		param.put("state", 1);
		Map slaMap = baseDao.queryForMap(sql, param);
		
		
		String userId = ConvertUtil.obj2StrBlank(slaMap.get("USER_ID"));
		List users = new ArrayList();
		if(StringUtil.notEmpty(userId)) {
			String[] ids = userId.split(",");
			String userName = ConvertUtil.obj2StrBlank(slaMap.get("USER_NAME"));
			String[] names = userName.split(",");
			for(int i=0; i<ids.length; i++) {
				Map map = new HashMap();
				map.put("userId", ids[i]);
				map.put("userName", names[i]);
				users.add(map);
			}
		}
		
		slaMap.put("users", users);
		
		String configId = ConvertUtil.obj2StrBlank(slaMap.get("ID"));
		String sqluser = "SELECT A.* FROM SC_SLA_USER A WHERE  A.LEVEL_ID = :level_id ORDER BY A.OVER_TIME";
		List<Map> list = baseDao.queryForList(sqluser, new SqlParameter("level_id",configId));
		
		List<Map> userList = new ArrayList<Map>();
		List<Map> userjjList = new ArrayList<Map>();
		if(null!=list && list.size()>0) {
			for(Map map : list) {
				String noticeType = ConvertUtil.obj2StrBlank(map.get("NOTICE_TYPE"));
				if(noticeType.equals(Constants.SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME)) {
					userList.add(map);
				} else {
					userjjList.add(map);
				}
			}
		}
		
		
		Map xy1 = new HashMap();
		Map xy2 = new HashMap();
		Map xy3 = new HashMap();
		if(null!=userList && userList.size()>0) {
			if(userList.size()==1) {
				xy1 = userList.get(0);
			} else if (userList.size()==2) {
				xy1 = userList.get(0);
				xy2 = userList.get(1);
			} else if (userList.size()==3) {
				xy1 = userList.get(0);
				xy2 = userList.get(1);
				xy3 = userList.get(2);
			}
		}
		if(xy1.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(xy1.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(xy1.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			xy1.put("users", us);
		}
		
		if(xy2.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(xy2.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(xy2.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			xy2.put("users", us);
		}
		
		
		if(xy3.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(xy3.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(xy3.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			xy3.put("users", us);
		}
		
		slaMap.put("xy1", xy1);
		slaMap.put("xy2", xy2);
		slaMap.put("xy3", xy3);
		
		
		Map jiej1 = new HashMap();
		Map jiej2 = new HashMap();
		Map jiej3 = new HashMap();
		if(null!=userjjList && userjjList.size()>0) {
			if(userjjList.size()==1) {
				jiej1 = userjjList.get(0);
			} else if (userjjList.size()==2) {
				jiej1 = userjjList.get(0);
				jiej2 = userjjList.get(1);
			} else if (userjjList.size()==3) {
				jiej1 = userjjList.get(0);
				jiej2 = userjjList.get(1);
				jiej3 = userjjList.get(2);
			}
		}
		
		if(jiej1.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(jiej1.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(jiej1.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			jiej1.put("users", us);
		}
		
		if(jiej2.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(jiej2.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(jiej2.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			jiej2.put("users", us);
		}
		
		
		if(jiej3.size()>0) {
			String uId = ConvertUtil.obj2StrBlank(jiej3.get("USER_ID"));
			List us = new ArrayList();
			if(StringUtil.notEmpty(uId)) {
				String[] ids = uId.split(",");
				String userName = ConvertUtil.obj2StrBlank(jiej3.get("USER_NAME"));
				String[] names = userName.split(",");
				for(int i=0; i<ids.length; i++) {
					Map map = new HashMap();
					map.put("userId", ids[i]);
					map.put("userName", names[i]);
					us.add(map);
				}
			}
			jiej3.put("users", us);
		}
		
		
		slaMap.put("jiej1", jiej1);
		slaMap.put("jiej2", jiej2);
		slaMap.put("jiej3", jiej3);
		
		return slaMap;
	}

	@Override
	public List<Map> getSlalevelList() {
		String sql = "SELECT * FROM SC_SLA WHERE STATE = :state ORDER BY SERIAL";
		return baseDao.queryForList(sql, new SqlParameter("state", 1));
	}

	@Override
	public boolean saveBatchSlaTab(HttpServletRequest request) {
		String levelid = request.getParameter("levelid");
		
		String levelName = ConvertUtil.obj2Str(new SC_SLA(levelid).getBeanMapById().get("LEVEL_NAME"));
		String response_time = request.getParameter("response_time");
		String resolve_time = request.getParameter("resolve_time");
		
		String cateIdStrs = new String();
		List<Map> cateIdsList = baseDao.queryForList("SELECT ID FROM SC_SERVCE_CATEGORY WHERE LEVEL = 3 ");
		for (int i = 0; i < cateIdsList.size()-1; i++) {
			cateIdStrs += cateIdsList.get(i).get("ID")+",";
		}
		cateIdStrs += cateIdsList.get(cateIdsList.size()-1).get("ID");  
		
		//查询出该服务目录该级别对应的所有服务级别协议设置
		String selectSql = "SELECT * FROM SC_SLA_CONFIG WHERE CATEGORY_ID = :categoryId AND LEVEL_ID = :levelId AND (CUSTOMER_ID IS NULL OR CUSTOMER_ID = '')";
		String user1 = request.getParameter("user1");
		String userName1 = request.getParameter("userName1");
		
		
		List<SqlParameter> paramListSaveConfig = new ArrayList<SqlParameter>();
		List<SqlParameter> paramListUpdateConfig = new ArrayList<SqlParameter>();
		
		
		List<SqlParameter> configs = new ArrayList<SqlParameter>();
		List<SqlParameter> configs2 = new ArrayList<SqlParameter>();
		
		
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		
		if(StringUtil.notEmpty(cateIdStrs)) {
			String[] cateIds = cateIdStrs.split(",");
			for(String cateId : cateIds) {

				
				String cateName = ConvertUtil.obj2Str(new SC_SERVCE_CATEGORY(cateId).getBeanMapById().get("CATEGORY_NAME"));
				SqlParameter sqlParameter = new SqlParameter();
				sqlParameter.put("cateId", cateId);
				sqlParameter.put("category_name", cateName);
				sqlParameter.put("level_id", levelid);
				sqlParameter.put("level_name", levelName);
				sqlParameter.put("resolveTime", resolve_time);
				sqlParameter.put("responseTime", response_time);
				sqlParameter.put("dealerType", 2);
				sqlParameter.put("groupId", "");
				sqlParameter.put("groupName", "");
				sqlParameter.put("userId", user1);
				sqlParameter.put("userName", userName1);
				
				
				Map result = baseDao.queryForMap(selectSql,new SqlParameter("categoryId",cateId).addValue("levelId", levelid));
				
				String configId = new String();
				
				if(result.size()>0) {
					String conId = ConvertUtil.obj2StrBlank(result.get("ID"));
					SqlParameter sqlParameter2 = new SqlParameter();
					sqlParameter2.put("configId", conId);
					configs.add(sqlParameter2);
					
					configId = conId;
					sqlParameter.put("id", configId);
					
					paramListUpdateConfig.add(sqlParameter);
				} else {
					configId = StringUtil.getUUID();
					sqlParameter.put("id", configId);
					paramListSaveConfig.add(sqlParameter);
				}
				
				for(int i=2; i<=7; i++) {
					
					String time = request.getParameter("time"+i);
					if(StringUtil.notEmpty(time)) {
						String user = request.getParameter("user"+i);
						String userName = request.getParameter("userName"+i);
						SqlParameter param = new SqlParameter();
						param.put("id", StringUtil.getUUID());
						param.put("level_id",configId);
						if(i>4) {
							param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_RESOLVE_OVERTIME);
						} else {
							param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME);
						}
						param.put("over_time", time);
						param.put("user_id", user);
						param.put("user_name", userName);
						param.put("type", "2");
						param.put("dealer_type", "2");
						param.put("group_id", "");
						param.put("group_name", "");
						paramList.add(param);
					}
				}
				
			}
		}
		
		if(configs.size()>0) {
			String deleteSql2 = "DELETE FROM SC_SLA_USER WHERE LEVEL_ID = :configId";
			baseDao.executeBatch(deleteSql2,configs);
		}
		
		
		if(paramListSaveConfig.size()>0) {
			String saveSql1 = "INSERT INTO SC_SLA_CONFIG(ID,CATEGORY_ID,CATEGORY_NAME,LEVEL_ID,LEVEL_NAME,RESPONSE_TIME,RESOLVE_TIME,STATE,TYPE,USER_ID,USER_NAME,GROUP_ID,GROUP_NAME,DEALER_TYPE) VALUES (" +
			":id,:cateId,:category_name,:level_id,:level_name,:responseTime,:resolveTime,1,2,:userId,:userName,:groupId,:groupName,2)";
			
			baseDao.executeBatch(saveSql1,paramListSaveConfig);
		}
		
		
		if(paramListUpdateConfig.size()>0) {
			String updateSql1 = "UPDATE SC_SLA_CONFIG SET CATEGORY_ID = :cateId,CATEGORY_NAME = :category_name,LEVEL_ID = :level_id,LEVEL_NAME = :level_name,RESPONSE_TIME = :responseTime,RESOLVE_TIME = :resolveTime," +
			"USER_ID = :userId,USER_NAME = :userName,GROUP_ID = :groupId,GROUP_NAME = :groupName,DEALER_TYPE = 2 WHERE ID = :id";
			baseDao.executeBatch(updateSql1,paramListUpdateConfig);
		}
		
		
		if(paramList.size()>0) {
			String sql = "INSERT INTO SC_SLA_USER(ID,LEVEL_ID,NOTICE_TYPE,OVER_TIME,USER_ID,USER_NAME,TYPE,DEALER_TYPE,GROUP_ID,GROUP_NAME) VALUES(:id,:level_id,:notice_type,:over_time,:user_id,:user_name,:type,:dealer_type,:group_id,:group_name)";
			baseDao.executeBatch(sql, paramList);
		}
		return true;
	}

	@Override
	public Map querySlaLevel(String customerId, String threeId,String secondId,int level, String levelId) {
		if(StringUtil.notEmpty(customerId)) {
			if(level == 3) {
				Map map = getSlaLevel(customerId,threeId,levelId);
				
				if(null!=map && map.size()>0) {
					map.put("isSelf", 1);
					return map;
				}
				
				map = querySlaLevel(customerId, threeId,secondId, 2, levelId);
				if(null!=map && map.size()>0) {
					map.put("isSelf", 2);
					return map;
				}
			}
			
			if(level == 2) {
				
				Map map = getSlaLevel(customerId,secondId,levelId);
					
				if(null!=map && map.size()>0) {
					map.put("isSelf", 1);
					return map;
				}
				
				if(StringUtil.notEmpty(threeId)) {
					map = querySlaLevel("",threeId,secondId,3,levelId);
					if(null!=map && map.size()>0) {
						map.put("isSelf", 2);
						return map;
					}
				}
				
				map = querySlaLevel("","",secondId,2,levelId);
				if(null!=map && map.size()>0) {
					map.put("isSelf", 2);
					return map;
				}
			}
		} 
		
		if(level == 3) {
			Map map = getSlaLevel(customerId,threeId,levelId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 1);
				return map;
			}
				
			map = querySlaLevel(customerId,"", secondId, 2, levelId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 2);
				return map;
			}
			
		}
		
		if(level == 2) {
			Map map = getSlaLevel(customerId,secondId,levelId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 1);
				return map;
			}	
			
			map = querySlaLevel("","","",0,levelId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 2);
				return map;
			}
		}
		
		if(level == 0) {
			Map map = getSlaLevel("", "",levelId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 1);
				return map;
			}	
		}
		
		return new HashMap();
	}
	
	
	private Map getSlaLevel(String customerId, String categoryId,String levelId) {
		Map paramMap = new HashMap();
		StringBuilder builder = new StringBuilder("SELECT COUNT(ID) FROM SC_SLA_CONFIG WHERE LEVEL_ID = :levelId AND STATE = 1 ");
		StringBuilder selectBuilder = new StringBuilder("SELECT * FROM SC_SLA_CONFIG WHERE LEVEL_ID = :levelId AND STATE = 1 ");
		paramMap.put("levelId", levelId);
		if(StringUtil.notEmpty(customerId)) {
			builder.append(" AND CUSTOMER_ID = :customerId ");
			selectBuilder.append(" AND CUSTOMER_ID = :customerId ");
			paramMap.put("customerId", customerId);
		} else {
			builder.append(" AND CUSTOMER_ID IS NULL ");
			selectBuilder.append(" AND CUSTOMER_ID IS NULL ");
		}
		
		if(StringUtil.notEmpty(categoryId)) {
			builder.append(" AND CATEGORY_ID = :categoryId ");
			selectBuilder.append(" AND CATEGORY_ID = :categoryId ");
			paramMap.put("categoryId", categoryId);
		} else {
			builder.append(" AND CATEGORY_ID IS NULL ");
			selectBuilder.append(" AND CATEGORY_ID IS NULL ");
		}
		
		int count = baseDao.queryForInteger(builder.toString(),paramMap);
		
		
		if(count>0) {
			Map slaMap = baseDao.queryForMap(selectBuilder.toString(),paramMap);
			if(null!=slaMap && slaMap.size()>0) {
				
				String userId = ConvertUtil.obj2StrBlank(slaMap.get("USER_ID"));
				List users = new ArrayList();
				if(StringUtil.notEmpty(userId)) {
					String[] ids = userId.split(",");
					String userName = ConvertUtil.obj2StrBlank(slaMap.get("USER_NAME"));
					String[] names = userName.split(",");
					for(int i=0; i<ids.length; i++) {
						Map map = new HashMap();
						map.put("userId", ids[i]);
						map.put("userName", names[i]);
						users.add(map);
					}
				}
				
				slaMap.put("users", users);
				
				String configId = ConvertUtil.obj2StrBlank(slaMap.get("ID"));
				String sqluser = "SELECT A.* FROM SC_SLA_USER A WHERE  A.LEVEL_ID = :level_id ORDER BY A.OVER_TIME";
				List<Map> list = baseDao.queryForList(sqluser, new SqlParameter("level_id",configId));
				
				List<Map> userList = new ArrayList<Map>();
				List<Map> userjjList = new ArrayList<Map>();
				if(null!=list && list.size()>0) {
					for(Map map : list) {
						String noticeType = ConvertUtil.obj2StrBlank(map.get("NOTICE_TYPE"));
						if(noticeType.equals(Constants.SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME)) {
							userList.add(map);
						} else {
							userjjList.add(map);
						}
					}
				}
				
				
				Map xy1 = new HashMap();
				Map xy2 = new HashMap();
				Map xy3 = new HashMap();
				if(null!=userList && userList.size()>0) {
					if(userList.size()==1) {
						xy1 = userList.get(0);
					} else if (userList.size()==2) {
						xy1 = userList.get(0);
						xy2 = userList.get(1);
					} else if (userList.size()==3) {
						xy1 = userList.get(0);
						xy2 = userList.get(1);
						xy3 = userList.get(2);
					}
				}
				if(xy1.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(xy1.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(xy1.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					xy1.put("users", us);
				}
				
				if(xy2.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(xy2.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(xy2.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					xy2.put("users", us);
				}
				
				
				if(xy3.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(xy3.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(xy3.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					xy3.put("users", us);
				}
				
				slaMap.put("xy1", xy1);
				slaMap.put("xy2", xy2);
				slaMap.put("xy3", xy3);
				
				
				Map jiej1 = new HashMap();
				Map jiej2 = new HashMap();
				Map jiej3 = new HashMap();
				if(null!=userjjList && userjjList.size()>0) {
					if(userjjList.size()==1) {
						jiej1 = userjjList.get(0);
					} else if (userjjList.size()==2) {
						jiej1 = userjjList.get(0);
						jiej2 = userjjList.get(1);
					} else if (userjjList.size()==3) {
						jiej1 = userjjList.get(0);
						jiej2 = userjjList.get(1);
						jiej3 = userjjList.get(2);
					}
				}
				
				if(jiej1.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(jiej1.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(jiej1.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					jiej1.put("users", us);
				}
				
				if(jiej2.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(jiej2.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(jiej2.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					jiej2.put("users", us);
				}
				
				
				if(jiej3.size()>0) {
					String uId = ConvertUtil.obj2StrBlank(jiej3.get("USER_ID"));
					List us = new ArrayList();
					if(StringUtil.notEmpty(uId)) {
						String[] ids = uId.split(",");
						String userName = ConvertUtil.obj2StrBlank(jiej3.get("USER_NAME"));
						String[] names = userName.split(",");
						for(int i=0; i<ids.length; i++) {
							Map map = new HashMap();
							map.put("userId", ids[i]);
							map.put("userName", names[i]);
							us.add(map);
						}
					}
					jiej3.put("users", us);
				}
				
				
				slaMap.put("jiej1", jiej1);
				slaMap.put("jiej2", jiej2);
				slaMap.put("jiej3", jiej3);
				
				return slaMap;
			}
		}
		
		return null;
	}

	
	

	@Override
	public void saveLevelSla(HttpServletRequest request) {
		String levelid = request.getParameter("levelid");
		String id = request.getParameter("id");
		String levelName = ConvertUtil.obj2Str(new SC_SLA(levelid).getBeanMapById().get("LEVEL_NAME"));
		String response_time = request.getParameter("response_time");
		String resolve_time = request.getParameter("resolve_time");
		
		
		String user1 = request.getParameter("user1");
		String userName1 = request.getParameter("userName1");
		
		SC_SLA_CONFIG config = new SC_SLA_CONFIG();
		config.setLevel_id(levelid).setLevel_name(levelName)
		.setResolve_time(ConvertUtil.obj2Integer(resolve_time))
		.setResponse_time(ConvertUtil.obj2Integer(response_time))
		.setDealer_type(2).setGroup_id("").setGroup_name("").setUser_id(user1).setUser_name(userName1);
		if(StringUtil.isEmpty(id)){
			config.setState(1).setType(2).insert();
		}else{
			config.setId(id).update();
		}
		
		String configId = config.getId();
		
		baseDao.execute("DELETE FROM SC_SLA_USER WHERE LEVEL_ID = :level_id", new SqlParameter("level_id",config.getId()));
		
		
		List<SqlParameter> paramList = new ArrayList<SqlParameter>();
		for(int i=2; i<=7; i++) {
			
			String time = request.getParameter("time"+i);
			if(StringUtil.notEmpty(time)) {
				String user = request.getParameter("user"+i);
				String userName = request.getParameter("userName"+i);
				SqlParameter param = new SqlParameter();
				param.put("id", StringUtil.getUUID());
				param.put("level_id",configId );
				if(i>4) {
					param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_RESOLVE_OVERTIME);
				} else {
					param.put("notice_type", Constants.SC_SLA_USER_NOTICE_TYPE_ANSWER_OVERTIME);
				}
				param.put("over_time", time);
				param.put("user_id", user);
				param.put("user_name", userName);
				param.put("type", "2");
				param.put("dealer_type", "2");
				param.put("group_id", "");
				param.put("group_name", "");
				paramList.add(param);
			}
		}
		
		if(paramList.size()>0) {
			String sql = "INSERT INTO SC_SLA_USER(ID,LEVEL_ID,NOTICE_TYPE,OVER_TIME,USER_ID,USER_NAME,TYPE,DEALER_TYPE,GROUP_ID,GROUP_NAME) VALUES(:id,:level_id,:notice_type,:over_time,:user_id,:user_name,:type,:dealer_type,:group_id,:group_name)";
			baseDao.executeBatch(sql, paramList);
		}
		
	}
	
	@Override
	public Map querySlaUser(String customerId, String threeId,String secondId,int level) {
		if(StringUtil.notEmpty(customerId)) {
			if(level == 3) {
				Map map = getSlaUser(customerId,threeId);
				
				if(null!=map && map.size()>0) {
					if(ConvertUtil.obj2Integer(map.get("count"))==1){
						map.put("isSelf", 1);
						return map;
					}
				}
				
				map = querySlaUser(customerId, threeId,secondId, 2);
				if(null!=map && map.size()>0) {
					if(ConvertUtil.obj2Integer(map.get("count"))==1){
						map.put("isSelf", 2);
						return map;
					}
				}
			}
			
			if(level == 2) {
				
				Map map = getSlaUser(customerId,secondId);
					
				if(null!=map && map.size()>0) {
					if(ConvertUtil.obj2Integer(map.get("count"))==1){
						map.put("isSelf", 1);
						return map;
					}
				}
				
				if(StringUtil.notEmpty(threeId)) {
					map = querySlaUser("",threeId,secondId,3);
					if(null!=map && map.size()>0) {
						if(ConvertUtil.obj2Integer(map.get("count"))==1){
							map.put("isSelf", 2);
							return map;
						}
					}
				}
				
				map = querySlaUser("","",secondId,2);
				if(null!=map && map.size()>0) {
					if(ConvertUtil.obj2Integer(map.get("count"))==1){
						map.put("isSelf", 2);
						return map;
					}
				}
			}
		} 
		
		if(level == 3) {
			Map map = getSlaUser(customerId,threeId);
			if(null!=map && map.size()>0) {
				if(ConvertUtil.obj2Integer(map.get("count"))==1){
					map.put("isSelf", 1);
					return map;
				}
			}
				
			map = querySlaUser(customerId,"", secondId, 2);
			if(null!=map && map.size()>0) {
				if(ConvertUtil.obj2Integer(map.get("count"))==1){
					map.put("isSelf", 2);
					return map;
				}
			}
				
		}
		
		if(level == 2) {
			Map map = getSlaUser(customerId,secondId);
			if(null!=map && map.size()>0) {
				map.put("isSelf", 1);
				return map;
			}	
			
		}
		
		return new HashMap();
	}
	
	public Map getSlaUser(String customerId,String cateId){
		int count = 0;
		Map param = new HashMap();
		param.put("cateId", cateId);
		param.put("customerId", customerId);
		String groupsql = "SELECT A.* FROM AC_ROLE_GROUP A,AC_ROLE B WHERE A.JSBH = B.ID AND A.STATE = 1 AND B.IDENTIFY = :identify ";
		String usersql = "SELECT A.* FROM GG_USER A,AC_USER_REF_ROLE B,AC_ROLE C WHERE A.ID = B.YHBH AND B.JSBH = C.ID AND A.ZT = 1 AND C.IDENTIFY = :identify ";
		StringBuilder sql = new StringBuilder("(SELECT A.* FROM SC_SERVCE_CATEGORY_USER A,AC_ROLE B WHERE A.GROUP_ID = B.ID AND B.IDENTIFY = :identify AND A.CATEGORY_ID = :cateId "); 
		if(StringUtil.isEmpty(customerId)){
			sql.append(" AND A.CUSTOMER_ID IS NULL  ");
		}else{
			sql.append(" AND A.CUSTOMER_ID =:customerId ");
		}
		sql.append("  ) UNION ALL (SELECT C.* FROM SC_SERVCE_CATEGORY_USER C,AC_ROLE_GROUP D,AC_ROLE E WHERE C.GROUP_ID = D.ID AND D.JSBH = E.ID AND E.IDENTIFY = :identify AND C.CATEGORY_ID = :cateId  ");
		if(StringUtil.isEmpty(customerId)){
			sql.append(" AND C.CUSTOMER_ID IS NULL  ");
		}else{
			sql.append(" AND C.CUSTOMER_ID =:customerId ");
		}
		sql.append(" ) ");
		param.put("identify", Constants.ROLE_FLINE);
		Map yxMap = baseDao.queryForMap(sql.toString(), param);
		if(yxMap!=null && yxMap.size() > 0){
			count = 1;
		}
		List<Map> groupList = baseDao.queryForList(groupsql, param);
		List<Map> userList = baseDao.queryForList(usersql, param);
		yxMap.put("groupList", groupList);
		yxMap.put("userList", userList);
		
		param.put("identify", Constants.ROLE_SLINE);
		Map exMap = baseDao.queryForMap(sql.toString(), param);
		if(exMap!=null && exMap.size() > 0){
			count = 1;
		}
		List<Map> egroupList = baseDao.queryForList(groupsql, param);
		List<Map> euserList = baseDao.queryForList(usersql, param);
		exMap.put("groupList", egroupList);
		exMap.put("userList", euserList);
		
		param.put("identify", Constants.ROLE_TLINE);
		Map sxMap = baseDao.queryForMap(sql.toString(), param);
		if(sxMap!=null && sxMap.size() > 0){
			count = 1;
		}
		List<Map> sgroupList = baseDao.queryForList(groupsql, param);
		List<Map> suserList = baseDao.queryForList(usersql, param);
		sxMap.put("groupList", sgroupList);
		sxMap.put("userList", suserList);
		Map result = new HashMap();
		result.put("yxMap", yxMap);
		result.put("exMap", exMap);
		result.put("sxMap", sxMap);
		result.put("count", count);
		return result;
	}

	@Override
	public int deleteLevelSla(String id) {
		Map param = new HashMap();
		param.put("id", id);
		String sql = "SELECT COUNT(ID) FROM SC_SLA_CONFIG WHERE LEVEL_ID = :id";
		int count = baseDao.queryForInteger(sql, param);
		if(count == 0){
			SC_SLA cate = new SC_SLA();
			cate.setId(id).setState(2).update();
		}
		return count;
	}
}